目录

死锁

1. 死锁的概念

2. 死锁发生条件

互斥条件

不可剥夺条件

请求与保持条件

循环等待

3. 案例分析

示例

分析

---

死锁

1. 死锁的概念

        Deadlock describes a situation where two or more threads are blocked forever, waiting for each other

        死锁描述了一种情况，其中两个或多个线程永远被阻塞，互相等待

public class DeadLockTest {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        DeadLockTask task1 = new DeadLockTask(o1, o2, 0);
        DeadLockTask task2 = new DeadLockTask(o1, o2, 1);
        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);
        t1.start();
        t2.start();
    }
    static class DeadLockTask implements Runnable{
        private Object o1, o2;
        private int flag; //锁使用的条件
        public DeadLockTask(Object o1, Object o2, int flag) {
            this.o1 = o1;
            this.o2 = o2;
            this.flag = flag;
        }
        @Override
        public void run() {
            String name = Thread.currentThread().getName();
            if(flag == 0){
                synchronized (o1){
                    System.out.println(name + "锁定对象o1");
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (o2){
                        System.out.println(name + "锁定对象o2");
                    }
                }
            } else {
                synchronized (o2){
                    System.out.println(name + "锁定对象o2");
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (o1){
                        System.out.println(name + "锁定对象o1");
                    }
                }
            }
        }
    }
}

        线程t1 开始执行，首先会将持有对象 o1 的锁，然后开始睡眠 0.5 秒，此时，线程 t2 开始执行，首先会持 有对象o2 的锁，然后开始睡眠 0.5 秒。

        线程t1 睡眠结束，尝试获得对象 o2 的锁，此时发现对象 o2 已经被其他线程 t2 锁住，此时 t1 被阻塞在外，等待对象o2 上的锁释放。

        线程t2 睡眠结束，尝试获得对象 o1 的锁，此时发现对象 o1 已经被其他线程 t1 锁住，此时 t2 被阻塞在外，等待对象o1 上的锁释放。