没有 Thread.sleep，死锁实现就无法工作

Question

我正在尝试了解死锁并相应地尝试创建死锁的实现。这个想法是创建一个循环锁定的模拟。这是我的 Runnable 实现：

public class WorkDelegator implements Runnable {

private static final Logger LOGGER = Logger.getGlobal();

WorkDelegator workDelegatorSupplier;
private final String name;

public WorkDelegator(String name) {
    this.name = name;
}

public void setWorkDelegatorSupplier(WorkDelegator workDelegatorSupplier) {
    this.workDelegatorSupplier = workDelegatorSupplier;
}

public void delegate(){

    synchronized (workDelegatorSupplier) {
//            try {
//                Thread.sleep(300);
//            } catch (InterruptedException e) {
//                LOGGER.warning("InterruptedException in Task " + name);
//            }
        workDelegatorSupplier.delegate();
    }
    LOGGER.info("task delegated from " + name + "to " + workDelegatorSupplier);
}

@Override
public void run() {
    LOGGER.info(this + " is trying to delegate task to " + workDelegatorSupplier);
    delegate();
}
}

一堆 WorkDelegator 个实例通过调用 delegate void 循环委派彼此的工作。关键是如果注释掉的代码也在执行，它也能正常工作，但为什么我得到 WhosebugError 没有线程休眠？

PS - 委托工厂 class:

public class WorkDelegatorFactory {

public List<WorkDelegator> getDelegatorsList(int size) {

    List<WorkDelegator> workDelegatorList = new ArrayList<>();
    for (int i = 0; i < size ; i++) {
        workDelegatorList.add(new WorkDelegator(String.valueOf(i)));
    }
    WorkDelegator firstDelegator = workDelegatorList.get(0);
    WorkDelegator lastDelegator = workDelegatorList.get(size-1);
    lastDelegator.setWorkDelegatorSupplier(firstDelegator);
    for (int i = 0; i < size-1; i++) {
        workDelegatorList.get(i).setWorkDelegatorSupplier(workDelegatorList.get(i+1));
    }
    return workDelegatorList;
}
}

Answer 1

如果没有 sleep，第一个启动的线程可以在其他线程启动之前进行大量递归调用。这允许他们获取足够的同步锁以无限期地继续并最终运行超出堆栈深度。其他线程开始到达太晚，无法获取它们的第一个同步锁并处于空闲状态。

使用 sleep 每个线程只能获取一个同步锁，没有线程可以超前到可以循环的程度。

您所看到的是并发编程的难点之一：您知道每个线程中的顺序，但不知道每个线程相对于其他线程的位置。

没有 Thread.sleep，死锁实现就无法工作

Deadlock implementation doesn't work without Thread.sleep

java

concurrency

multithreading

deadlock