Java多线程：死锁

时间 2019-11-06

标签 java 多线程死锁栏目 Java 繁體版

原文原文链接

1、死锁的定义java

多线程以及多进程改善了系统资源的利用率并提升了系统的处理能力。然而，并发执行也带来了新的问题——死锁。所谓死锁是指多个线程因竞争资源而形成的一种僵局（互相等待），若无外力做用，这些进程都将没法向前推动。数据结构

所谓死锁是指两个或两个以上的线程在执行过程当中，因争夺资源而形成的一种互相等待的现象，若无外力做用，它们都将没法推动下去。多线程

下面咱们经过一些实例来讲明死锁现象。并发

先看生活中的一个实例，两我的面对面过独木桥，甲和乙都已经在桥上走了一段距离，即占用了桥的资源，甲若是想经过独木桥的话，乙必须退出桥面让出桥的资源，让甲经过，可是乙不服，为何让我先退出去，我还想先过去呢，因而就僵持不下，致使谁也过不了桥，这就是死锁。dom

在计算机系统中也存在相似的状况。例如，某计算机系统中只有一台打印机和一台输入设备，进程P1正占用输入设备，同时又提出使用打印机的请求，但此时打印机正被进程P2 所占用，而P2在未释放打印机以前，又提出请求使用正被P1占用着的输入设备。这样两个进程相互无休止地等待下去，均没法继续执行，此时两个进程陷入死锁状态。ide

2、死锁产生的缘由工具

一、系统资源的竞争ui

一般系统中拥有的不可剥夺资源，其数量不足以知足多个进程运行的须要，使得进程在运行过程当中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可剥夺资源的竞争才可能产生死锁，对可剥夺资源的竞争是不会引发死锁的。this

二、进程推动顺序非法spa

进程在运行过程当中，请求和释放资源的顺序不当，也一样会致使死锁。例如，并发进程 P一、P2分别保持了资源R一、R2，而进程P1申请资源R2，进程P2申请资源R1时，二者都会由于所需资源被占用而阻塞。

Java中死锁最简单的状况是，一个线程T1持有锁L1而且申请得到锁L2，而另外一个线程T2持有锁L2而且申请得到锁L1，由于默认的锁申请操做都是阻塞的，因此线程T1和T2永远被阻塞了。致使了死锁。这是最容易理解也是最简单的死锁的形式。可是实际环境中的死锁每每比这个复杂的多。可能会有多个线程造成了一个死锁的环路，好比：线程T1持有锁L1而且申请得到锁L2，而线程T2持有锁L2而且申请得到锁L3，而线程T3持有锁L3而且申请得到锁L1，这样致使了一个锁依赖的环路：T1依赖T2的锁L2，T2依赖T3的锁L3，而T3依赖T1的锁L1。从而致使了死锁。

从上面两个例子中，咱们能够得出结论，产生死锁可能性的最根本缘由是：线程在得到一个锁L1的状况下再去申请另一个锁L2，也就是锁L1想要包含了锁L2，也就是说在得到了锁L1，而且没有释放锁L1的状况下，又去申请得到锁L2，这个是产生死锁的最根本缘由。另外一个缘由是默认的锁申请操做是阻塞的。

三、死锁产生的必要条件：

产生死锁必须同时知足如下四个条件，只要其中任一条件不成立，死锁就不会发生。

（1）互斥条件：进程要求对所分配的资源（如打印机）进行排他性控制，即在一段时间内某资源仅为一个进程所占有。此时如有其余进程请求该资源，则请求进程只能等待。

（2）不剥夺条件：进程所得到的资源在未使用完毕以前，不能被其余进程强行夺走，即只能由得到该资源的进程本身来释放（只能是主动释放)。

（3）请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其余进程占有，此时请求进程被阻塞，但对本身已得到的资源保持不放。

（4）循环等待条件：存在一种进程资源的循环等待链，链中每个进程已得到的资源同时被链中下一个进程所请求。即存在一个处于等待状态的进程集合{Pl, P2, ..., pn}，其中Pi等待的资源被P(i+1)占有（i=0, 1, ..., n-1)，Pn等待的资源被P0占有，如图1所示。

直观上看，循环等待条件彷佛和死锁的定义同样，其实否则。按死锁定义构成等待环所要求的条件更严，它要求Pi等待的资源必须由P(i+1)来知足，而循环等待条件则无此限制。例如，系统中有两台输出设备，P0占有一台，PK占有另外一台，且K不属于集合{0, 1, ..., n}。

Pn等待一台输出设备，它能够从P0得到，也可能从PK得到。所以，虽然Pn、P0和其余一些进程造成了循环等待圈，但PK不在圈内，若PK释放了输出设备，则可打破循环等待, 如图2-16所示。所以循环等待只是死锁的必要条件。

资源分配图含圈而系统又不必定有死锁的缘由是同类资源数大于1。但若系统中每类资源都只有一个资源，则资源分配图含圈就变成了系统出现死锁的充分必要条件。

下面再来通俗的解释一下死锁发生时的条件：

（1）互斥条件：一个资源每次只能被一个进程使用。独木桥每次只能经过一我的。

（2）请求与保持条件：一个进程因请求资源而阻塞时，对已得到的资源保持不放。乙不退出桥面，甲也不退出桥面。

（3）不剥夺条件: 进程已得到的资源，在未使用完以前，不能强行剥夺。甲不能强制乙退出桥面，乙也不能强制甲退出桥面。

（4）循环等待条件：若干进程之间造成一种头尾相接的循环等待资源关系。若是乙不退出桥面，甲不能经过，甲不退出桥面，乙不能经过。

3、死锁实例

例子1：

package com.demo.test;

/**
 * 一个简单的死锁类
 * t1先运行，这个时候flag==true,先锁定obj1,而后睡眠1秒钟
 * 而t1在睡眠的时候，另外一个线程t2启动，flag==false,先锁定obj2,而后也睡眠1秒钟
 * t1睡眠结束后须要锁定obj2才能继续执行，而此时obj2已被t2锁定
 * t2睡眠结束后须要锁定obj1才能继续执行，而此时obj1已被t1锁定
 * t一、t2相互等待，都须要获得对方锁定的资源才能继续执行，从而死锁。 
 */
public class DeadLock implements Runnable{
    
    private static Object obj1 = new Object();
    private static Object obj2 = new Object();
    private boolean flag;
    
    public DeadLock(boolean flag){
        this.flag = flag;
    }
    
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName() + "运行");
        
        if(flag){
            synchronized(obj1){
                System.out.println(Thread.currentThread().getName() + "已经锁住obj1");
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                synchronized(obj2){
                    // 执行不到这里
                    System.out.println("1秒钟后，"+Thread.currentThread().getName()
                                + "锁住obj2");
                }
            }
        }else{
            synchronized(obj2){
                System.out.println(Thread.currentThread().getName() + "已经锁住obj2");
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                synchronized(obj1){
                    // 执行不到这里
                    System.out.println("1秒钟后，"+Thread.currentThread().getName()
                                + "锁住obj1");
                }
            }
        }
    }

}

package com.demo.test;

public class DeadLockTest {

     public static void main(String[] args) {
         
         Thread t1 = new Thread(new DeadLock(true), "线程1");
         Thread t2 = new Thread(new DeadLock(false), "线程2");

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

运行结果：

线程1运行
线程1已经锁住obj1
线程2运行
线程2已经锁住obj2

线程1锁住了obj1（甲占有桥的一部分资源），线程2锁住了obj2（乙占有桥的一部分资源），线程1企图锁住obj2（甲让乙退出桥面，乙不从），进入阻塞，线程2企图锁住obj1（乙让甲退出桥面，甲不从），进入阻塞，死锁了。

从这个例子也能够反映出，死锁是由于多线程访问共享资源，因为访问的顺序不当所形成的，一般是一个线程锁定了一个资源A，而又想去锁定资源B；在另外一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操做，两个线程都想获得对方的资源，而不肯释放本身的资源，形成两个线程都在等待，而没法执行的状况。

例子2：

package com.demo.test;

public class SyncThread implements Runnable{
    
    private Object obj1;
    private Object obj2;
 
    public SyncThread(Object o1, Object o2){
        this.obj1=o1;
        this.obj2=o2;
    }
    
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        synchronized (obj1) {
            System.out.println(name + " acquired lock on "+obj1);
            work();
            synchronized (obj2) {
                System.out.println("After, "+name + " acquired lock on "+obj2);
                work();
            }
            System.out.println(name + " released lock on "+obj2);
        }
        System.out.println(name + " released lock on "+obj1);
        System.out.println(name + " finished execution.");
    }
    
    private void work() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.demo.test;

public class ThreadDeadTest {

    public static void main(String[] args) throws InterruptedException {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Object obj3 = new Object();
 
        Thread t1 = new Thread(new SyncThread(obj1, obj2), "t1");
        Thread t2 = new Thread(new SyncThread(obj2, obj3), "t2");
        Thread t3 = new Thread(new SyncThread(obj3, obj1), "t3");
 
        t1.start();
        Thread.sleep(1000);
        t2.start();
        Thread.sleep(1000);
        t3.start();
 
    }
}

运行结果：

t1 acquired lock on java.lang.Object@5e1077
t2 acquired lock on java.lang.Object@1db05b2
t3 acquired lock on java.lang.Object@181ed9e

在这个例子中，造成了一个锁依赖的环路。以t1为例，它先将第一个对象锁住，可是当它试着向第二个对象获取锁时，它就会进入等待状态，由于第二个对象已经被另外一个线程锁住了。这样以此类推，t1依赖t2锁住的对象obj2，t2依赖t3锁住的对象obj3，而t3依赖t1锁住的对象obj1，从而致使了死锁。在线程引发死锁的过程当中，就造成了一个依赖于资源的循环。

4、如何避免死锁

在有些状况下死锁是能够避免的。下面介绍三种用于避免死锁的技术：

加锁顺序（线程按照必定的顺序加锁）
加锁时限（线程尝试获取锁的时候加上必定的时限，超过期限则放弃对该锁的请求，并释放本身占有的锁）
死锁检测

一、加锁顺序

当多个线程须要相同的一些锁，可是按照不一样的顺序加锁，死锁就很容易发生。若是能确保全部的线程都是按照相同的顺序得到锁，那么死锁就不会发生。看下面这个例子：

Thread 1:
  lock A 
  lock B

Thread 2:
   wait for A
   lock C (when A locked)

Thread 3:
   wait for A
   wait for B
   wait for C

若是一个线程（好比线程3）须要一些锁，那么它必须按照肯定的顺序获取锁。它只有得到了从顺序上排在前面的锁以后，才能获取后面的锁。

例如，线程2和线程3只有在获取了锁A以后才能尝试获取锁C(获取锁A是获取锁C的必要条件)。由于线程1已经拥有了锁A，因此线程2和3须要一直等到锁A被释放。而后在它们尝试对B或C加锁以前，必须成功地对A加了锁。

按照顺序加锁是一种有效的死锁预防机制。可是，这种方式须要你事先知道全部可能会用到的锁(并对这些锁作适当的排序)，但总有些时候是没法预知的。

下面对例子1进行改造：

将

Thread t2 = new Thread(new DeadLock(false), "线程2");

改成：

Thread t2 = new Thread(new DeadLock(true), "线程2");

如今应该不会出现死锁了，由于线程1和线程2都是先对obj1加锁，而后再对obj2加锁，当t1启动后，锁住了obj1，而t2也启动后，只有当t1释放了obj1后t2才会执行，从而有效的避免了死锁。

运行结果：

线程1运行
线程1已经锁住obj1
线程2运行
1秒钟后，线程1锁住obj2
线程2已经锁住obj1
1秒钟后，线程2锁住obj2

例子2改造：

package com.demo.test;

public class SyncThread1 implements Runnable{

    private Object obj1;
    private Object obj2;
 
    public SyncThread1(Object o1, Object o2){
        this.obj1=o1;
        this.obj2=o2;
    }
    
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        synchronized (obj1) {
            System.out.println(name + " acquired lock on "+obj1);
            work();
        }
        System.out.println(name + " released lock on "+obj1);
        synchronized(obj2){
            System.out.println("After, "+ name + " acquired lock on "+obj2);
            work();
        }
        System.out.println(name + " released lock on "+obj2);
        System.out.println(name + " finished execution.");
    }
    
    private void work() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.demo.test;

public class ThreadDeadTest1 {

    public static void main(String[] args) throws InterruptedException {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Object obj3 = new Object();
 
        Thread t1 = new Thread(new SyncThread1(obj1, obj2), "t1");
        Thread t2 = new Thread(new SyncThread1(obj2, obj3), "t2");
        Thread t3 = new Thread(new SyncThread1(obj3, obj1), "t3");
 
        t1.start();
        Thread.sleep(1000);
        t2.start();
        Thread.sleep(1000);
        t3.start();
 
    }
}

运行结果：

t1 acquired lock on java.lang.Object@60e128
t2 acquired lock on java.lang.Object@18b3364
t3 acquired lock on java.lang.Object@76fba0
t1 released lock on java.lang.Object@60e128
t2 released lock on java.lang.Object@18b3364
After, t1 acquired lock on java.lang.Object@18b3364
t3 released lock on java.lang.Object@76fba0
After, t2 acquired lock on java.lang.Object@76fba0
After, t3 acquired lock on java.lang.Object@60e128
t1 released lock on java.lang.Object@18b3364
t1 finished execution.
t2 released lock on java.lang.Object@76fba0
t3 released lock on java.lang.Object@60e128
t3 finished execution.
t2 finished execution.

从结果中看，没有出现死锁的局面。由于在run()方法中，不存在嵌套封锁。

避免嵌套封锁：这是死锁最主要的缘由的，若是你已经有一个资源了就要避免封锁另外一个资源。若是你运行时只有一个对象封锁，那是几乎不可能出现一个死锁局面的。

再举个生活中的例子，好比银行转帐的场景下，咱们必须同时得到两个帐户上的锁，才能进行操做，两个锁的申请必须发生交叉。这时咱们也能够打破死锁的那个闭环，在涉及到要同时申请两个锁的方法中，老是以相同的顺序来申请锁，好比老是先申请 id 大的帐户上的锁，而后再申请 id 小的帐户上的锁，这样就没法造成致使死锁的那个闭环。

public class Account {
    private int id;    // 主键
    private String name;
    private double balance;
    
    public void transfer(Account from, Account to, double money){
        if(from.getId() > to.getId()){
            synchronized(from){
                synchronized(to){
                    // transfer
                }
            }
        }else{
            synchronized(to){
                synchronized(from){
                    // transfer
                }
            }
        }
    }

    public int getId() {
        return id;
    }
}

这样的话，即便发生了两个帐户好比 id=1的和id=100的两个帐户相互转帐，由于无论是哪一个线程先得到了id=100上的锁，另一个线程都不会去得到id=1上的锁(由于他没有得到id=100上的锁)，只能是哪一个线程先得到id=100上的锁，哪一个线程就先进行转帐。这里除了使用id以外，若是没有相似id这样的属性能够比较，那么也可使用对象的hashCode()的值来进行比较。

二、加锁时限

另一个能够避免死锁的方法是在尝试获取锁的时候加一个超时时间，这也就意味着在尝试获取锁的过程当中若超过了这个时限该线程则放弃对该锁请求。若一个线程没有在给定的时限内成功得到全部须要的锁，则会进行回退并释放全部已经得到的锁，而后等待一段随机的时间再重试。这段随机的等待时间让其它线程有机会尝试获取相同的这些锁，而且让该应用在没有得到锁的时候能够继续运行(加锁超时后能够先继续运行干点其它事情，再回头来重复以前加锁的逻辑)。

如下是一个例子，展现了两个线程以不一样的顺序尝试获取相同的两个锁，在发生超时后回退并重试的场景：

Thread 1 locks A
Thread 2 locks B

Thread 1 attempts to lock B but is blocked
Thread 2 attempts to lock A but is blocked

Thread 1's lock attempt on B times out
Thread 1 backs up and releases A as well
Thread 1 waits randomly (e.g. 257 millis) before retrying.

Thread 2's lock attempt on A times out
Thread 2 backs up and releases B as well
Thread 2 waits randomly (e.g. 43 millis) before retrying.

在上面的例子中，线程2比线程1早200毫秒进行重试加锁，所以它能够先成功地获取到两个锁。这时，线程1尝试获取锁A而且处于等待状态。当线程2结束时，线程1也能够顺利的得到这两个锁（除非线程2或者其它线程在线程1成功得到两个锁以前又得到其中的一些锁）。

须要注意的是，因为存在锁的超时，因此咱们不能认为这种场景就必定是出现了死锁。也多是由于得到了锁的线程（致使其它线程超时）须要很长的时间去完成它的任务。此外，若是有很是多的线程同一时间去竞争同一批资源，就算有超时和回退机制，仍是可能会致使这些线程重复地尝试但却始终得不到锁。若是只有两个线程，而且重试的超时时间设定为0到500毫秒之间，这种现象可能不会发生，可是若是是10个或20个线程状况就不一样了。由于这些线程等待相等的重试时间的几率就高的多（或者很是接近以致于会出现问题）。(超时和重试机制是为了不在同一时间出现的竞争，可是当线程不少时，其中两个或多个线程的超时时间同样或者接近的可能性就会很大，所以就算出现竞争而致使超时后，因为超时时间同样，它们又会同时开始重试，致使新一轮的竞争，带来了新的问题。)

这种机制存在一个问题，在Java中不能对synchronized同步块设置超时时间。你须要建立一个自定义锁，或使用Java5中java.util.concurrent包下的工具。

三、死锁检测

死锁检测是一个更好的死锁预防机制，它主要是针对那些不可能实现按序加锁而且锁超时也不可行的场景。

每当一个线程得到了锁，会在线程和锁相关的数据结构中（map、graph等等）将其记下。除此以外，每当有线程请求锁，也须要记录在这个数据结构中。当一个线程请求锁失败时，这个线程能够遍历锁的关系图看看是否有死锁发生。例如，线程A请求锁7，可是锁7这个时候被线程B持有，这时线程A就能够检查一下线程B是否已经请求了线程A当前所持有的锁。若是线程B确实有这样的请求，那么就是发生了死锁（线程A拥有锁1，请求锁7；线程B拥有锁7，请求锁1）。

固然，死锁通常要比两个线程互相持有对方的锁这种状况要复杂的多。线程A等待线程B，线程B等待线程C，线程C等待线程D，线程D又在等待线程A。线程A为了检测死锁，它须要递进地检测全部被B请求的锁。从线程B所请求的锁开始，线程A找到了线程C，而后又找到了线程D，发现线程D请求的锁被线程A本身持有着。这是它就知道发生了死锁。

下面是一幅关于四个线程（A,B,C和D）之间锁占有和请求的关系图。像这样的数据结构就能够被用来检测死锁。

那么当检测出死锁时，这些线程该作些什么呢？

一个可行的作法是释放全部锁，回退，而且等待一段随机的时间后重试。这个和简单的加锁超时相似，不同的是只有死锁已经发生了才回退，而不会是由于加锁的请求超时了。虽然有回退和等待，可是若是有大量的线程竞争同一批锁，它们仍是会重复地死锁（缘由同超时相似，不能从根本上减轻竞争）。

一个更好的方案是给这些线程设置优先级，让一个（或几个）线程回退，剩下的线程就像没发生死锁同样继续保持着它们须要的锁。若是赋予这些线程的优先级是固定不变的，同一批线程老是会拥有更高的优先级。为避免这个问题，能够在死锁发生的时候设置随机的优先级。

总结：避免死锁的方式

一、让程序每次至多只能得到一个锁。固然，在多线程环境下，这种状况一般并不现实。

二、设计时考虑清楚锁的顺序，尽可能减小嵌在的加锁交互数量。

三、既然死锁的产生是两个线程无限等待对方持有的锁，那么只要等待时间有个上限不就行了。固然synchronized不具有这个功能，可是咱们可使用Lock类中的tryLock方法去尝试获取锁，这个方法能够指定一个超时时限，在等待超过该时限以后便会返回一个失败信息。

咱们可使用ReentrantLock.tryLock()方法，在一个循环中，若是tryLock()返回失败，那么就释放以及得到的锁，并睡眠一小段时间。这样就打破了死锁的闭环。好比：线程T1持有锁L1而且申请得到锁L2，而线程T2持有锁L2而且申请得到锁L3，而线程T3持有锁L3而且申请得到锁L1。此时若是T3申请锁L1失败，那么T3释放锁L3，并进行睡眠，那么T2就能够得到L3了，而后T2执行完以后释放L2, L3，因此T1也能够得到L2了执行完而后释放锁L1, L2，而后T3睡眠醒来，也能够得到L1, L3了。打破了死锁的闭环。