目录

1. 问题引入

2.死锁问题的概念和原因

 3. 解决死锁问题

---

1. 问题引入

在学习死锁之前, 我们先观察下面的代码能否输出正确的结果:

运行程序, 能正常输出结果:

这个代码只管上看起来, 好像是有锁冲突的, 此时的 locker 对象已经是加锁的状态, 在尝试对 locker 加锁, 不应该会出现阻塞问题吗?

其实, 问题的关键是,这两次加锁, 其实是在同一个线程上进行的.  由于是同一个线程, 此时锁对象就知道了第二次加锁的线程,  第二次加锁操作就可以直接放行通过, 不会出现阻塞.  这个特性称为 "可重入". 

使用可重入锁, 可以避免代码出现死锁问题, 如果使用的不是可重入锁, 就会出现死锁问题.

2.死锁问题的概念和原因

Java多线程中的死锁问题是指两个或多个线程互相持有对方所需的资源而无法继续执行的情况。这种情况下，线程无法释放已经占有的资源，也无法获取自己所需的资源，导致程序无法继续执行下去。

通常，发生死锁问题需要满足以下四个条件：

1. 互斥条件（Mutual exclusion）：至少有一个资源同时只能被一个线程占用。
2. 请求与保持条件（Hold and wait）：线程至少已经占有一个资源，并且正在请求另一个被其他线程占用的资源。
3. 不可剥夺条件（No preemption）：已经分配给一个线程的资源不能被强制剥夺。
4. 循环等待条件（Circular wait）：存在一个线程链，每个线程都在等待下一个线程所占有的资源。

死锁的例子:

线程1获取到锁A, 线程2获取到锁B, 接下来, 线程1尝试获取锁 B, 线程2尝试获取锁A, 此时出现了死锁问题:  

package thread;

public class ThreadDemo22 {
    public static void main(String[] args) {
        Object A = new Object();
        Object B = new Object();
        Thread t1 = new Thread(()-> {
           synchronized (A) {
               // sleep 是为了t2时间, 让t2也能拿到 B
               try {
                   Thread.sleep(1000);
               }catch (InterruptedException e) {
                   e.printStackTrace();
               }

               //尝试获取B, 并没有释放 A
               synchronized (B) {
                   System.out.println("t1拿到了两把锁");
               }
           }
        });

        Thread t2 = new Thread(()->{
            synchronized (B) {
                // sleep 是给t1时间, 让t1能拿到 A
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //尝试获取A, 并没有释放 B
                synchronized (A) {
                    System.out.println("t2拿到了两把锁");
                }
            }
        });

        t1.start();
        t2.start();
    }
}

 程序没有任何输出结果:

 3. 解决死锁问题

为了避免死锁问题，可以采取以下策略：

1. 避免使用多个锁：尽量减少使用多个锁，如果必须使用多个锁，确保获取锁的顺序是一致的，以减少死锁的可能性。
2. 加锁顺序：多个线程获取锁的顺序要保持一致，避免出现循环等待条件。
3. 加锁时限：在获取锁的时候设置超时时间，如果一段时间内没有获取到锁，就放弃当前的操作，释放已经持有的锁，避免长时间等待导致死锁。
4. 死锁检测：通过监控线程的状态和资源的使用情况，及时检测并解决潜在的死锁问题。

对于死锁例子, 我们可以使两个线程的取锁顺序保持一致:

package thread;

public class ThreadDemo22 {
    public static void main(String[] args) {
        Object A = new Object();
        Object B = new Object();
        Thread t1 = new Thread(()-> {
           synchronized (A) {
               // sleep 是为了t2时间, 让t2也能拿到 B
               try {
                   Thread.sleep(1000);
               }catch (InterruptedException e) {
                   e.printStackTrace();
               }

               //尝试获取B, 并没有释放 A
               synchronized (B) {
                   System.out.println("t1拿到了两把锁");
               }
           }
        });

        Thread t2 = new Thread(()->{
            synchronized (A) {
                // sleep 是给t1时间, 让t1能拿到 A
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //尝试获取A, 并没有释放 B
                synchronized (B) {
                    System.out.println("t2拿到了两把锁");
                }
            }
        });

        t1.start();
        t2.start();
    }
}