Java并发编程(八)线程死锁

逆流者 2021年02月21日 29次浏览

什么是线程死锁

死锁是指两个或两个以上的线程在执行过程中,因争夺资源而造成的互相等待的现象,在无外力作用的情况下,这些线程会一直相互等待而无法继续运行下去.
线程死锁
图中的两个线程各持有一个资源占有不释放, 又想去获取对方持有的资源, 造成两个线程一直等待对方释放, 造成了死锁.

死锁的产生须具备四个条件

  • 互斥条件∶ 指线程对已经获取到的资源进行排它性使用,即该资源同时只由一个线程占用。如果此时还有其他线程请求获取该资源,则请求者只能等待,直至占有资源的线程释放该资源。
  • 请求并持有条件∶ 指一个线程已经持有了至少一个资源,但又提出了新的资源请求,而新资源已被其他线程占有,所以当前线程会被阻塞,但阻塞的同时并不释放自己已经获取的资源。
  • 不可剥夺条件∶ 指线程获取到的资源在自己使用完之前不能被其他线程抢占,只有
    在自己使用完毕后才由自己释放该资源。
  • 环路等待条件∶ 指在发生死锁时,必然存在一个线程一资源的环形链,即线程集合{T0,T1,T2,…,Tn)中的T0正在等待一个T1占用的资源,T1正在等待T2占用的资源,……Tn 正在等待己被 T0 占用的资源。

一个线程死锁的例子

下面通过一个例子来说明线程死锁。

public class DeadLockTest {

    private static Object resourceA = new Object();
    private static Object resourceB = new Object();

    public static void main(String[] args) {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceA) {
                    System.out.println(Thread.currentThread() + " get ResourceA");

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

                    System.out.println(Thread.currentThread() + " waiting get ResourceB");

                    synchronized (resourceB) {
                        System.out.println(Thread.currentThread() + " get ResourceB");
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceB) {
                    System.out.println(Thread.currentThread() + " get ResourceB");

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

                    System.out.println(Thread.currentThread() + " waiting get ResourceA");

                    synchronized (resourceA) {
                        System.out.println(Thread.currentThread() + " get ResourceA");
                    }
                }
            }
        });

        // 启动线程
        threadA.start();
        threadB.start();
    }

}
Thread[Thread-0,5,main] get ResourceA
Thread[Thread-1,5,main] get ResourceB
Thread[Thread-0,5,main] waiting get ResourceB
Thread[Thread-1,5,main] waiting get ResourceA

看执行结果, 两个线程都在等待对方释放资源, 双方都不释放, 造成了死锁!

如何避免线程死锁

要想避免死锁,只需要破坏掉至少一个构造死锁的必要条件即可,由于操作系统的设定,目前只有请求并持有和环路等待条件是可以被破坏的。

造成死锁的原因其实和申请资源的顺序有很大关系,使用资源申请的有序性原则就可以避免死锁.

修改下上面线程死锁的例子(改变 threadB 获取资源的顺序):

public class DeadLockTest2 {

    private static Object resourceA = new Object();
    private static Object resourceB = new Object();

    public static void main(String[] args) {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceA) {
                    System.out.println(Thread.currentThread() + " get ResourceA");

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

                    System.out.println(Thread.currentThread() + " waiting get ResourceB");

                    synchronized (resourceB) {
                        System.out.println(Thread.currentThread() + " get ResourceB");
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceA) {
                    System.out.println(Thread.currentThread() + " get resourceA");

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

                    System.out.println(Thread.currentThread() + " waiting get ResourceB");

                    synchronized (resourceB) {
                        System.out.println(Thread.currentThread() + " get ResourceB");
                    }
                }
            }
        });

        // 启动线程
        threadA.start();
        threadB.start();
    }

}
Thread[Thread-0,5,main] get ResourceA
Thread[Thread-0,5,main] waiting get ResourceB
Thread[Thread-0,5,main] get ResourceB
Thread[Thread-1,5,main] get resourceA
Thread[Thread-1,5,main] waiting get ResourceB
Thread[Thread-1,5,main] get ResourceB

看执行结果, threadA 线程执行完, threadA 线程才执行, 避免了线程死锁!