02锁机制篇（D1_常见锁）_死锁活锁-CSDN博客

进程级别：CPU、主内存等资源都属于可剥夺性资源，系统将这些资源分配给一个进程之后，系统是可以将这些资源剥夺后转交给其他进程使用的。
线程级别：比如 Java 中的 ForkJoin 框架中的任务，分配给一个线程的任务是有可能被其他线程窃取的。可剥夺性资源还有很多，诸如上述过程中的一些类似的资源都可以被称为可剥夺性

分类四：不可抢占式资源

同样，不可抢占式资源也被称为不可剥夺性资源，不可剥夺性是指把一个执行实体获取到资源之

后，系统或程序不能强行收回，只能在实体使用完后自行释放。如：

进程级别：磁带机、打印机等资源，分配给进程之后只能由进程使用完后自行释放。
线程级别：锁资源就是典型的线程级别的不可剥夺性资源，当一条线程获取到锁资源后，其他线程不能剥夺该资源，只能由获取到锁的线程自行释放。

5. 死锁案例分析

上述对于死锁的理论进行了大概阐述，下来来个简单例子感受一下死锁情景：

/**
 * @projectName: 02JUC
 * @ClassName DeadLock
 * @description:
 * @author: CodingW
 * @create: 2025.01.16.14:31
 * @Version 1.0
 **/
public class DeadLock implements Runnable {
    public boolean flag = true;

    // 静态成员属于class，是所有实例对象可共享的
    private static Object o1 = new Object(), o2 = new Object();

    public DeadLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) {
            synchronized (o1) {
                System.out.println("线程：" + Thread.currentThread().getName() + "持有o1....");
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "等待o2....");
                synchronized (o2) {
                    System.out.println("true");
                }
            }
        }
        if (!flag) {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + "持有o2....");
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "等待o1....");
                synchronized (o1) {
                    System.out.println("false");
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new DeadLock(true), "T1");
        Thread t2 = new Thread(new DeadLock(false), "T2");
        // 因为线程调度是按时间片切换决定的，
        // 所以先执行哪个线程是不确定的，也就代表着：
        // 后面的t1.run()可能在t2.run()之前运行
        t1.start();
        t2.start();
    }
}

// 运行结果如下：
/*
线程：T1持有o1....
线程：T2持有o2....
线程：T2等待o1....
线程：T1等待o2....
*/

如上是一个简单的死锁案例，在该代码中：

当flag==true时，先获取对象o1的锁，获取成功之后休眠500ms，而发生这个动作的必然是t1，因为在main方法中，我们将任务的flag显式的置为了true。
而当线程睡眠时，t2线程启动，此时任务的flag=false，所以会去获取对象o2的锁资源，然后获取成功之后休眠。
此时线程睡眠时间结束，线程被唤醒后会继续往下执行，然后需要获取对象的锁资源，但此时已经被持有，此时会阻塞等待。
而此刻线程也从睡眠中被唤醒会继续往下执行，然后需要获取对象的锁资源，但此时已经被持有，此时会阻塞等待。
最终导致线程t1、t2相互等待对象的资源，都需要获取对方持有的资源之后才可继续往下执行，最终导致死锁产生。

6. 死锁处理

对于死锁的情况一旦出现都是比较麻烦的，但这也是设计并发程序避免不了的问题，当你想要通过

多线程编程技术提升你的程序处理速度和整体吞吐量时，对于死锁的问题也是必须要考虑的一项，

而处理死锁问题总的归纳来

说可以从如下四个角度出发：

① 预防死锁：通过代码设计或更改配置来破坏掉死锁产生的四个条件其中之一，以此达到预防死

锁的目的。

② 避免死锁：在资源分配的过程中，尽量保证资源请求的顺序性，防止推进顺序不当引起死锁问

题产生。

③ 检测死锁：允许系统在运行过程中发生死锁情况，但可设置检测机制及时检测死锁的发生，并

采取适当措施加以清除。

④ 解除死锁：当检测出死锁后，便采取适当措施将进程从死锁状态中解脱

6.1. 预防死锁

处理方式

前面提过，预防死锁的手段是通过破坏死锁产生的四个必要条件中的一个或多个，以此达到预防死

锁的目的。

方式一：破坏“互斥”条件

在程序中将所有“互斥”的逻辑移除，如果一个资源不能被独占使用时，那么死锁情况必然不会发

生。但一般来说在所列的四个条件中，“互斥”条件是不能破坏的，因为程序设计中必须要考虑线程

安全问题，所以“互斥”条件是必需的。因此，在死锁预防里主要是破坏其他几个必要条件，不会去

破坏“互斥”条件。

方式二：破坏“不可剥夺”条件

破坏“不可剥夺性”条件的含义是指取消资源独占性，一个执行实体获取到的资源可以被别的实体或

系统强制剥夺，在程序中可以这样设计：

① 如果占用资源的实体下一步资源请求失败，那么则释放掉之前获取到的所有资源，后续再重新请求这些资源和另外的资源（和分布式事务的概念有些类似）。
② 如果一个实体需要请求的资源已经被另一个实体持有，那么则由程序或系统将该资源释放，然后让给当前实体获取执行。这种方式在Java中也有实现，就是设置线程的优先级，优先级高的线程是可以抢占优先级低的资源先执行的。