为什么死锁不会发生

Question

死锁描述了另外两个线程因为永远等待对方而被阻塞的情况。当死锁发生时，程序永远挂起，你唯一能做的就是杀死程序。

为什么在下面给出的示例生产者-消费者问题中没有发生死锁：

我想知道为什么当同步对象正在等待其他线程释放锁时，在同步块中调用等待方法不会导致死锁？

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class WaitAndNotify {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        var th1 = new Thread(new Producer(list));
        var th2 = new Thread(new Consumer(list));
        th1.start();
        th2.start();
    }
}

class Producer implements Runnable {

    private List<Integer> list;
    private final Integer MAX_SIZE_LIST = 5;

    public Producer(List<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        Random rand = new Random();
        for (;;) {
            synchronized (this.list) {
                if (list.size() == MAX_SIZE_LIST) { // check list is full or not
                    try {
                        System.out.println("list full wait producer");
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                var randNumber = rand.nextInt();
                System.out.println("produce number => " + randNumber);
                list.add(randNumber);
                list.notify();
            }
        }
    }

}

class Consumer implements Runnable {

    private List<Integer> list;

    public Consumer(List<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        for (;;) {
            synchronized (this.list) {
                if (list.size() == 0) {
                    try {
                        System.out.println("list empty consumer wait");
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("consume number <= " + list.remove(0));
                list.notify();
            }
        }
    }
}

Answer 1

正如我们已经在这里讨论过的，死锁没有发生，因为使用了同步块，列表.wait（）和list.notify（）方法。

这是一个很好的死锁示例：https://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html

Answer 2

你可能会认为，使用者将在 list.wait（） 处阻止，而生产者将在同步（此列表）处阻止。

这是可行的，因为< code>list.wait()在< code>synchronized块中释放了< code>list的所有权。在< code>wait返回后，线程再次获得所有权。

见Object.wait（）