Java中关于线程同步，你会用到的4个类

àì夳堔傛蜴生んèń 2022-08-29 10:14 55阅读 0赞

![4598ff38202f8dd2c52bf371cc46fe24.png][]

### CountDownLatch ###

#### 解释： ####

CountDownLatch相当于一个门闩，门闩上挂了N把锁。只有N把锁都解开的话，门才会打开。怎么理解呢？我举一个赛跑比赛的例子，赛跑比赛中必须等待所有选手都准备好了，裁判才能开发令枪。选手才可以开始跑。

CountDownLatch当中主要有两个方法，一个是await()会挂上锁阻塞当前线程，相当于裁判站在起始点等待，等待各位选手准备就绪，一个是countDown方法用于解锁，相当于选手准备好了之后调用countDown方法告诉裁判自己准备就绪，当所有人都准备好了之后裁判开发令枪。

#### 代码： ####

public class TestCountDownLatch {
        public static void main(String[] args) {
            // 需要等待两个线程，所以传入参数为2
            CountDownLatch latch = new CountDownLatch(2);
            // 该线程运行1秒
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("1号选手准备就绪！用时1秒！");
                    latch.countDown();
                }
            }).start();
            
            // 该线程运行3秒
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("2号选手准备就绪！用时3秒！");
                    latch.countDown();
                }
            }).start();
            
            try {
                System.out.println("请1号选手和2号选手各就各位！");
                // 主线程在此等待两个线程执行完毕之后继续执行
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 两个线程执行完毕后，主线程恢复运行
            System.out.println("裁判发枪，1号选手和2号选手开跑！");
        }
    }

#### 运行结果： ####

请1号选手和2号选手各就各位！
    1号选手准备就绪！用时1秒！
    2号选手准备就绪！用时3秒！
    裁判发枪，1号选手和2号选手开跑！

如果去掉CountDownLatch的效果呢？运行结果就会变成如下：

请1号选手和2号选手各就各位！
    裁判发枪，1号选手和2号选手开跑！
    1号选手准备就绪！用时1秒！
    2号选手准备就绪！用时3秒！

裁判就会在选手还未准备就绪的时候开发令枪，这就乱套了。  
其实CountDownLatch一个最简单的用处就是计算多线程执行完毕时的时间。像刚才的例子当中两个线程并行执行了共花费了3秒钟。

### CyclicBarrier ###

#### 解释： ####

CyclicBarrier就像一个栅栏，将各个线程拦住。Cyclic是循环的英文，表明该工具可以进行循环使用。CyclicBarrier(N)的构造参数表明该一共有几个线程需要互相等待。它相当于N个选手约定进行多次比赛，每次比赛完都要在起跑点互相等待。

读者可能会马上疑惑这不是和CountDownLatch一样吗？不一样。因为CountDownLatch是裁判等待选手，是调用await()方法的线程，等待调用countDown()方法的各个线程。而CyclicBarrier是选手等待选手，是调用await()方法的线程互相等待，等待其他线程都运行好之后，再开始下一轮运行。

我们举一个例子，两个选手进行比赛，一共进行三轮比赛。

#### 代码： ####

public class TestCyclicBarrier {
        // 1号选手跑的轮数
        public static int countA = 1;
        // 2号选手跑的轮数
        public static int countB = 1;
        public static void main(String[] args) {
            // 填入2,代表2个线程互相等待
            CyclicBarrier barrier = new CyclicBarrier(2);
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 一共跑三轮
                    for (int i = 0; i < 3; i++) {
                        System.out.println("1号选手开始跑！当前第" + countA++ + "轮比赛！");
                        // 1号选手跑得慢，每次跑三秒
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        try {
                            System.out.println("1号选手抵达终点！");
                            // 调用等待方法，在此等待其他选手
                            barrier.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
    
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 一共等待三轮
                    for (int i = 0; i < 3; i++) {
                        System.out.println("2号选手开始跑！当前第" + countB++ + "轮比赛！");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        try {
                            System.out.println("2号选手抵达终点！");
                            // 调用等待方法，在此等待其他选手
                            barrier.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }
    
    }

#### 运行结果: ####

1号选手开始跑！当前第1轮比赛！
    2号选手开始跑！当前第1轮比赛！
    2号选手抵达终点！
    1号选手抵达终点！
    1号选手开始跑！当前第2轮比赛！
    2号选手开始跑！当前第2轮比赛！
    2号选手抵达终点！
    1号选手抵达终点！
    1号选手开始跑！当前第3轮比赛！
    2号选手开始跑！当前第3轮比赛！
    2号选手抵达终点！
    1号选手抵达终点！

每轮比赛1号选手和2号选手都会回到起跑线互相等待，再开启下一轮比赛。

如果不加CyclicBarrier呢？

1号选手开始跑！当前第1轮比赛！
    2号选手开始跑！当前第1轮比赛！
    2号选手抵达终点！
    2号选手开始跑！当前第2轮比赛！
    2号选手抵达终点！
    2号选手开始跑！当前第3轮比赛！
    1号选手抵达终点！
    1号选手开始跑！当前第2轮比赛！
    2号选手抵达终点！
    1号选手抵达终点！
    1号选手开始跑！当前第3轮比赛！
    1号选手抵达终点！

此时2号选手就直接跑完三轮比赛，不等1号选手了。

### Semaphore ###

Semaphore英文的字面意思是信号量。它的工作机制是每个线程想要获取运行的机会的话，都必须获取到信号量。acquire()方法阻塞的获取信号量，release()释放信号量。

举个例子，假设我们去迪士尼游玩，但是迪士尼担心游客很多的话，影响大家的游玩体验，于是规定每个小时只能卖出两张门票。这样就可以控制在游乐园当中的游客数量了。

#### 代码： ####

public class TestSemaphore {
    
        public static void main(String[] args) {
    
            Semaphore semaphore = new Semaphore(0);
            System.out.println("顾客在售票处等候中");
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (; ; ) {
                        try {
                            Thread.sleep(500);
                            // 等待出票
                            semaphore.acquire();
                            System.out.println("顾客拿到门票入场！");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
    
                    for (int i = 0; i < 3; i++) {
                        try {
                            // 等待一小时再发门票
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                        // 一次性发出两张门票
                        System.out.println("售票处第" + (i + 1) + "小时售出两张票！");
                        semaphore.release();
                        semaphore.release();
                    }
                }
            }).start();
    
            System.out.println("售票处开始售票！");
        }
    }

#### 运行结果： ####

顾客在售票处等候中...
    售票处开始售票！
    售票处第1小时售出两张票！
    顾客拿到门票入场！
    顾客拿到门票入场！
    售票处第2小时售出两张票！
    顾客拿到门票入场！
    顾客拿到门票入场！
    售票处第3小时售出两张票！
    顾客拿到门票入场！
    顾客拿到门票入场！

### Exchanger ###

#### 解释： ####

Exchanger提供了让两个线程互相交换数据的同步点。Exchanger有点像2个线程的CyclicBarrier，线程之间都是互相等待，区别在于Exchanger多了交换的操作。

举个例子好比以前玩网游的时候，买家和卖家必须走到地图上同一地点面对面进行交易一样，一手交钱一手交装备。

#### 代码： ####

public class TestExchanger {
        public static void main(String[] args) {
            Exchanger<String> exchanger = new Exchanger<>();
            
            new Thread(new Runnable() {
                @Override
                public void run() {
                    String weapon = "装备";
                    System.out.println("我是卖家，我带着" + weapon + "过来了！");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("卖家到达地图上交易地点");
                    try {
                        System.out.println("我是卖家，换回了" + exchanger.exchange(weapon));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                }
            }).start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    String money = "一万游戏币";
                    System.out.println("我是买家，我带着" + money + "过来了");
                    try {
                        Thread.sleep(4000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("买家到达地图上交易地点");
                    try {
                        System.out.println("我是买家，换回了" + exchanger.exchange(money));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                }
            }).start();
        }

运行结果：

我是卖家，我带着装备过来了！
    我是买家，我带着一万游戏币过来了
    卖家达到交易地点
    买家到达交易地点
    我是买家，换回了装备
    我是卖家，换回了一万游戏币

往期推荐

[数据库消耗 CPU 最高的 sql 语句如何定位？][CPU _ sql]

[怎么样通过Nginx实现限流？][Nginx]

[5个好用的开源网络监控工具][5]

[SpringBoot实现登录拦截的原理][SpringBoot]

[keepalived实现Nginx双机热备][keepalived_Nginx]

[一行代码让你摆脱U盘完成局域网文件传输][U]

[Docker简易搭建 ElasticSearch 集群][Docker_ ElasticSearch]

[我把跨境当副业，一个星期赚了7000块”：想给有梦想的人提个醒！！！][7000]

[这个基于jedis的Redis工具类可以收藏一下][jedis_Redis]

[ZooKeeper实现分布式队列、分布式锁和选举，很详细][ZooKeeper]

[Spring SchedulingConfigurer 实现动态定时任务][Spring SchedulingConfigurer]

[从原则、方案、策略及难点阐述分库分表][Link 1]

[(建议收藏)服务器宕机了不要慌，这样排查效率高][Link 2]

![0cb528a362df55ad3c4dc8970d3349f1.png][]

[4598ff38202f8dd2c52bf371cc46fe24.png]: /images/20220829/ea3190c42d1147b9a23f1417ec8923e4.png
[CPU _ sql]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44efaecb3366b81ed2f753608b1a1d36191643e727b5662228139dc1da831261e182b7d1b7&idx=2&mid=2247490199&scene=21&sn=ffd2237ecc6ea306cf8fa0d6d21b1ed0#wechat_redirect
[Nginx]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44efb6cb3366a0196d6a8a15935598596fe1429286e9ebe402a76cfdfd8e9ee7c7afd0479b&idx=1&mid=2247490191&scene=21&sn=cf9e2c7e787ff649fabc73a099ba867d#wechat_redirect
[5]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44efb6cb3366a03f989ee57eaca66fe09eba65954926469554efcadb264e3b5a36f49d49a8&idx=2&mid=2247490191&scene=21&sn=d93b68eef5d14609210368f05fe35da9#wechat_redirect
[SpringBoot]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44efb8cb3366ae130246b08e6bc6cccb847f641fed9afd7dfc9907240161c628865a7b0f42&idx=1&mid=2247490177&scene=21&sn=3ee25fb0bd5964d7fec8384c4426f11c#wechat_redirect
[keepalived_Nginx]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef4ecb336658cadbc79d1a7d08db1c523e4badc04fd6c04cb4e8a0d33206a436581f01bc&idx=1&mid=2247490167&scene=21&sn=6e45804ba5db31a876ad0477dba33ab3#wechat_redirect
[U]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef4ecb336658f827b4e492f2d4d3db4cc2ea6d936ac2e93e0e61dfc7362c576f37a17af4&idx=2&mid=2247490167&scene=21&sn=ce298a0d23b75c736d8780d50afc926d#wechat_redirect
[Docker_ ElasticSearch]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef4fcb3366596390e361b10db1b6616d405df719cb3b259805629d75601ba03475212cd6&idx=1&mid=2247490166&scene=21&sn=5eb8eed5d0a6cd5c59d00aae41ad0039#wechat_redirect
[7000]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef4fcb336659b1c864d0c9255b16e0c2eb4aaf7a30854462a7dd238892aa93b11040e767&idx=2&mid=2247490166&scene=21&sn=519f78fa7501840cdf6de96a0dec4564#wechat_redirect
[jedis_Redis]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef54cb336642fc5ffb45160a552fd6deaf7cef8039251c3962abfc74dccfc721fc97f799&idx=1&mid=2247490157&scene=21&sn=bcb84fb6107ce1a05912da335122700b#wechat_redirect
[ZooKeeper]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef55cb3366433da40ddcd71fa7f61a60df9902c152a77dc661d9166957a20393d9fdbcc5&idx=1&mid=2247490156&scene=21&sn=fe02fa5db8eafe9468cf5ad63f0d9b3e#wechat_redirect
[Spring SchedulingConfigurer]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef66cb33667087272c87b07ccb700b48782af0b82ab9df8c93be1a08bb8b0fa5444c1c2f&idx=1&mid=2247490143&scene=21&sn=3608b976ef47aaa572f7872fc76c6954#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef67cb336671c174f6fb2d258f0dc3df395e9ba991bb60740b99ab9aa2af4e03a4eb55d1&idx=1&mid=2247490142&scene=21&sn=424a472c4642ee01a3302fab53f1972a#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef65cb336673784019227c2c2a5ffaef2f35c40f5ea6e5e0a58b22a891cdeffbfa4cc713&idx=1&mid=2247490140&scene=21&sn=a781c5208f37ddaa4999755f98143f72#wechat_redirect
[0cb528a362df55ad3c4dc8970d3349f1.png]: /images/20220829/f42ae458a48e4c3aa85e3f297cda7561.png