一、概述

死锁是指两个或两个以上的进程在执行过程中，因争抢资源而造成的一种互相等待的现象，若无外力干涉它们将无法推进，如果系统资源充足，进程的资源请求能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。

死锁产生的原因：【1】系统资源不足；【2】资源分配不当；【3】进程运行推进的顺序不合适；

形成死锁的四个必要条件：
【1】互斥条件： 一个资源每次只能被一个进程使用。
【2】请求与保持条件： 一个进程因请求资源而阻塞时，对已获得的资源保持不放。
【3】不剥夺条件： 进程已获得的资源，在末使用完之前，不能强行剥夺。
【4】循环等待条件： 若干进程之间形成一种头尾相接的循环等待资源关系。

二、代码演示

public class TestMian {
        //A、B 表示两把锁
        String A = "A";
        String B = "B";
    public static void main(String[] args) {
        TestMian testMian = new TestMian();
        new Thread(()->{
            try {
                testMian.a();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            try {
                testMian.b();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }


    public void a() throws InterruptedException {
        //持有锁A后，尝试持有锁B   ***********重点**************
        synchronized (A){
            System.out.println("A");
            TimeUnit.SECONDS.sleep(1);
            synchronized (B){
                System.out.println("B");
            }
        }
    }

    public void b() throws InterruptedException {
        //持有锁B后，尝试持有锁A   ***********重点**************
        synchronized (B){
            System.out.println("B");
            TimeUnit.SECONDS.sleep(1);
            synchronized (A){
                System.out.println("A");
            }
        }
    }
}

三、排查死锁

【1】jps 命令定位进程号： window 下 java 运行程序，也有类似与 Linux 操作系统的 ps -ef|grep xxx 的查看进程的命令，我们这里只查看 java 的进程，即使用 jps 命令

【2】jstack 能够找到死锁信息：

四、如何避免线程死锁

【1】破坏互斥条件： 这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
【2】破坏请求与保持条件： 一次性申请所有的资源。
【3】破坏不剥夺条件： 占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
【4】破坏循环等待条件： 靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

避免死锁可以概括成三种方法：
【1】固定加锁的顺序(针对锁顺序死锁)；
【2】开放调用(针对对象之间协作造成的死锁)；
【3】使用定时锁 tryLock()； 使用显式 Lock锁，在获取锁时使用 tryLock()方法。当等待超过时限的时候，tryLock()不会一直等待，而是返回错误信息。使用tryLock()能够有效避免死锁问题。

如果等待获取锁时间超时，则抛出异常而不是一直等待！

五、死锁案例及解决方案

【1】不同的加锁顺序案例：

public class DiffLockOrder {

    private int amount;

    public DiffLockOrder(int amount){
       this.amount=amount;
    }

    // 第一个锁 this 是 DiffLockOrder的对象，第二个锁target 也是 DiffLockOrder对象，为死锁埋下了隐患
    public void transfer(DiffLockOrder target,int transferAmount){
        synchronized (this){
            synchronized (target){
                if(amount< transferAmount){
                    System.out.println("余额不足！");
                }else{
                    amount=amount-transferAmount;
                    target.amount=target.amount+transferAmount;
                }
            }
        }
    }
}

【2】 上面的例子中，我们模拟一个转账的过程，amount用来表示用户余额。transfer用来将当前账号的一部分金额转移到目标对象中。为了保证在 transfer的过程中，两个账户不被别人修改，我们使用了两个synchronized 关键字，分别把 transfer对象和目标对象进行锁定。看起来好像没问题，但是我们没有考虑在调用的过程中，transfer的顺序是可以发送变化的：

DiffLockOrder account1 = new DiffLockOrder(1000);
DiffLockOrder account2 = new DiffLockOrder(500);

Runnable target1= ()->account1.transfer(account2,200);
Runnable target2= ()->account2.transfer(account1,100);
new Thread(target1).start();
new Thread(target2).start();

上面的例子中，我们定义了两个account，然后两个账户互相转账，最后很有可能导致互相锁定，最后产生死锁。

解决方案一： 使用 private类变量，只是用一个 sync就可以在所有的实例中同步，来解决两个 sync顺序问题。因为类变量是在所有实例中共享的，这样一次sync就够了：

public class LockWithPrivateStatic {

    private int amount;
    // 不管有多少个实例，共享同一个 lock
    private static final Object lock = new Object();

    public LockWithPrivateStatic(int amount){
       this.amount=amount;
    }

    public void transfer(LockWithPrivateStatic target, int transferAmount){
        synchronized (lock) {
            if (amount < transferAmount) {
                System.out.println("余额不足！");
            } else {
                amount = amount - transferAmount;
                target.amount = target.amount + transferAmount;
            }
        }
    }
}

解决方案二： 使用相同的Order，我们产生死锁的原因是无法控制上锁的顺序，如果我们能够控制上锁的顺序，是不是就不会产生死锁了呢？带着这个思路，我们给对象再加上一个 id字段：

private final long id; // 唯一ID，用来排序
private static final AtomicLong nextID = new AtomicLong(0); // 用来生成ID

public DiffLockWithOrder(int amount){
   this.amount=amount;
   this.id = nextID.getAndIncrement();
}

在初始化对象的时候，我们使用 static的 AtomicLong类来为每个对象生成唯一的ID。在做 transfer的时候，我们先比较两个对象的ID大小，然后根据 ID进行排序，最后安装顺序进行加锁。这样就能够保证顺序，从而避免死锁。

public void transfer(DiffLockWithOrder target, int transferAmount){
        //将加锁的对象修改为可变参数,ID小的永远为第一个锁对象
    DiffLockWithOrder fist, second;

    if (compareTo(target) < 0) {
        fist = this;
        second = target;
    } else {
        fist = target;
        second = this;
    }

    synchronized (fist){
        synchronized (second){
            if(amount< transferAmount){
                System.out.println("余额不足！");
            }else{
                amount=amount-transferAmount;
                target.amount=target.amount+transferAmount;
            }
        }
    }
}

解决方案三： 释放掉已占有的锁，死锁是互相请求对方占用的锁，但是对方的锁一直没有释放，我们考虑一下，如果获取不到锁的时候，自动释放已占用的锁是不是也可以解决死锁的问题呢？因为 ReentrantLock有一个 tryLock()方法，我们可以使用这个方法来判断是否能够获取到锁，获取不到就释放已占有的锁。我们使用 ReentrantLock来完成这个例子：

public class DiffLockWithReentrantLock {

    private int amount;
    private final Lock lock = new ReentrantLock();

    public DiffLockWithReentrantLock(int amount){
        this.amount=amount;
    }

    private void transfer(DiffLockWithReentrantLock target, int transferAmount)
            throws InterruptedException {
        while (true) {
            if (this.lock.tryLock()) {
                try {
                    if (target.lock.tryLock()) {
                        try {
                            if(amount< transferAmount){
                                System.out.println("余额不足！");
                            }else{
                                amount=amount-transferAmount;
                                target.amount=target.amount+transferAmount;
                            }
                            break;
                        } finally {
                            target.lock.unlock();
                        }
                    }
                } finally {
                    this.lock.unlock();
                }
            }
            //随机sleep一定的时间，保证可以释放掉锁
            Thread.sleep(1000+new Random(1000L).nextInt(1000));
        }
    }
}

我们把两个 tryLock方法在 while循环中，如果不能获取到锁就循环遍历。

(adsbygoogle = window.adsbygoogle || []).push({});