多线程的死锁问题

---

一.什么是死锁

死锁大概的意思说几句是多个线程，它们中的一个或多个全部在等待某个资源被释放，由于线程被无限期地被阻塞，因此程序不可能被终止。

二.死锁的场景

场景一

1.一个线程,一把锁(上面的情况)，可重入锁没事,不可重入锁死锁.
我举一个生活的场景,大家或许就明白了
假设一个人要进入一间有锁的房间，并且需要一把钥匙才能打开门。该人带着钥匙进入房间，但是发现房间里面还有一个抽屉是上锁的，他需要再次获取钥匙才能打开抽屉。如果该人使用的是可重入锁，那么他可以再次获取钥匙，打开抽屉并完成他需要的工作。但是，如果该人使用的是不可重入锁，那么当他再次获取钥匙时，由于他已经持有了钥匙，锁就会因为重复获取锁而出现死锁的情况。

场景二

2.两个线程两把锁,即使是可重入锁,也会死锁
情况如下

场景三

3.N个线程,M把锁.
线程数量和锁数量更多了,就更容易死锁了!!

产生死锁的原因是
假设同一时刻, 五个 哲 学 家 同时拿起左手边的筷子, 然后再尝试拿右手的筷子, 就会
发现右手的筷子都被占用了. 由于 哲 学 家 们互不相让, 这个时候就形成了 死锁

这里做一个小小的总结

死锁的四个必要条件
1.互斥使用.一个线程拿到一把锁之后,另一个线程不能使用.(锁的基本特点)
2.不可抢占.一个线程拿到锁,只能自己主动释放,不能是被其他线程强行占有挖墙脚是不行滴](锁的基本特点)
3.请求和保持﹑“吃着碗里的，惦记锅里的’追到了1号女神之后，又对2号女神跃跃欲试。但是此时是绝不会放弃1号女神的(代码的特点)
4.循环等待. 上面例子中的情况。逻辑依赖循环的.“钥匙锁车里了,车钥匙锁家里了”

三.如何避免死锁

我这里给出来了几种方案,大家可以参考参考
1.避免一个线程同时获取多个锁：如果一个线程在获取一个锁的同时还要获取另一个锁，那么就容易出现死锁。因此，尽量避免一个线程同时获取多个锁，可以通过对锁进行排序，按照一定的顺序获取锁来避免死锁。

2.加锁时限制时间：如果一个线程获取一个锁的时间超过了一定的阈值，那么就放弃对该锁的获取，释放已经获取的锁，并等待一段时间后再进行重试。

3.使用tryLock()方法：在使用 ReentrantLock 锁时，可以使用其 tryLock() 方法来尝试获取锁，如果获取不到就立即返回 false，避免死锁和线程等待的情况。

4.使用读写锁：在读写操作较多的场景下，可以使用读写锁来代替互斥锁，读写锁可以允许多个线程同时读取共享资源，但只允许一个线程进行写入操作。

5.合理设计锁粒度：锁粒度太粗会导致效率低下，而锁粒度太细会增加线程间的竞争，导致死锁的发生。因此，在设计锁粒度时需要综合考虑业务逻辑和性能要求，避免死锁的发生。

当然这上面的思路都很好,我这下面提供了一种思路,可以看一下,如果我们去获取锁的时候,此时约定,先加锁小的编号,后加锁大的编号
此时只要所有线程都遵守这个顺序就行了!!!

如果还是没有理解,我们这里可以直接上一个伪代码,去理解一下.
这里的俩个线程就加锁的顺序没有约定,就容易产生环路等待

Object lock1 = new Object();
Object lock2 = new Object();
Thread t1 = new Thread() {
    @Override
    public void run() {
        synchronized (lock1) {
            synchronized (lock2) {
                // do something...
           }
       }
   }
};
t1.start();
Thread t2 = new Thread() {
    @Override
    public void run() {
        synchronized (lock2) {
            synchronized (lock1) {
                // do something...
           }
       }
   }
};
t2.start();

不会产生环路等待的代码:

Object lock1 = new Object();
Object lock2 = new Object();
Thread t1 = new Thread() {
    @Override
    public void run() {
        synchronized (lock1) {
            synchronized (lock2) {
                // do something...
           }
       }
   }
};
t1.start();
Thread t2 = new Thread() {
    @Override
    public void run() {
        synchronized (lock1) {
            synchronized (lock2) {
                // do something...
           }
       }
   }

};
t2.start();

这里就约定好了,加锁的顺序,就不会产生死锁的问题.