JavaEE 初阶（7）——多线程5 之线程安全中 --＞“死锁”

求大厂offer （ing…

于 2024-07-25 23:18:18 发布

阅读量748

点赞数 10

文章标签： java java-ee

本文链接：https://blog.csdn.net/2301_80243321/article/details/140673484

版权

一. 什么是“死锁”

并非是 synchronized 就一定线程安全，还要看代码具体咋写。到底是否加 synchronized ，和具体场景直接相关。“无脑加锁”的做法不推荐，锁需要的时候才使用，不需要的时候不要使用，会付出代价（性能）。使用锁，就可能触发阻塞，一旦某个线程阻塞，啥时候能恢复阻塞，继续执行，是不可预期了...（可能需要非常多时间）

因此，synchronized 如果使用不当，就会出现“死锁”。

死锁：发生在多个进程或线程在执行过程中，因为竞争资源而造成的一种互相等待的僵持状态，没有任何一个进程或线程可以继续执行下去。简单来说，死锁是指两个或多个进程无限期地等待永远不会发生的条件，导致它们无法继续执行。

二. 产生死锁的场景

场景1：一个线程连续加锁

public class DeadLock2 {
    private static int count = 0;

    public void add(){
        synchronized (this){
            synchronized (this){
                count++;
            }
        }
    }
  
}

运行结果：

代码分析：

里面的synchronized要想拿到锁，就需要外面的synchronized释放锁
外面的synchronized要释放锁，就需要执行到 }
要想执行到 } 就需要执行完 count++
但是 count++ 阻塞着呢~

这样，就会一直阻塞等待，造成“死锁”.....

但是，实际运行并没有出现“死锁”现象，这是为什么呢？

因为 synchronized 针对这种情况做了特殊处理~

synchronized 是 “可重入锁”，针对上述一个线程对同一把锁连续加锁做了特殊处理，是Java为了减少程序员写出死锁的概率，引入的特殊机制。同样的代码，换成C++ / Python 就会出现“死锁”。

“可重入锁” 的一个主要特性是它允许同一个线程多次获取同一把锁。如果线程已经持有了这把锁，那么它可以再次进入由这把锁保护的代码块，而不会阻塞产生“死锁”。这是通过记录锁的持有者，并引入一个计数器来实现的：

初始情况下，计数器是0 --> 执行到 { 计数器 +1 ，执行到 } 计数器 -1。如果某次 -1 之后，计数器为0了，说明这次就要真正释放锁了。

此处涉及到了 “引入计数” 的思想，后面讲到 JVM 中的垃圾回收机制也会有

场景2：两个线程两把锁

public class DeadLock {
    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                System.out.println("t1 加锁locker1 完成");

                //这里的sleep是为了让t1和t2都先拿到自己锁，然后再拿对方的锁
                //如果没有sleep执行顺序就不可控
                //可能出现某个线程一口气拿到两把锁，另一个线程还没执行，无法构造出死锁.
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker2){
                    System.out.println("t1 加锁locker2 完成");
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized(locker2){
                System.out.println("t2 加锁locker2 完成");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(locker1){
                    System.out.println("t2 加锁locker1 完成");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

运行结果：