死锁的四个必要条件

2023-12-20 08:41:53

死锁在高并发中是一个常见的名词。产生的四个必要条件如下:

  1. 互斥条件:一个资源同一时间能且只能被一个线程访问;

  1. 不可掠夺:当资源被一个线程占用时,其他线程不可抢夺该资源;

  1. 请求与等待:当资源被一个线程占用时,其他线程只能等待资源的释放再拥有;

  1. 循环等待:指的是若干线程形成头尾相接的情况,将所有资源都占用导致的整体死锁或局部死锁。

图演示

线程1依次占用资源1和资源2,当尝试占用资源2时,发现该资源被线程2占用,此时只能等待线程2的释放,此时处于阻塞状态;

线程2依次占用资源2和资源1,当尝试占用资源1时,发现该资源被线程1占用,此时只能等待线程1的释放,此时处于阻塞状态。

这两个线程无限的等待对方资源的释放,则成为死锁。

代码演示

package com.lidantao.deadLock;

import java.util.concurrent.TimeUnit;

/**
 * @author Cola
 * @Date 2023年02月16日 10:41:00
 */
public class Demo {

    public static void main(String[] args) throws InterruptedException {

        Object obj1 = new Object();
        Object obj2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (obj1) {
                try {
                    System.out.println("====线程1尝试占用资源1====");
                    obj1.hashCode();
                    System.out.println("====线程1已经占用资源1====");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("======线程1尝试占用资源2======");
                    synchronized (obj2) {
                        obj2.hashCode();
                        System.out.println("====线程1已经占用资源2====");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程1");

        Thread t2 = new Thread(() -> {
            synchronized (obj2) {
                try {
                    System.out.println("====线程2尝试占用资源2====");
                    obj2.hashCode();
                    System.out.println("====线程2已经占用资源2====");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("======线程2尝试占用资源1======");
                    synchronized (obj1){
                        obj1.hashCode();
                        System.out.println("====线程2已经占用资源1====");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程2");

        // 启动线程
        t1.start();
        t2.start();

        // t1业务完成
        t1.join();
        System.out.println("====== t1线程业务已完成 ======");

        // t2业务完成
        t2.join();
        System.out.println("====== t2线程业务已完成 ======");

    }
}

控制台输出,两线程彼此等待资源释放,无法停止线程

经jconsole验证,线程1与线程2掠夺资源产生死锁

处理死锁

既然了解了死锁的必要条件,那么我们只要破坏其中一个条件则可避免产生死锁。

  1. 通常我们在业务中,可以设置等待时间。例如尝试占用资源时,设置等待时间,时间内未获得资源,则放弃尝试,避免程序长时间等待,占用过高的CPU资源。

  1. 尽量一次只占用一个资源,不要一次嵌套的占用多个资源,占用资源链越长,越容易产生死锁问题。

文章来源:https://blog.csdn.net/u014135206/article/details/129056130
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。