JAVA 并发编程之死锁的产生及避免

死锁的产生

死锁可以理解为，在多线程并发竞争资源的环境下，在各自拥有锁的情况下，又去尝试获取对方的锁，从而造成的一种阻塞的现象，若无外力作用，它们都将一直阻塞下去。

 

 代码示例：

public class ThreadTest {
    public static void main(String[] args) {
        Object lockA = new Object();
        Object lockB = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程1：获得锁A。");
                try {
                    TimeUnit.SECONDS.sleep(1);//让线程2有时间先占有锁B
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockB) {
                    System.out.println("线程1：获得锁B。");
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("线程2：获得了锁B");
                try {
                    TimeUnit.SECONDS.sleep(1);//保证线程1能有充足的时间得到锁A
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockA) {
                    System.out.println("线程2：获得了锁A");
                }
            }
        });
        t2.start();
 }}

join()方法的死锁

我们都知道 ，join方法的作用是阻塞线程，即当前线程等待挂起的线程执行结束，才继续执行。

但是，在thread类的join方法中，有一个坑，如下：

Thread.currentThread().join();

如果线程自身调用了调用join()这个方法，表示，自身挂起自身，那么线程将一直在阻塞。

因为它自己在等待自己结束，这无疑会造成死锁。

---

死锁产生的条件

①互斥条件：一个资源只能被一个线程占有，当这个资源被占用后其他线程就只能等待。

②不可剥夺条件：当一个线程不主动释放资源时，此资源一直被拥有线程占有。

③请求并持有条件：线程已经拥有一个资源后仍然不满足，又尝试请求新的资源。 

④环路等待条件：产生死锁一定是发生了线程资源环路链。

 

---

避免死锁的发生

根据以上死锁产生的必要条件我们得知，只需改变任意一个或多个条件就可以避免死锁问题。

由于前两个条件是客观规则不允许被修改，而后两个条件是主观意图可以被修改。

禁止请求并持有条件

当线程在持用锁的情况下，就不再去请求获取另一把锁。代码示例如下：

    Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程1：获得锁A。");
               // synchronized (lockB) {
               //     System.out.println("线程1：获得锁B。");
               //}
            }
    });

破坏环路等待条件

假如有两个资源锁A和B，多线程尝试获取锁的顺序要严格按照先获取A再获取B。

        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程1：获得锁A。");
                //业务代码...
                synchronized (lockB) {
                    System.out.println("线程1：获得锁B。");
                }
            }
        });
        Thread t2 = new Thread(() -> {
              synchronized (lockA) {
                System.out.println("线程1：获得锁A。");
                //业务代码...
                synchronized (lockB) {
                    System.out.println("线程1：获得锁B。");
                }
            }
        });