什么是线程死锁以及如何避免死锁

还有一个需要注意的一个问题就是，如果一个线程获取到了锁并进入的临界区，此时如果因为异常而终止整个线程，如果这个线程在终止的时候无法处理这个被锁住的资源，那其他线程都会因此被阻塞，也就是所谓的死锁。非分离的线程终止时，其线程id和退出状态将保留，直到另外一个线程调用pthread_join.分离的线程在当它终止时，所有的资源将释放，我们不能等待它终止。对互斥量加锁后，其他线程试图对互斥量加锁时都会被阻塞直到互斥量的锁释放（注意如果线程试图对同一个互斥量加锁两次，那么它自身就会陷入阻塞多线程如何避免死锁，即死锁状态。

①、死锁：线程a占有资源a，线程b占有资源b，线程a申请占有资源b，同时要求占有资源b之后才释放资源a，而线程b申请占有资源a，同时要求占有资源a之后才释放资源b，这样两个线程互相永久等待对方释放资源，这就是死锁。②、循环死锁：线程a占有资源a，线程b占有资源b，线程c占有资源c，线程a申请占有资源b，同时要求占有资源b之后才释放资源a，而线程b申请占有资源c，同时要求占有资源c之后才释放资源b，线程c申请占有资源a，同时要求占有资源a之后才释放资源c，这样线程互相永久等待对方释放资源，这就是循环死锁。1 定义： 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，形成线程的死锁。

线程死锁

下面通过一个例子来说明线程死锁，代码模拟了上图的死锁情况 (源于《并发编程之美》)：

public class DeadLockDemo {
    private static Object resource1 = new Object();//资源 1
    private static Object resource2 = new Object();//资源 2
    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (resource1) {
                System.out.println(Thread.currentThread() + "get resource1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource2");
                synchronized (resource2) {
                    System.out.println(Thread.currentThread() + "get resource2");
                }
            }
        }, "线程 1").start();
        new Thread(() -> {
            synchronized (resource2) {
                System.out.println(Thread.currentThread() + "get resource2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource1");
                synchronized (resource1) {
                    System.out.println(Thread.currentThread() + "get resource1");
                }
            }
        }, "线程 2").start();
    }
}

Output：

Thread[线程 1,5,main]get resource1
Thread[线程 2,5,main]get resource2
Thread[线程 1,5,main]waiting get resource2
Thread[线程 2,5,main]waiting get resource1

sleep()方法（休眠）是线程类（thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（cpu）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态)。上面的例子非常简单，就不再介绍了，需要提出的是在使用互斥锁的过程中很有可能会出现死锁：两个线程试图同时占用两个资源，并按不同的次序锁定相应的互斥锁，例如两个线程都需要锁定互斥锁1和互斥锁2，a线程先锁定互斥锁1，b线程先锁定互斥锁2，这时就出现了死锁。一个经典的例子就是ab锁问题，线程1获取到了共享数据a的锁，同时线程2获取到了共享数据b的锁，此时线程1想要去获取共享数据b的锁，线程2获取共享数据a的锁。

学过操作系统的朋友都知道，产生死锁必须具备以下四个条件：

互斥条件：该资源任意一个时刻只由一个线程占用；

请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源持有不释放；

不剥夺条件：线程已获得的资源，在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源；

循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

同理，只要任意破坏产生死锁的四个条件中的其中一个就可以了：

1. 破坏互斥条件

该条件没有办法破坏，因为用锁的意义本来就是想让他们互斥的（临界资源需要互斥访问）；

2. 破坏请求与保持条件

一次性申请所有的资源；

3. 破坏不剥夺条件

占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源；

4. 破坏循环等待条件

靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。

对线程 2 的代码修改成下面这样，就不会产生死锁了：

        new Thread(() -> {
            synchronized (resource1) {
                System.out.println(Thread.currentThread() + "get resource1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource2");
                synchronized (resource2) {
                    System.out.println(Thread.currentThread() + "get resource2");
                }
            }
        }, "线程 2").start();

Output：

Thread[线程 1,5,main]get resource1
Thread[线程 1,5,main]waiting get resource2
Thread[线程 1,5,main]get resource2
Thread[线程 2,5,main]get resource1
Thread[线程 2,5,main]waiting get resource2
Thread[线程 2,5,main]get resource2
Process finished with exit code 0

我们分析一下上面的代码为什么能避免死锁的发生?

同步嵌套是产生死锁的常见情景，从上面的代码中我们可以看出，当t1线程拿到锁a后，睡眠2秒，此时线程t2刚好拿到了b锁，接着要获取a锁，但是此时a锁正好被t1线程持有，因此只能等待t1线程释放锁a，但遗憾的是在t1线程内又要求获取到b锁，而b锁此时又被t2线程持有，到此结果就是t1线程拿到了锁a同时在等待t2线程释放锁b，而t2线程获取到了锁b也同时在等待t1线程释放锁a，彼此等待也就造成了线程死锁问题。羊群效应（herd effect）：在分布式锁中，羊群效应指的是，在有多个请求等待获取锁的时候，一旦占有锁的线程释放之后，如果所有等待的方都同时被唤醒，尝试抢占锁。（3）线程2的run)(方法中同步代码块先获取lock2的对象锁多线程如何避免死锁，接着获取lock1的对象锁，当然这时lock1的对象锁已经被线程1锁持有，线程2肯定是要等待线程1释放lock1的对象锁的。

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-114014-1.html