Java之死锁

最新推荐文章于 2022-12-30 22:26:19 发布

不平衡的叉叉树

最新推荐文章于 2022-12-30 22:26:19 发布

阅读量178

点赞数

分类专栏： java 文章标签： java 多线程多进程锁

本文链接：https://blog.csdn.net/NoviceZ/article/details/117562482

版权

java 专栏收录该内容

108 篇文章 9 订阅

订阅专栏

什么是死锁？

死锁：死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

死锁的产生条件？

虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件。

1）互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

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

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

4）循环等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

如何预防死锁？

只要打破四个必要条件之一就能有效预防死锁的发生：

打破互斥条件：改造独占性资源为虚拟资源，大部分资源已无法改造。

打破占有且申请条件：采用资源预先分配策略，即进程运行前申请全部资源，满足则运行，不然就等待，这样就不会占有且申请。

打破不可抢占条件：当一进程占有一独占性资源后又申请一独占性资源而无法满足，则退出原占有的资源。

打破循环等待条件：实现资源有序分配策略，对所有设备实现分类编号，所有进程只能采用按序号递增的形式申请资源。

死锁案例

package cn.tedu.test5;
public class DeadlockDemo1 {
	 
    public static void main(String[] args) {
        // 线程a
        Thread td1 = new Thread(new Runnable() {
            public void run() {
                DeadlockDemo1.A();
            }
        });
        // 线程b
        Thread td2 = new Thread(new Runnable() {
            public void run() {
                DeadlockDemo1.B();
            }
        });
 
        td1.start();
        td2.start();
    }
 
    public static void A() {
        synchronized (String.class) {//获取String.class锁
            System.out.println("线程a获取到string.class");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程a尝试获取integer.class");
            synchronized (Integer.class) { //线程a尝试获取integer.class锁，但此时Integer.class锁已经被线程b获取，且b不会释放
            }
            System.out.println("线程a已经获取integer.class"); //这条语句没有执行
        }
    }
    public static void B() {
        synchronized (Integer.class) {//获取Integer.class锁
            System.out.println("线程b获取到Integer.class");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程b尝试获取String.class");
            synchronized (String.class) { //线程b尝试获取String.class锁，但此时String.class锁已经被线程a获取,且a不会释放,所以陷入循环等待死锁
            }
            System.out.println("线程b已经获取String.class"); //这条语句没有执行
        }
    }
}


结果显示：
线程b获取到Integer.class
线程a获取到string.class
线程b尝试获取String.class
线程a尝试获取integer.class

...程序阻塞

这是一个循环等待死锁案例

解决办法

造成上放程序死锁的具体原因是：

线程a和b首先分别获取到了String.class锁和Integer.class锁，接着线程a想要尝试获取Integer.class锁，而该锁已被线程b获取，所以线程a需等待线程b释放Integer.class锁，但是线程b又想要获取String.class锁，而该锁已被线程a获取，所以线程b也需要等待线程a释放String.class锁。这样就造成了循环等待死锁。

解决办法是打破循环等待，只需要让线程a和线程b获取锁的顺序一样。

package cn.tedu.test5;

public class DeadlockDemo2 {
 
    public static void main(String[] args) {
        // 线程a
        Thread td1 = new Thread(new Runnable() {
            public void run() {
                DeadlockDemo2.A();
            }
        });
        // 线程b
        Thread td2 = new Thread(new Runnable() {
            public void run() {
                DeadlockDemo2.B();
            }
        });
 
        td1.start();
        td2.start();
    }
 
    public static void A() {
        synchronized (String.class) {
            System.out.println("线程a尝试获取string.class");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程a尝试获取integer.class");
            synchronized (Integer.class) {
                System.out.println("线程a获取到integer.class");
            }
 
        }
    }
 
    public static void B() {
        // 不再获取线程a需要的Integer.class锁。
        synchronized (String.class) {
            System.out.println("线程b尝试获取string.class");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程b尝试获取Integer.class");
            synchronized (Integer.class) {
                System.out.println("线程b获取到Integer.class");
            }
 
        }
    }
 
}

结果显示：
线程a尝试获取string.class
线程a尝试获取integer.class
线程a获取到integer.class
线程b尝试获取string.class
线程b尝试获取Integer.class
线程b获取到Integer.class