Java SE入门及基础（61）& 死锁 & 死锁发生条件

目录

死锁

1. 死锁的概念

2. 死锁发生条件

互斥条件

不可剥夺条件

请求与保持条件

循环等待

3. 案例分析

示例

分析

---

死锁

1. 死锁的概念

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

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

2. 死锁发生条件

互斥条件

        线程要求对所分配的资源进行排他性控制，即在一段时间内某资源仅为一个线程所占有。此时若有其他线程请求该资源，则请求线程只能等待。

不可剥夺条件

        线程所获得的资源在未使用完毕之前，不能被其他线程强行夺走，即只能由获得该资源的线程自己来释放（只能是主动释放)。

请求与保持条件

        线程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他线程占有，此时请求线程被阻塞，但对自己已获得的资源保持不放。

循环等待

        存在一种线程资源的循环等待链，链中每一个线程已获得的资源同时被链中下一个线程所请求。

3. 案例分析

示例

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 上的锁释放。