死锁

产生死锁的四个必要条件：

（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

产生死锁, 顺序死锁



@Slf4j
public class DeadlockExample {
    static Object lockA = new Object();
    static Object lockB = new Object();


    public static void main(String[] args) {
        String name = ManagementFactory.getRuntimeMXBean().getName();
        String pid = name.split("@")[0];
        log.info("Pid is:" + pid);
        log.info("jstack " + pid);

        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.submit(() -> {
            synchronized (lockA) {
                try {
                    log.info("lockA");
                    TimeUnit.SECONDS.sleep(10);
                    log.info("lockA after sleep");

                    synchronized (lockB) {
                        log.info("lock B");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });

        executorService.submit(() -> {
            synchronized (lockB) {
                try {
                    log.info("lockB");
                    TimeUnit.SECONDS.sleep(10);
                    log.info("lockB after sleep");

                    synchronized (lockA) {
                        log.info("lock A");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

    }

}

分析信息 Found one Java-level deadlock:

Found one Java-level deadlock:
=============================
"pool-1-thread-1":
  waiting to lock monitor 0x000002c99012fa80 (object 0x0000000710944898, a java.lang.Object),
  which is held by "pool-1-thread-2"
"pool-1-thread-2":
  waiting to lock monitor 0x000002c99012bb80 (object 0x0000000710944888, a java.lang.Object),
  which is held by "pool-1-thread-1"

Java stack information for the threads listed above:
===================================================
"pool-1-thread-1":
        at cn.wyj.learn.juc.DeadlockExample.lambda$main$0(DeadlockExample.java:33)
        - waiting to lock <0x0000000710944898> (a java.lang.Object)
        - locked <0x0000000710944888> (a java.lang.Object)
        at cn.wyj.learn.juc.DeadlockExample$$Lambda$41/0x00000008000e2440.run(Unknown Source)
        at java.util.concurrent.Executors$RunnableAdapter.call(java.base@11.0.2/Executors.java:515)
        at java.util.concurrent.FutureTask.run(java.base@11.0.2/FutureTask.java:264)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@11.0.2/ThreadPoolExecutor.java:1128)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@11.0.2/ThreadPoolExecutor.java:628)
        at java.lang.Thread.run(java.base@11.0.2/Thread.java:834)
"pool-1-thread-2":
        at cn.wyj.learn.juc.DeadlockExample.lambda$main$1(DeadlockExample.java:50)
        - waiting to lock <0x0000000710944888> (a java.lang.Object)
        - locked <0x0000000710944898> (a java.lang.Object)
        at cn.wyj.learn.juc.DeadlockExample$$Lambda$42/0x00000008000e1840.run(Unknown Source)
        at java.util.concurrent.Executors$RunnableAdapter.call(java.base@11.0.2/Executors.java:515)
        at java.util.concurrent.FutureTask.run(java.base@11.0.2/FutureTask.java:264)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@11.0.2/ThreadPoolExecutor.java:1128)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@11.0.2/ThreadPoolExecutor.java:628)
        at java.lang.Thread.run(java.base@11.0.2/Thread.java:834)

Found 1 deadlock.

活锁

指事物1可以使用资源，但它让其他事物先使用资源；事物2可以使用资源，但它也让其他事物先使用资源，于是两者一直谦让，都无法使用资源。

活锁同样会发生在多个相互协作的线程间，当他们为了彼此间的响应而相互礼让，使得没有一个线程能够继续前进，那么就发生了活锁。

好比两个过于礼貌的人在半路相遇，出于礼貌他们相互礼让，避开对方的路，但是在另一条路上又相遇了。就这样，不停地一直避让下去。。。。



@Slf4j
public class DeadlockExample {

    static ReentrantLock reentrantLockA = new ReentrantLock();
    static ReentrantLock reentrantLockB = new ReentrantLock();

    public static void main(String[] args) {
        String name = ManagementFactory.getRuntimeMXBean().getName();
        String pid = name.split("@")[0];
        log.info("Pid is:" + pid);
        log.info("jstack " + pid);

        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.submit(() -> {
            try {
                while (reentrantLockA.tryLock(10, TimeUnit.SECONDS)) {
                    log.info("A任务重新初始化");
                    TimeUnit.SECONDS.sleep(1);
                    boolean locked = reentrantLockB.isLocked();
                    if (locked) {
                        reentrantLockA.unlock();
                        continue;
                    }
                    boolean b = reentrantLockB.tryLock(10, TimeUnit.SECONDS);
                    if (!b) {
                        reentrantLockA.unlock();
                        continue;
                    }
                    log.info("线程A处理任务");
                    break;
                }
                log.info("线程A处理完成");
            } catch (InterruptedException e) {
                log.error("线程中断", e);
            } finally {
                reentrantLockB.unlock();
                reentrantLockA.unlock();
            }
        });

        executorService.submit(() -> {
            try {
                while (reentrantLockB.tryLock(10, TimeUnit.SECONDS)) {
                    log.info("B任务重新初始化");
                    TimeUnit.SECONDS.sleep(2);
                    boolean locked = reentrantLockA.isLocked();
                    if (locked) {
                        reentrantLockB.unlock();
                        continue;
                    }
                    boolean b = reentrantLockA.tryLock(10, TimeUnit.SECONDS);
                    if (!b) {
                        reentrantLockB.unlock();
                        continue;
                    }
                    log.info("线程B处理任务");
                    break;
                }
                log.info("线程B处理完成");
            } catch (InterruptedException e) {
                log.error("线程中断", e);
            } finally {
                reentrantLockA.unlock();
                reentrantLockB.unlock();
            }
        });
        executorService.shutdown();
    }

}

10:55:25.434 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
10:55:25.434 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化
10:55:26.435 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化
10:55:27.436 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
10:55:29.436 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
10:55:31.437 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
10:55:33.438 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
.
.
.
.
.
.

10:57:41.497 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
10:57:42.493 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化
10:57:43.493 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化
10:57:43.498 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
10:57:44.493 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化
10:57:45.493 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化
10:57:45.498 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
10:57:46.494 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化

解决活锁1

在锁让出的时候时候添加随机睡眠时间,

@Slf4j
public class DeadlockExample {

    static ReentrantLock reentrantLockA = new ReentrantLock();
    static ReentrantLock reentrantLockB = new ReentrantLock();

    public static void main(String[] args) {
        String name = ManagementFactory.getRuntimeMXBean().getName();
        String pid = name.split("@")[0];
        log.info("Pid is:" + pid);
        log.info("jstack " + pid);

        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.submit(() -> {
            try {
                //自旋
                while (reentrantLockA.tryLock(10, TimeUnit.SECONDS)) {
                    log.info("A任务重新初始化");
                    TimeUnit.SECONDS.sleep(1);
                    boolean locked = reentrantLockB.isLocked();
                    if (locked) {
                        reentrantLockA.unlock();
                        //避免活锁
                        TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(1,2000));
                        continue;
                    }
                    boolean b = reentrantLockB.tryLock(10, TimeUnit.SECONDS);
                    if (!b) {
                        reentrantLockA.unlock();
                        continue;
                    }
                    log.info("线程A处理任务");
                    break;
                }
                log.info("线程A处理完成");
            } catch (InterruptedException e) {
                log.error("线程中断", e);
            } finally {
                reentrantLockB.unlock();
                reentrantLockA.unlock();
            }
        });

        executorService.submit(() -> {
            try {
                //自旋
                while (reentrantLockB.tryLock(10, TimeUnit.SECONDS)) {
                    log.info("B任务重新初始化");
                    TimeUnit.SECONDS.sleep(2);
                    boolean locked = reentrantLockA.isLocked();
                    if (locked) {
                        reentrantLockB.unlock();
                        //避免活锁
                        TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(1, 2000));
                        continue;
                    }
                    boolean b = reentrantLockA.tryLock(10, TimeUnit.SECONDS);
                    if (!b) {
                        reentrantLockB.unlock();
                        continue;
                    }
                    log.info("线程B处理任务");
                    break;
                }
                log.info("线程B处理完成");
            } catch (InterruptedException e) {
                log.error("线程中断", e);
            } finally {
                reentrantLockA.unlock();
                reentrantLockB.unlock();
            }
        });
        executorService.shutdown();
    }

}

11:28:22.212 [main] INFO cn.wyj.learn.juc.DeadlockExample - Pid is:33004
11:28:22.215 [main] INFO cn.wyj.learn.juc.DeadlockExample - jstack 33004
11:28:22.219 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化
11:28:22.219 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
11:28:23.845 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - A任务重新初始化
11:28:24.846 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - 线程A处理任务
11:28:24.846 [pool-1-thread-1] INFO cn.wyj.learn.juc.DeadlockExample - 线程A处理完成
11:28:25.546 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - B任务重新初始化
11:28:27.547 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - 线程B处理任务
11:28:27.547 [pool-1-thread-2] INFO cn.wyj.learn.juc.DeadlockExample - 线程B处理完成

解决活锁2 约定优先级

线程A 是等待10S 才让出所, 线程B如果发现已经被锁定那么立即释放锁


@Slf4j
public class DeadlockExample3 {

    static ReentrantLock reentrantLockA = new ReentrantLock();
    static ReentrantLock reentrantLockB = new ReentrantLock();

    public static void main(String[] args) {
        String name = ManagementFactory.getRuntimeMXBean().getName();
        String pid = name.split("@")[0];
        log.info("Pid is:" + pid);
        log.info("jstack " + pid);

        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.submit(() -> {
            try {
                //自旋
                while (reentrantLockA.tryLock(10, TimeUnit.SECONDS)) {
                    log.info("A任务重新初始化");
                    TimeUnit.SECONDS.sleep(1);
                    boolean b = reentrantLockB.tryLock(10, TimeUnit.SECONDS);
                    if (!b) {
                        reentrantLockA.unlock();
                        continue;
                    }
                    log.info("线程A处理任务");
                    break;
                }
                log.info("线程A处理完成");
            } catch (InterruptedException e) {
                log.error("线程中断", e);
            } finally {
                reentrantLockB.unlock();
                reentrantLockA.unlock();
            }
        });

        executorService.submit(() -> {
            try {
                //自旋
                while (reentrantLockB.tryLock(10, TimeUnit.SECONDS)) {
                    log.info("B任务重新初始化");
                    TimeUnit.SECONDS.sleep(2);
                    boolean locked = reentrantLockA.isLocked();
                    if (locked) {
                        reentrantLockB.unlock();
                        //避免活锁
                        TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(1, 2000));
                        continue;
                    }
                    boolean b = reentrantLockA.tryLock(10, TimeUnit.SECONDS);
                    if (!b) {
                        reentrantLockB.unlock();
                        continue;
                    }
                    log.info("线程B处理任务");
                    break;
                }
                log.info("线程B处理完成");
            } catch (InterruptedException e) {
                log.error("线程中断", e);
            } finally {
                reentrantLockA.unlock();
                reentrantLockB.unlock();
            }
        });
        executorService.shutdown();
    }

}

JAVA 死锁 & 活锁

JAVA 死锁 & 活锁

死锁

活锁

解决活锁1

解决活锁2 约定优先级

相关阅读更多精彩内容

友情链接更多精彩内容