Java线程死锁的问题解决_Java

1. 死锁案例

死锁：线程之间互相持有对方的锁，并且等待获取对方持有的锁。

案例如下：我这里直接写的service层代码，没写测试类（测试类直接调用deadlocktest()方法）。

package cn.sh.tools.service.component.lock;
 
import lombok.allargsconstructor;
import lombok.getter;
import lombok.extern.slf4j.slf4j;
import org.springframework.scheduling.concurrent.threadpooltaskexecutor;
import org.springframework.stereotype.component;
 
import javax.annotation.resource;
import java.util.arraylist;
import java.util.comparator;
import java.util.list;
import java.util.concurrent.countdownlatch;
 
/**
 * @description
 * @classname lockcomponent
 * @date 2023/4/28
 * @author sh
 **/
@component
@slf4j
public class lockcomponent {
 
    // 记得在 yml文件中配置线程池相关参数（核心线程数、工作队列大小、最大线程数）。
    @resource(name = "applicationtaskexecutor")
    private threadpooltaskexecutor threadpooltaskexecutor;
 
    // 入参createthreadnum：要创建的线程数。尽量设置个十几二十个，设置的太小可能程序执行太快就发生不了死锁。
    public void deadlocktest(int createthreadnum) {
        // 计数器
        countdownlatch suncdl = new countdownlatch(createthreadnum);
        // 1- 填充数据
        list<deadlockobj> deadlockobjlist = new arraylist<>(createthreadnum);
        /**
         * for循环 创建deadlockobj对象，这里只创建了两种对象。
         * 这里创建两种对象的原因是为了 后面创建的线程互相持有锁。
         */
        for (int i = 0; i < createthreadnum; i++) {
            if (i % 2 != 0) {
                // i 为 奇数时，给 deadlockobj 对象的 a = 1，b = 2。
                deadlockobjlist.add(new deadlockobj(i, 1, 2));
            } else {
                // i 为 偶数时，给 deadlockobj 对象的 a = 2，b = 1。
                deadlockobjlist.add(new deadlockobj(i, 2, 1));
            }
        }
        deadlockobjlist.sort(comparator.comparingint(deadlockobj::getid));
 
        // 循环数据，调用 deadlockinternal()方法，展示死锁情况。
        deadlockobjlist.foreach(deadlockobj -> {
            this.threadpooltaskexecutor.execute(() -> {
                try {
                    suncdl.await();
                } catch (interruptedexception e) {
                    throw new runtimeexception(e);
                }
 
                // 在高并发情况下，必然会出现死锁。
                this.deadlockinternal(deadlockobj);
            });
        });
 
        // 循环将 计数器 减1，当减为0时，上面的线程就开始 真正的并发执行。
        for (int i = 0; i < createthreadnum; i++) {
            suncdl.countdown();
        }
    }
 
    private void deadlockinternal(deadlockobj deadlockobj) {
        /**
         * ① 线程a 持有 integer.valueof(1)，线程b 持有 integer.valueof(2)
         * ② 线程a 抢占 integer.valueof(2)，但是2被线程b持有。
         *   同时，线程b 抢占 integer.valueof(1)，但是1被线程a持有。
         * 线程a 和 线程b 要抢占的锁都被对方持有，所以，必然会出现死锁。
         */
 
        // 第一把锁
        synchronized (integer.valueof(deadlockobj.geta())) {
            // 第二把锁
            synchronized (integer.valueof(deadlockobj.getb())) {
                system.out.println(deadlockobj.getid());
            }
        }
    }
 
    @getter
    @allargsconstructor
    static class deadlockobj {
        integer id;
        int a;
        int b;
    }
 
}