【Java多线程】分析线程加锁导致的死锁问题以及解决方案

简介: 【Java多线程】分析线程加锁导致的死锁问题以及解决方案

1、线程加锁


其中 locker 可以是任意对象,进入 synchronized 修饰的代码块, 相当于加锁,退出 synchronized 修饰的代码块, 相当解锁。


如果一个线程,针对一个对象加上锁之后,其他线程也尝试对这个对象加锁,就会导致锁竞争进而引起阻塞(BLOCKED),这个阻塞会一直持续到上一个线程释放锁为止。


如果是两个线程分别针对不同的对象进行加锁,此时不会由锁竞争,也就不会阻塞。


出现锁竞争进而引起阻塞状态,这个阻塞会一直持续到下一个线程释放锁为止。


但是,设想一个场景,共有AB两个线程,此时A线程因为锁竞争进入阻塞状态,而如果此时B线程恰巧也正在阻塞状态,由于AB线程都进入了阻塞状态,此时进程无法运行,出现死锁问题。下面针对死锁问题的出现以及解决方法展开讨论。


2、死锁问题的三种经典场景

2.1、一个线程一把锁

public static void main(String[] args) {
    Object locker = new Object();
    Thread t = new Thread(() -> {
        synchronized (locker) {   //两次加锁,加的是同一把锁
            synchronized (locker) {   //两次加锁,加的是同一把锁
                System.out.println("hello synchronized");
            }
        }
    });
    t.start();
}

需要注意的是,这里最直观的感觉是进行了两次加锁,会发生锁冲突。第一次针对locker加锁之后,在还没释放锁的时候又尝试对locker加锁,理论会出现锁冲突。


至于事实上是否会出现所冲突进而出现死锁,需要分情况讨论:


1、如果是不可重入锁,则就会出现锁竞争引起死锁。


2、如果是可重入锁,则不会出现锁竞争引起死锁,Java中的锁就是可重入锁,因此可以正常打印。


可以把这种情况理解成:【屋钥匙锁在了屋里】


2.2、两个线程两把锁

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();
    }
}
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();
    }
}


两个线程,两把锁。线程A获取到锁A,线程B获取到锁B,在没释放锁AB的前提下,线程A尝试获取锁B,线程B尝试获取锁A,就会出现死锁。


可以把这种情况理解成:【屋钥匙锁在了车里,车钥匙锁在了屋里】


2.3、N个线程M把锁(哲学家就餐问题)

首先假设一个场景,一张圆桌上坐着五个人,每个人面前都有一碗面条,桌子上一共有五根筷子(不是五双),而将五根筷子分别摆放在两人各自之间,如下图。



       要想吃面条,需要拿起自己身旁的两根筷子(左右两根,只能拿身边的这两根)。假设此时A拿起了左右筷子吃面条,此时B就无法吃,因为A正在使用B的左筷子,B目前只能拿起一根右筷子,并且开始等待,等待A放下筷子,再拿起左筷子吃面条(此处的等待只有拿到另外一根筷子后才会停止,并且等待的同时不会放下已经拿起的筷子)。同理E也一样。


       此处讨论的问题中N等于M。我们将线程比作人,筷子比作锁,此时B所处的状态可以比作锁竞争引起的阻塞状态。大家可以试着想想各种其他不同的情况,始终都能保证桌上5个人至少有一人正在吃面条,除了一种特殊的极端情况下:


       极端情况下,会出现所有人同时都拿了同一侧的筷子(例如都拿了左筷子),导致所有人都不能拿起另一侧的筷子而都进入阻塞,等待着别人放下筷子后自己再拿起来。但是此时又因为没有一个人能吃的上面条,因此永远不会有人放下筷子,出现死锁。


       这个问题也被人称之为:哲学家就餐问题。


3、解决死锁问题

要想解决死锁情况,就得先讨论产生死锁的原因:


死锁产生的四个必要条件(缺一不可)


由于是必要条件,只需要破坏其中一种条件,就可以让死锁解开。


  1. 互斥使用。一个线程拿到了这把锁,另一个线程也想获取,就需要阻塞等待,这是锁最基本的特性,不好破坏。
  2. 不可抢占。一个线程拿到了锁之后,只能主动解锁,不能让别的线程强行把锁抢走,这也是锁最基本的特性,不好破坏。
  3. 请求保持。一个线程拿到了锁A,在持有锁A的前提下,尝试获取锁B。这些场景下必须需要这样使用,也不好破坏。
  4. 循环等待/环路等待,是一种代码结构,是最容易破坏。

由上述分析可以得知,想要解决死锁问题,要从破坏循环等待/环路等待入手。


引入加锁顺序的规则就是很好破解循环等待的办法,即给每一个锁编号,规定只能按照锁的序号顺序拿起,就能打破循环等待。


举例说明:


       依然是是上面的哲学家就餐问题,此时给筷子编号序号之后,要求只能按照顺序由小到大拿起,此时就算是所有人同时拿起筷子,C先拿1,B先拿2,A先拿3,E先拿4,此时D按照规定应该拿起1,但是此时C正拿着1,因此此时D还没有机会拿起5,就直接进入阻塞状态。此场景下E就能拿起5开始吃面,E放下筷子A就接着吃,依此类推,就将可能出现的死锁问题破解了。


目录
相关文章
|
1天前
|
Java API
详细探究Java多线程的线程状态变化
Java多线程的线程状态主要有六种:新建(NEW)、可运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、超时等待(TIMED_WAITING)和终止(TERMINATED)。线程创建后处于NEW状态,调用start()后进入RUNNABLE状态,表示准备好运行。当线程获得CPU资源,开始执行run()方法时,它处于运行状态。线程可以因等待锁或调用sleep()等方法进入BLOCKED或等待状态。线程完成任务或发生异常后,会进入TERMINATED状态。
|
1天前
|
存储 安全 Java
Java多线程中线程安全问题
Java多线程中的线程安全问题主要涉及多线程环境下对共享资源的访问可能导致的数据损坏或不一致。线程安全的核心在于确保在多线程调度顺序不确定的情况下,代码的执行结果始终正确。常见原因包括线程调度随机性、共享数据修改以及原子性问题。解决线程安全问题通常需要采用同步机制,如使用synchronized关键字或Lock接口,以确保同一时间只有一个线程能够访问特定资源,从而保持数据的一致性和正确性。
|
1天前
|
监控 安全 Java
Java多线程的使用
Java多线程允许程序同时执行多个任务,提高了系统的整体性能和响应速度。通过创建Thread类或其子类的实例,或使用Runnable接口,Java开发者可以定义并发执行的代码段。多线程在处理复杂任务、资源共享、网络通信等方面具有显著优势,但也需要注意线程安全、同步和死锁等问题。Java提供了丰富的API和工具来处理这些并发问题,使多线程编程更加高效和可靠。
|
2天前
|
API
java-多线程-CountDownLatch(闭锁) CyclicBarrier(栅栏) Semaphore(信号量)-
java-多线程-CountDownLatch(闭锁) CyclicBarrier(栅栏) Semaphore(信号量)-
6 1
|
2天前
|
安全 Java API
Java并发基础-启动和终止线程
Java并发基础-启动和终止线程
12 0
|
2天前
|
Java 调度
Java并发基础-线程简介(状态、常用方法)
Java并发基础-线程简介(状态、常用方法)
8 0
|
7天前
|
安全 Java 编译器
JAVA-多线程知识点总结(二)
JAVA-多线程知识点总结(二)
|
8天前
|
缓存 Java 调度
java面试题之个人对线程池的理解
java面试题之个人对线程池的理解
|
2天前
|
安全 Java 程序员
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题(二)
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题(二)
23 4
|
2天前
|
Java 程序员 调度
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题(一)
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题(一)
19 0
Java基础18-一文搞懂Java多线程使用方式、实现原理以及常见面试题(一)