线程中的死锁问题

三种典型的死锁场景

一个线程一把锁

就像在上一篇文章所说的,不是所有锁都可以进行可重入的,
如果一个锁是不可重入的锁,并且一个线程对这锁进行了两次加锁,那么这种情况就会发生死锁

两个线程,两把锁

一个线程1 ,获取了锁a
线程2,获取到了锁b
接下来,线程1在获取到了锁啊的情况下,又想获取锁b
线程2在获取到了锁b的情况下,又想获取锁a,这个时候,线程就会卡住了,无法继续工作

可以说,加锁是属于程序中,最严重的一类bug

public class TreadDemo {
    public static void main(String[] args) {
        Object object = new Object();
        Object locker = new Object();
        Thread t1 = new Thread(() ->{
           synchronized (object){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               synchronized (locker){
                   System.out.println("t1拿了两把锁");
               }
           }
        });
        Thread t2 = new Thread(() ->{
           synchronized (locker){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               synchronized (object){
                   System.out.println("t2拿到了两把锁");
               }
           }
        });
         t1.start();
        t2.start();
    }
}

这就是死锁情况的代码

卡住了就会出现这种情况
这个时候就是t1和t2都卡在了system那一行都出不来了,因为他们都想得到对方手里的a或者b,所以就卡那里,动不了了
这个时候,我们只要改变其中一个代码的加锁顺序就可以正常运行了

public class TreadDemo {
    public static void main(String[] args) {
        Object object = new Object();
        Object locker = new Object();
        Thread t1 = new Thread(() ->{
           synchronized (object){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               synchronized (locker){
                   System.out.println("t1拿了两把锁");
               }
           }
        });
        Thread t2 = new Thread(() ->{
            synchronized (object){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker){
                    System.out.println("t2拿到了两把锁");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

就像t2中,我们把原来的先加locker锁再加object锁,顺序替换一下,改成了先加object,再加locker

最后也就可以正常运行了

N个线程,M把锁

这种情况就比较特殊了,要有请我们的滑稽助教,掌声欢迎!!!

这里情况是这样的,我们把滑稽看做线程,筷子看做锁.
这里面由于只有四根筷子,所以我们的滑稽在想吃面时候,需要从左边拿一根,右边拿一根,这样才可以凑成一双吃面条,当一个滑稽吃完的时候,就会放下,然后另一个滑稽拿筷子吃,因为滑稽们是著名哲学家,除了吃面还要进行思考!!!
但是总有意外发生,有一天,他们四个同时想吃面条,这时候他们同时拿起了自己的一根筷子,可是一根吃不了面的,但是他们又互不谦让,就一直僵持着,吃不了面
线程也就卡住了,发生了死锁

像3这种情况,大多数是不会有问题的,但是在极端情况下聚会出现这种同时抢夺的死锁问题,由于不好遇见,没法演示

产生死锁的必要条件

1>互斥作用; 获取锁的过程是互斥的(锁的基本特征)
一个线程想拿到这把锁,另一个也想拿,就要发生阻塞等待了

2>不可抢夺; (锁的基本特征)
一个线程拿到锁之后,只能主动解锁,不能让别的线程抢走锁

3>请求保持; (代码结构)
一个线程在拿到锁a的情况下,又想去拿锁b

4>循环等待; (代码结构)
就是上面的滑稽吃面问题
这上面四种情况,.缺一不可

所以解决死锁问题,就是破坏其中一个即可
其中4>这个是和代码结构有关的,而且是最容易破坏的
所以我们只要指定一定的顺序,就可以有效避免循环等待
所以可以指定加锁顺序,(例如对锁编号,规定要线程要先拿到临近自己的小编号锁,才可以去拿大编号的锁)

Java标准库中的线程安全类

不安全的线程

ArrayList, LinkedList, HashMap, TreeMap, HashSet, TreeSet, StringBuilder
这几种线程都是不安全的,多个线程尝试修改同一个上述的对象就容易出现问题

较为安全的线程

Vector, HashTable, StringBuffer, ConcurrentHashMap
这几个类,都自带锁,多线程环境下出问题概率小一点,但是前三种不推荐使用,因为比较老了在JDK17里面似乎要删除了
String,虽然这个不加锁,但是也是安全的