线程死锁

2021-03-16

线程死锁的条件

互斥条件：该资源任意一时刻只由一个线程占用。
请求与保持条件：某线程因为请求资源而发生阻塞时，对于已经获得的资源保持不放。
不可剥夺条件：线程已经获得的资源在未使用之前不能被其他线程强行剥夺，只有自己使用完之后才释放资源。
循环等待条件：多个线程之间形成一种头尾相接的循环等待资源关系。

死锁演示

public class Test {

    private static final Object o1 = new Object();
    private static final Object o2 = new Object();

    public static void main(String[] args) {

        new Thread(() -> {
            synchronized (o1) {
                System.out.println(Thread.currentThread() + "get o1");

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread() + "waiting get o2");
                synchronized (o2) {
                    System.out.println(Thread.currentThread() + "get o2");
                }
            }
        }, "线程1").start();

        new Thread(() -> {
            synchronized (o2) {
                System.out.println(Thread.currentThread() + "get o2");

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread() + "waiting get o1");
                synchronized (o1) {
                    System.out.println(Thread.currentThread() + "get o1");
                }
            }
        }, "线程2").start();
    }
}

Thread[线程1,5,main]get o1
Thread[线程2,5,main]get o2
Thread[线程2,5,main]waiting get o1
Thread[线程1,5,main]waiting get o2

避免死锁

破坏互斥条件：这个条件我们没有办法破坏，因为我们⽤锁本来就是想让他们互斥的（临界资
源需要互斥访问）。
破坏请求与保持条件：⼀次性申请所有的资源。
破坏不剥夺条件：占⽤部分资源的线程进⼀步申请其他资源时，如果申请不到，可以主动释放
它占有的资源。
破坏循环等待条件：靠按序申请资源来预防。按某⼀顺序申请资源，释放资源则反序释放。破
坏循环等待条件。

破坏循环等待条件来避免死锁

public class Test {

    private static final Object o1 = new Object();
    private static final Object o2 = new Object();

    public static void main(String[] args) {

        new Thread(() -> {
            synchronized (o1) {
                System.out.println(Thread.currentThread() + "get o1");

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread() + "waiting get o2");
                synchronized (o2) {
                    System.out.println(Thread.currentThread() + "get o2");
                }
            }
        }, "线程1").start();

        new Thread(() -> {
            synchronized (o1) {
                System.out.println(Thread.currentThread() + "get o1");

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread() + "waiting get o2");
                synchronized (o2) {
                    System.out.println(Thread.currentThread() + "get o2");
                }
            }
        }, "线程2").start();
    }
}

Thread[线程1,5,main]get o1
Thread[线程1,5,main]waiting get o2
Thread[线程1,5,main]get o2
Thread[线程2,5,main]get o1
Thread[线程2,5,main]waiting get o2
Thread[线程2,5,main]get o2