Java中的死锁及其解决方案-编程学习网

Java中的死锁及其解决方案

在Java中，锁是很常见的一个工具，常见的用法就是在高并发场景下保证线程安全，但是使用不当也会造成死锁，给我们带来一些不必要的麻烦，本文分析死锁及其产生原因，并作出相应的解决方案。

死锁产生的四个必要条件

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

2）请求和保持条件：进程已经获得了至少一个资源，但又对其他资源发出请求，而该资源已被其他进程占有，此时该进程的请求被阻塞，但又对自己获得的资源保持不放。

3）不可剥夺条件：进程已获得的资源在未使用完毕之前，不可被其他进程强行剥夺，只能由自己释放。

4）环路等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被链中下一个进程所请求。

生活示例

死锁就好比两个人去过独木桥，小庞从桥左边出发，小贾从桥右边出发，然后到了桥中间，小庞要去右边，小贾要去左边，但两者都互不想让，最终只能在桥中间站着，造成死循环，谁也过不了河的结果。

对象A先持有锁1，然后对象B持有锁2，此时对象A要去获取锁2，但是锁2此时在对象B手里，对象B要去获取锁1，锁1在对象A手里，对象A，B互不相让，最终导致死链现象，出现死锁。

死锁代码

方式1，继承Runnable接口实现

package com.wwy.lock;import java.util.concurrent.TimeUnit;public class DieLock {    public static void main(String[] args) {         Object A = new Object();         Object B = new Object();         //线程1                Thread thread1 = new Thread(()->{            synchronized (A){                System.out.println("线程1此时获取锁A");                try {                                        TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }                //对象A苏醒之后再去尝试获取锁2                synchronized (B){                    System.out.println("线程1此时获取锁B");                }            }        });        thread1.start();        //线程2        Thread thread2 = new Thread(()->{            synchronized (B){                System.out.println("线程2此时获取锁B");                try {                    TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }                //对象A苏醒之后再去尝试获取锁2                synchronized (A){                    System.out.println("线程2此时获取锁A");                }            }        });        thread2.start();    }}

方式2，继承Thread类（不推荐使用）

package com.wwy.lock;import java.util.concurrent.TimeUnit;public class ThreadA extends Thread {    private Object A ;    private Object B ;    public Object getA() {        return A;    }    public void setA(Object a) {        A = a;    }    public Object getB() {        return B;    }    public void setB(Object b) {        B = b;    }    @Override    public void run() {        synchronized (A){            System.out.println("线程1此时获取锁A");            try {                TimeUnit.SECONDS.sleep(1);            } catch (InterruptedException e) {                e.printStackTrace();            }            synchronized (B){                System.out.println("线程1此时获取锁B");            }        }    }}

package com.wwy.lock;import java.util.concurrent.TimeUnit;public class ThreadB extends Thread {   private Object A ;   private Object B ;    public Object getA() {        return A;    }    public void setA(Object a) {        A = a;    }    public Object getB() {        return B;    }    public void setB(Object b) {        B = b;    }    @Override    public void run() {        synchronized (B){            System.out.println("线程2此时获取锁B");            try {                TimeUnit.SECONDS.sleep(1);            } catch (InterruptedException e) {                e.printStackTrace();            }            synchronized (A){                System.out.println("线程2此时获取锁A");            }        }    }}

package com.wwy.lock;public class ThreadTest  {    public static void main(String[] args) {        Object A = new Object();        Object B = new Object();        ThreadA t1 = new ThreadA();        ThreadB t2 = new ThreadB();        t1.setA(A);        t1.setB(B);        t2.setA(A);        t2.setB(B);        t1.start();        t2.start();    }}

检测死锁

正常情况下应该打印四句话的，可此时程序一直在运行状态并且只打印了两句话，说明出现死锁现象，验证方法，可以去到我们jdk目录下的bin目录中的一个可视化界面查看

可以看到此处确实出现死锁现象

死锁解决方案

预防死锁的方式就是打破四个必要条件中的任意一个即可。

1）打破互斥条件：在系统里取消互斥。若资源不被一个进程独占使用，那么死锁是肯定不会发生的。但一般来说在所列的四个条件中，“互斥”条件是无法破坏的。因此，在死锁预防里主要是破坏其他几个必要条件，而不去涉及破坏“互斥”条件。。

2）打破请求和保持条件：采用资源预先分配策略，即进程运行前申请全部资源，满足则运行，不然就等待。

每个进程提出新的资源申请前，必须先释放它先前所占有的资源。

3）打破不可剥夺条件：当进程占有某些资源后又进一步申请其他资源而无法满足，则该进程必须释放它原来占有的资源。

4）打破环路等待条件：实现资源有序分配策略，将系统的所有资源统一编号，所有进程只能采用按序号递增的形式申请资源。

方案一，改变两个线程获取锁的顺序

让线程1和线程2的获取锁的顺序都是先获取锁A在获取锁B

package com.wwy.lock;import java.util.concurrent.TimeUnit;public class DieLock {    public static void main(String[] args) {         Object A = new Object();         Object B = new Object();         //线程1                Thread thread1 = new Thread(()->{            synchronized (A){                System.out.println("线程1此时获取锁A");                try {                                        TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }                //对象A苏醒之后再去尝试获取锁2                synchronized (B){                    System.out.println("线程1此时获取锁B");                }            }        });        thread1.start();        //线程2        Thread thread2 = new Thread(()->{            synchronized (A){                System.out.println("线程2此时获取锁A");                try {                    TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }                //对象A苏醒之后再去尝试获取锁2                synchronized (B){                    System.out.println("线程2此时获取锁B");                }            }        });        thread2.start();    }}

继承Runnable类也是如此解决，改变两个线程获取锁的顺序

方式二，使用ReentrantLock来解决

package com.wwy.lock;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.ReentrantLock;public class DieLock {    public static void main(String[] args) {        ReentrantLock lockA = new ReentrantLock();        ReentrantLock lockB = new ReentrantLock();         //线程1                Thread thread1 = new Thread(()->{            while(true) {                if (lockA.tryLock()) {                    System.out.println("线程1获取锁A");                    try {                        TimeUnit.SECONDS.sleep(1);                        if (lockB.tryLock()) {try {    System.out.println("线程1获取锁B");} finally {    lockB.unlock();    System.out.println("线程1释放锁B");    break;}                        }                    } catch (InterruptedException e) {                        e.printStackTrace();                    } finally {                                                lockA.unlock();                        System.out.println("线程1释放锁A");                    }                }                try {                    TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        });        thread1.start();        //线程2        Thread thread2 = new Thread(()->{                        lockB.lock();                System.out.println("线程2获取锁B");                try {                    TimeUnit.SECONDS.sleep(1);                    lockA.lock();                        try {System.out.println("线程2获取锁A");                        }finally {lockA.unlock();System.out.println("线程2释放锁A");                        }                } catch (InterruptedException e) {                    e.printStackTrace();                }                finally {                                        lockB.unlock();                    System.out.println("线程2释放锁B");                }        });        thread2.start();    }}