轮询锁使用时遇到的问题与解决方案!

古城微笑少年丶 2023-10-03 15:39 32阅读 0赞

![680871e8c5e8db8cb59a11675066943a.png][]

作者 | 王磊

来源 | Java中文社群（ID：javacn666）

转载请联系授权（微信ID：GG\_Stone

当我们遇到死锁之后，除了可以手动重启程序解决之外，还可以考虑是[**使用顺序锁和轮询锁**][Link 1]，这部分的内容可以参考我的[**上一篇文章**][Link 1]，这里就不再赘述了。然而，轮询锁在使用的过程中，如果使用不当会带来新的严重问题，所以本篇我们就来了解一下这些问题，以及相应的解决方案。

### 问题演示 ###

当我们没有使用轮询锁之前，可能会出现这样的问题：

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class DeadLockByReentrantLock {
        public static void main(String[] args) {
            Lock lockA = new ReentrantLock(); // 创建锁 A
            Lock lockB = new ReentrantLock(); // 创建锁 B
    
            // 创建线程 1
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lockA.lock(); // 加锁
                    System.out.println("线程 1:获取到锁 A!");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程 1:等待获取 B...");
                        lockB.lock(); // 加锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                }
            });
            t1.start(); // 运行线程
    
            // 创建线程 2
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lockB.lock(); // 加锁
                    System.out.println("线程 2:获取到锁 B!");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程 2:等待获取 A...");
                        lockA.lock(); // 加锁
                        try {
                            System.out.println("线程 2:获取到锁 A!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lockB.unlock(); // 释放锁
                    }
                }
            });
            t2.start(); // 运行线程
        }
    }

以上代码的执行结果如下：

![f1a665a5ec74c06d5abc95fb36c9ed22.png][] img

从上述结果可以看出，此时程序中出现了线程相互等待，并尝试获取对方（锁）资源的情况，这就是典型的死锁问题了。

### 简易版轮询锁 ###

当出现死锁问题之后，我们就可以使用轮询锁来解决它了，它的实现思路是通过轮询的方式来获取多个锁，如果中途有任意一个锁获取失败，则执行回退操作，释放当前线程拥有的所有锁，等待下一次重新执行，这样就可以避免多个线程同时拥有并霸占锁资源了，从而直接解决了死锁的问题，简易版的轮询锁实现如下：

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class SolveDeadLockExample2 {
        public static void main(String[] args) {
            Lock lockA = new ReentrantLock(); // 创建锁 A
            Lock lockB = new ReentrantLock(); // 创建锁 B
    
            // 创建线程 1(使用轮询锁)
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 调用轮询锁
                    pollingLock(lockA, lockB);
                }
            });
            t1.start(); // 运行线程
    
            // 创建线程 2
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lockB.lock(); // 加锁
                    System.out.println("线程 2:获取到锁 B!");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程 2:等待获取 A...");
                        lockA.lock(); // 加锁
                        try {
                            System.out.println("线程 2:获取到锁 A!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lockB.unlock(); // 释放锁
                    }
                }
            });
            t2.start(); // 运行线程
        }
    
        /**
         * 轮询锁
         */
        private static void pollingLock(Lock lockA, Lock lockB) {
            // 轮询锁
            while (true) {
                if (lockA.tryLock()) { // 尝试获取锁
                    System.out.println("线程 1:获取到锁 A!");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程 1:等待获取 B...");
                        if (lockB.tryLock()) { // 尝试获取锁
                            try {
                                System.out.println("线程 1:获取到锁 B!");
                            } finally {
                                lockB.unlock(); // 释放锁
                                System.out.println("线程 1:释放锁 B.");
                                break;
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lockA.unlock(); // 释放锁
                        System.out.println("线程 1:释放锁 A.");
                    }
                }
                // 等待一秒再继续执行
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

以上代码的执行结果如下：

![7e80ead908d46166d1171844eb433473.png][] img

从上述结果可以看出，当我们在程序中使用轮询锁之后就不会出现死锁的问题了，但以上轮询锁也并不是完美无缺的，下面我们来看看这个轮询锁会有什么样的问题？

### 问题1：死循环 ###

以上简易版的轮询锁，如果遇到有一个线程一直霸占或者长时间霸占锁资源的情况，就会导致这个轮询锁进入死循环的状态，它会尝试一直获取锁资源，这样就会造成新的问题，带来不必要的性能开销，具体示例如下。

#### 反例 ####

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class SolveDeadLockExample {
    
        public static void main(String[] args) {
            Lock lockA = new ReentrantLock(); // 创建锁 A
            Lock lockB = new ReentrantLock(); // 创建锁 B
    
            // 创建线程 1(使用轮询锁)
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 调用轮询锁
                    pollingLock(lockA, lockB);
                }
            });
            t1.start(); // 运行线程
    
            // 创建线程 2
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lockB.lock(); // 加锁
                    System.out.println("线程 2:获取到锁 B!");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程 2:等待获取 A...");
                        lockA.lock(); // 加锁
                        try {
                            System.out.println("线程 2:获取到锁 A!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        // 如果此处代码未执行，线程 2 一直未释放锁资源
                        // lockB.unlock(); 
                    }
                }
            });
            t2.start(); // 运行线程
        }
    
        /**
         * 轮询锁
         */
        public static void pollingLock(Lock lockA, Lock lockB) {
            while (true) {
                if (lockA.tryLock()) { // 尝试获取锁
                    System.out.println("线程 1:获取到锁 A!");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程 1:等待获取 B...");
                        if (lockB.tryLock()) { // 尝试获取锁
                            try {
                                System.out.println("线程 1:获取到锁 B!");
                            } finally {
                                lockB.unlock(); // 释放锁
                                System.out.println("线程 1:释放锁 B.");
                                break;
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lockA.unlock(); // 释放锁
                        System.out.println("线程 1:释放锁 A.");
                    }
                }
                // 等待一秒再继续执行
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

以上代码的执行结果如下：

![1df971615fa40e854c018ce6342163de.png][] img

从上述结果可以看出，线程 1 轮询锁进入了死循环的状态。

#### 优化版 ####

针对以上死循环的情况，我们可以改进的思路有以下两种：

1.  添加最大次数限制：如果经过了 n 次尝试获取锁之后，还未获取到锁，则认为获取锁失败，执行失败策略之后终止轮询（失败策略可以是记录日志或其他操作）；
2.  添加最大时长限制：如果经过了 n 秒尝试获取锁之后，还未获取到锁，则认为获取锁失败，执行失败策略之后终止轮询。

以上策略任选其一就可以解决死循环的问题，出于实现成本的考虑，我们可以采用轮询最大次数的方式来改进轮询锁，具体实现代码如下：

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class SolveDeadLockExample {
    
        public static void main(String[] args) {
            Lock lockA = new ReentrantLock(); // 创建锁 A
            Lock lockB = new ReentrantLock(); // 创建锁 B
    
            // 创建线程 1(使用轮询锁)
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 调用轮询锁
                    pollingLock(lockA, lockB, 3);
                }
            });
            t1.start(); // 运行线程
    
            // 创建线程 2
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    lockB.lock(); // 加锁
                    System.out.println("线程 2:获取到锁 B!");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程 2:等待获取 A...");
                        lockA.lock(); // 加锁
                        try {
                            System.out.println("线程 2:获取到锁 A!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        // 线程 2 忘记释放锁资源
                        // lockB.unlock(); // 释放锁
                    }
                }
            });
            t2.start(); // 运行线程
        }
    
        /**
         * 轮询锁
         *
         * maxCount：最大轮询次数
         */
        public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
            // 轮询次数计数器
            int count = 0;
            while (true) {
                if (lockA.tryLock()) { // 尝试获取锁
                    System.out.println("线程 1:获取到锁 A!");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程 1:等待获取 B...");
                        if (lockB.tryLock()) { // 尝试获取锁
                            try {
                                System.out.println("线程 1:获取到锁 B!");
                            } finally {
                                lockB.unlock(); // 释放锁
                                System.out.println("线程 1:释放锁 B.");
                                break;
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lockA.unlock(); // 释放锁
                        System.out.println("线程 1:释放锁 A.");
                    }
                }
    
                // 判断是否已经超过最大次数限制
                if (count++ > maxCount) {
                    // 终止循环
                    System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                    return;
                }
    
                // 等待一秒再继续尝试获取锁
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

以上代码的执行结果如下：

![0dd0866bd424c8b968fbd998710cf49d.png][] img

从以上结果可以看出，当我们改进之后，轮询锁就不会出现死循环的问题了，它会尝试一定次数之后终止执行。

### 问题2：线程饿死 ###

我们以上的轮询锁的轮询等待时间是固定时间，如下代码所示：

// 等待 1s 再尝试获取（轮询）锁
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

这样在特殊情况下会造成线程饿死的问题，也就是轮询锁一直获取不到锁的问题，比如以下示例。

#### 反例 ####

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class SolveDeadLockExample {
    
        public static void main(String[] args) {
            Lock lockA = new ReentrantLock(); // 创建锁 A
            Lock lockB = new ReentrantLock(); // 创建锁 B
    
            // 创建线程 1(使用轮询锁)
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 调用轮询锁
                    pollingLock(lockA, lockB, 3);
                }
            });
            t1.start(); // 运行线程
    
            // 创建线程 2
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        lockB.lock(); // 加锁
                        System.out.println("线程 2:获取到锁 B!");
                        try {
                            System.out.println("线程 2:等待获取 A...");
                            lockA.lock(); // 加锁
                            try {
                                System.out.println("线程 2:获取到锁 A!");
                            } finally {
                                lockA.unlock(); // 释放锁
                            }
                        } finally {
                            lockB.unlock(); // 释放锁
                        }
                        // 等待一秒之后继续执行
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            t2.start(); // 运行线程
        }
    
        /**
         * 轮询锁
         */
        public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
            // 循环次数计数器
            int count = 0;
            while (true) {
                if (lockA.tryLock()) { // 尝试获取锁
                    System.out.println("线程 1:获取到锁 A!");
                    try {
                        Thread.sleep(100); // 等待 0.1s(获取锁需要的时间)
                        System.out.println("线程 1:等待获取 B...");
                        if (lockB.tryLock()) { // 尝试获取锁
                            try {
                                System.out.println("线程 1:获取到锁 B!");
                            } finally {
                                lockB.unlock(); // 释放锁
                                System.out.println("线程 1:释放锁 B.");
                                break;
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lockA.unlock(); // 释放锁
                        System.out.println("线程 1:释放锁 A.");
                    }
                }
    
                // 判断是否已经超过最大次数限制
                if (count++ > maxCount) {
                    // 终止循环
                    System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                    return;
                }
    
                // 等待一秒再继续尝试获取锁
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

以上代码的执行结果如下：

![4f63bac88b7e6da6a2fad77def8a9d2e.png][] img

从上述结果可以看出，线程 1（轮询锁）一直未成功获取到锁，造成这种结果的原因是：线程 1 每次轮询的等待时间为固定的 1s，而线程 2 也是相同的频率，每 1s 获取一次锁，这样就会导致线程 2 会一直先成功获取到锁，而线程 1 则会一直处于“饿死”的情况，执行流程如下图所示：

![9210c08b469116d1c449f064832dad90.png][] img

#### 优化版 ####

接下来，我们可以将轮询锁的固定等待时间，**改进为固定时间 + 随机时间的方式**，这样就可以避免因为获取锁的频率一致，而造成轮询锁“饿死”的问题了，具体实现代码如下：

import java.util.Random;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class SolveDeadLockExample {
        private static Random rdm = new Random();
    
        public static void main(String[] args) {
            Lock lockA = new ReentrantLock(); // 创建锁 A
            Lock lockB = new ReentrantLock(); // 创建锁 B
    
            // 创建线程 1(使用轮询锁)
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 调用轮询锁
                    pollingLock(lockA, lockB, 3);
                }
            });
            t1.start(); // 运行线程
    
            // 创建线程 2
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        lockB.lock(); // 加锁
                        System.out.println("线程 2:获取到锁 B!");
                        try {
                            System.out.println("线程 2:等待获取 A...");
                            lockA.lock(); // 加锁
                            try {
                                System.out.println("线程 2:获取到锁 A!");
                            } finally {
                                lockA.unlock(); // 释放锁
                            }
                        } finally {
                            lockB.unlock(); // 释放锁
                        }
                        // 等待一秒之后继续执行
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            t2.start(); // 运行线程
        }
    
        /**
         * 轮询锁
         */
        public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
            // 循环次数计数器
            int count = 0;
            while (true) {
                if (lockA.tryLock()) { // 尝试获取锁
                    System.out.println("线程 1:获取到锁 A!");
                    try {
                        Thread.sleep(100); // 等待 0.1s(获取锁需要的时间)
                        System.out.println("线程 1:等待获取 B...");
                        if (lockB.tryLock()) { // 尝试获取锁
                            try {
                                System.out.println("线程 1:获取到锁 B!");
                            } finally {
                                lockB.unlock(); // 释放锁
                                System.out.println("线程 1:释放锁 B.");
                                break;
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lockA.unlock(); // 释放锁
                        System.out.println("线程 1:释放锁 A.");
                    }
                }
    
                // 判断是否已经超过最大次数限制
                if (count++ > maxCount) {
                    // 终止循环
                    System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                    return;
                }
    
                // 等待一定时间(固定时间 + 随机时间)之后再继续尝试获取锁
                try {
                    Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定时间 + 随机时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

以上代码的执行结果如下：

![e7302eb06b335b4f046c8086a4ad8a6f.png][] img

从上述结果可以看出，线程 1（轮询锁）加入随机等待时间之后就不会出现线程饿死的问题了。

### 总结 ###

本文我们介绍了轮询锁的用途，用于解决死锁问题，但简易版的轮询锁在某些情况下会造成死循环和线程饿死的问题，因此我们对轮询锁进行了优化，给轮询锁加入了最大轮询次数，以及随机轮询等待时间，这样就可以解决因为引入轮询锁而造成的新问题了，这样就可以愉快的使用它来解决死锁的问题了。

**参考 & 鸣谢**

《Java并发编程实战》

\---END---

--------------------

##### 原创并发文章推荐 #####

[1.线程的故事：我的3位母亲成就了优秀的我！][1._3]

[2.线程池的7种创建方式，强烈推荐你用它...][2._7_...]

[3.轻量级锁一定比重量级锁快吗？][3.]

[4.这样终止线程，竟然会导致服务宕机？][4.]

[5.漫画：如何证明sleep不释放锁，而wait释放锁？][5._sleep_wait]

[6.池化技术到达有多牛？看了这个对比吓我一跳！][6.]

[7.求求你，别再用wait和notify了！][7._wait_notify]

[8.Semaphore自白：限流器用我就对了！][8.Semaphore]

[9.CountDownLatch：别浪，等人齐再团！][9.CountDownLatch]

[10.CyclicBarrier：人齐了，老司机就发车了！][10.CyclicBarrier]

[11.Java中用户线程和守护线程区别这么大？][11.Java]

[12.ThreadLocal不好用？那是你没用对！][12.ThreadLocal]

[13.ThreadLocal内存溢出代码演示和原因分析！][13.ThreadLocal]

[14.SimpleDateFormat线程不安全的5种解决方案！][14.SimpleDateFormat_5]

[15.synchronized 加锁 this 和 class 的区别！][15.synchronized _ this _ class]

[16.synchronized 优化手段之锁膨胀机制！][16.synchronized]

[17.synchronized 中的 4 个优化，你知道几个？][17.synchronized _ 4]

[18.ReentrantLock 中的 4 个坑！][18.ReentrantLock _ 4]

[19.图解：为什么非公平锁的性能更高？][19.]

[20.死锁的 4 种排查工具 ！][20._ 4 _]

[21.死锁终结者：顺序锁和轮询锁！][Link 1]

--------------------

[680871e8c5e8db8cb59a11675066943a.png]: https://img-blog.csdnimg.cn/img_convert/680871e8c5e8db8cb59a11675066943a.png
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf956dccb81c7b07e5e9b112b10c6cc5a190729262ccebe97196075804d32112578db63954&idx=1&mid=2247497813&scene=21&sn=6ad7b879e60af14934c5c51d67798e00#wechat_redirect
[f1a665a5ec74c06d5abc95fb36c9ed22.png]: https://img-blog.csdnimg.cn/img_convert/f1a665a5ec74c06d5abc95fb36c9ed22.png
[7e80ead908d46166d1171844eb433473.png]: https://img-blog.csdnimg.cn/img_convert/7e80ead908d46166d1171844eb433473.png
[1df971615fa40e854c018ce6342163de.png]: https://img-blog.csdnimg.cn/img_convert/1df971615fa40e854c018ce6342163de.png
[0dd0866bd424c8b968fbd998710cf49d.png]: https://img-blog.csdnimg.cn/img_convert/0dd0866bd424c8b968fbd998710cf49d.png
[4f63bac88b7e6da6a2fad77def8a9d2e.png]: https://img-blog.csdnimg.cn/img_convert/4f63bac88b7e6da6a2fad77def8a9d2e.png
[9210c08b469116d1c449f064832dad90.png]: https://img-blog.csdnimg.cn/img_convert/9210c08b469116d1c449f064832dad90.png
[e7302eb06b335b4f046c8086a4ad8a6f.png]: https://img-blog.csdnimg.cn/img_convert/e7302eb06b335b4f046c8086a4ad8a6f.png
[1._3]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf830cccb80a1a69c0b37109082b541b5ed1df80943b9ec50a6a663393a8fc7a7a1d033979&idx=1&mid=2247495220&scene=21&sn=c81f58dad1b384181bf2e5af6cf12440#wechat_redirect
[2._7_...]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf8fcbccb806dd5cd7c63cca08103028bcdb36010636cdb30f8a3af506c3528075d9be1c12&idx=1&mid=2247492339&scene=21&sn=3667ed5b8e437b40024f5c3ba9f16789#wechat_redirect
[3.]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc68f9ccbbe1efdfe6f1d5a319725000631c8c22d650228180e42f1449f298943c0c096359&idx=1&mid=2247484865&scene=21&sn=8f8c02deee43b78a2f589f42f47d22fa#wechat_redirect
[4.]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc6b10ccbbe206ada073cab9642fe0bb1af451c2890d01b49d58ed2a68c4a4cbe36489dbdf&idx=1&mid=2247484968&scene=21&sn=effbab986e8e26a3150535aea3cf66f9#wechat_redirect
[5._sleep_wait]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc62b2ccbbeba43cdaa4e95a8263ac7bd9dc42bf75b9060ff0354e724e0bc2215dda232b10&idx=1&mid=2247487370&scene=21&sn=90c0bd01fd490b680eae9b60515e5e5f#wechat_redirect
[6.]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc7d29ccbbf43f470d3aa206d7bf01d5bb0bd54d94a17a94c71a0fad8064afcedcbe61bca5&idx=1&mid=2247487505&scene=21&sn=483f5064f311704ae58eced059142235#wechat_redirect
[7._wait_notify]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf8f61ccb8067790023944dc632aff9869dbdaeac014aa0e94f7f42df00db68238f29f4f53&idx=1&mid=2247492185&scene=21&sn=28b89032d2c1cb50bcb2b0feaeadc7c0#wechat_redirect
[8.Semaphore]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf8325ccb80a332977b10d31ff0ea07be3fb91c7f4cb696605c38d5ac4258167c46bbf62e3&idx=1&mid=2247495197&scene=21&sn=12b9e794ea7f425cd50b2b79cf0aa80b#wechat_redirect
[9.CountDownLatch]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf801eccb809081aeca421d114ad688a9eb982b43ec26c17e56978431725a6ea7aeae66908&idx=1&mid=2247494950&scene=21&sn=c748fcc97cad2dce60b73ef8722c7bae#wechat_redirect
[10.CyclicBarrier]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf80abccb809bd3bf7f69ecb785db9fcd296aa49ed27ea378a5d6a9f2a7aa46931b762f8f4&idx=1&mid=2247495059&scene=21&sn=ba5f236b755897ec5a2de37f3977aa50#wechat_redirect
[11.Java]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf835eccb80a48d244250ca7d6725de2a72091602994e402b97b51e5f4b63f8ecbf2c60f99&idx=1&mid=2247495270&scene=21&sn=33c3316028dd1cb8883e63da328fdbd4#wechat_redirect
[12.ThreadLocal]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf8205ccb80b137afe1b71787cd9b5484c9a0afcd5f22a9c47f1fe72cba879dd5bb23d7384&idx=1&mid=2247495485&scene=21&sn=d09a6c32f61699c54c860fd5879ae14b#wechat_redirect
[13.ThreadLocal]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf82d5ccb80bc383e9a2683e43ee9a1465675605b8e462e8737a9fcbfcbae42c5942c06e84&idx=1&mid=2247495661&scene=21&sn=fe02ab94e2522dcbf3eb6be0b6339caa#wechat_redirect
[14.SimpleDateFormat_5]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf8244ccb80b528eef4147f9f639675e29e481426833780d1ed525d56a74c4228c1a952ef9&idx=1&mid=2247495548&scene=21&sn=68f3b875ea8d9476cebb9a9936feb86d#wechat_redirect
[15.synchronized _ this _ class]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf9817ccb811011f29601aaee0880048e4e6a21e520913fbebbfa141f5adff07e33073d008&idx=1&mid=2247497007&scene=21&sn=e88ceceee130737250db7236d009b526#wechat_redirect
[16.synchronized]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf9805ccb81113bc2e7835645e6249bed9abe6bb96fb0eb511f0fe8dfdd67fa983503f4d0b&idx=1&mid=2247497021&scene=21&sn=a4c9e9af10ea9dbc4e6295ceb6e986a0#wechat_redirect
[17.synchronized _ 4]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf98bbccb811adce31875ac027a149c4c0cb3d9618166a11b11efed89dbf70d4c21ac1b1ac&idx=1&mid=2247497091&scene=21&sn=43fb8bcd58b4f8b84ade9e7142205293#wechat_redirect
[18.ReentrantLock _ 4]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf988dccb8119b7b1415454cfe9cadaddc80cec7dccca2b0b51484795da298db0932bb97f0&idx=1&mid=2247497141&scene=21&sn=5b1a86743eace289cd4a7a197e5f6b6e#wechat_redirect
[19.]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf9b68ccb8127ed04c0c0daaa189fc5c7746b1722aff9928b59c7124671818f68f9db6cb60&idx=1&mid=2247497296&scene=21&sn=78f39ea7f30df692019b9d45c1a2d624#wechat_redirect
[20._ 4 _]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf9a96ccb8138058f5c66a62d65b40267b7b596373de411a66bc685071f9fef2935848fd22&idx=1&mid=2247497646&scene=21&sn=f05e1c5424fee8f6096907020232e2e5#wechat_redirect