同步工具类：CountDownLatch、CyclicBarrier和Exchanger

最新推荐文章于 2024-08-16 23:08:28 发布

weixin_33827965

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量82

点赞数

文章标签： java python

原文链接：https://my.oschina.net/u/3696939/blog/1913797

版权

2019独角兽企业重金招聘Python工程师标准>>>

1. CountDownLatch

1.1说明：

CountDownLatch可以理解为一个计数器在初始化时设置初始值，当一个线程需要等待某些操作先完成时，需要调用await()方法。这个方法让线程进入休眠状态直到等待的所有线程都执行完成。每调用一次countDown()方法内部计数器减1,当计数达到0时，则所有的等待着开始执行。可以实现一个线程（也可以是多个线程）等待其他线程来唤醒，也可以实现一个线程通知多个线程的效果。

举例：类似裁判一声口令下，所有的运动员才能开始奔跑，或者所有的运动员奔跑完后才有比赛结果。
核心方法两个：countDown()和await()

（1）countDown():使CountDownLatch维护的内部计数器减1,每个被等待的线程完成的时候调用。

（2）await():线程在执行到CountDownLatch的时候会将此线程置于休眠。

2.2使用案例：

模拟裁判发出命令后，3个运动员以不同的速度奔跑。等3个运动员都跑完后，裁判得到比赛结果。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * CountDownLatch demo ：模拟裁判发出命令后，3个运动员以不同的速度奔跑。等3个运动员都跑完后，裁判得到比赛结果
 * 
 * @author Smile
 */
public class CountdownLatchTest {

	public static void main(String[] args) throws InterruptedException {
		ExecutorService service = Executors.newCachedThreadPool();
		// 创建一个“命令”计数器
		final CountDownLatch cdOrder = new CountDownLatch(1);
		// 创建三个“回应”计数器
		final CountDownLatch cdAnswer = new CountDownLatch(3);
		for (int i = 0; i < 3; i++) {
			Runnable runnable = new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println("线程" + Thread.currentThread().getName() + "正在准备接收命令");
						// 等待“命令”计数器为0
						cdOrder.await();

						System.out.println("线程" + Thread.currentThread().getName() + "已收命令");
						Thread.sleep((long) (Math.random() * 10000));
						System.out.println("线程" + Thread.currentThread().getName() + "处理结束！回应命令处理结果");
						// “回应”计数器减1
						cdAnswer.countDown();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

				}
			};
			service.execute(runnable);
		}

		// 主线程发命令CountDownLatch cdOrder命令
		Thread.sleep((long) (Math.random() * 10000));
		System.out.println("线程" + Thread.currentThread().getName() + "即将发布命令");
		// “命令”计数器减1，“命令”计数器为0，开始唤醒cdOrder.await()的线程
		cdOrder.countDown();
		System.out.println("线程" + Thread.currentThread().getName() + "已发布命令，等待处理结果……");

		// 等待“回应”计数器为0时，再继续执行
		cdAnswer.await();
		System.out.println("线程" + Thread.currentThread().getName() + "已收到全部结果结果。");

		service.shutdown();
	}

}

运行结果：

2. CyclicBarrier

2.1说明：

CyclicBarrier是一个同步工具类，它允许一组线程互相等待，直到到达某个公共屏障点。

举例：整个公司的人利用周末时间到集体郊游一样，先各自从家里出发到公司集合，再同时出发到公园分开游玩，在餐馆集合后再同时开始聚餐。这里的“公司集合”、“餐馆集合”就是指的是公共屏障点。
常用方法：

（1）await()方法：在调用await()方法后，CyclicBarrier将阻塞这个线程并将它置入休眠状态等待其它线程的到来。

2.2 与CountDownLatch的区别：

（1）与CountDownLatch不同的是该barrier在释放等待线程后可以重用，所以称它为循环（Cyclic）的屏障（Barrier）。

（2）CountDownLatch主要是实现了1个或N个线程需要等待其他线程完成某项操作之后才能继续往下执行操作，描述的是1个线程或N个线程等待其他线程的关系。CyclicBarrier主要是实现了多个线程之间相互等待，直到所有的线程都满足了条件之后各自才能继续执行后续的操作，描述的多个线程内部相互等待的关系。

2.3使用案例：

模拟线程1、线程2、线程3以不同时间到达集合点1后，再一起以不同的速度到达集合点2，等所有线程都到达集合点2后，再一起出发到集合点3。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * CyclicBarrier
 * Demo：模拟线程1、线程2、线程3以不同时间到达集合点1后，再一起以不同的速度到达集合点2，等所有线程都到达集合点2后，再一起出发到集合点3
 * 
 * @author Smile
 */
public class CyclicBarrierTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		// 设置屏障，此屏障需要等待3个线程
		final CyclicBarrier cb = new CyclicBarrier(3);
		for (int i = 0; i < 3; i++) {
			Runnable runable = new Runnable() {
				@Override
				public void run() {
					try {
						Thread.sleep((long) (Math.random() * 10000));
						System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点1， 当前已有"
								+ (cb.getNumberWaiting() + 1) + "个并发"
								+ ((2 == cb.getNumberWaiting()) ? "。线程已经全部到达集合点1,继续往下走！" : ""));
						cb.await(); // 设置第一次屏障，需等3个线程全部执行到此时，才继续往下

						Thread.sleep((long) (Math.random() * 10000));
						System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点2， 当前已有"
								+ (cb.getNumberWaiting() + 1) + "个并发"
								+ ((2 == cb.getNumberWaiting()) ? "。线程已经全部到达集合点2,继续往下走！" : ""));
						cb.await(); // 设置第二次屏障，需等3个线程全部执行到此时，才继续往下

						Thread.sleep((long) (Math.random() * 10000));
						System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点3， 当前已有"
								+ (cb.getNumberWaiting() + 1) + "个并发"
								+ ((2 == cb.getNumberWaiting()) ? "。线程已经全部到达集合点3,完毕！" : ""));
						cb.await(); // 设置第三次屏障，需等3个线程全部执行到此时，才继续往下

					} catch (InterruptedException e) {
						e.printStackTrace();
					} catch (BrokenBarrierException e) {
						e.printStackTrace();
					}
				}
			};
			service.execute(runable);
		}
		service.shutdown();
	}
}

运行结果：

3. Exchanger

3.1说明

用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交互数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才彼此交换数据。

核心方法：

public V exchange(V x)：等待另一个线程到达交换点（如果当前线程没有被中断），然后将已知的对象传给它，返回接收的对象。

3.2使用案例：

模拟两个线程交换数据：当线程A调用Exchange对象的exchange()方法后，他会陷入阻塞状态，直到线程B也调用了exchange()方法，然后以线程安全的方式交换数据，之后线程A和B继续运行。

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Exchanger Demo:两个线程之间的信息交换
 * 用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交互数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才彼此交换数据
 * 
 * @author xiao
 *
 */
public class ExchangerTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final Exchanger exchanger = new Exchanger();
		service.execute(new Runnable() {
			@Override
			public void run() {
				try {
					String data1 = "XMSSS";
					System.out.println("线程" + Thread.currentThread().getName() + "正在把数据 " + data1 + "交换出去");
					Thread.sleep((long) (Math.random() * 10000));
					String data2 = (String) exchanger.exchange(data1);
					System.out.println("线程" + Thread.currentThread().getName() + "换回的数据为 " + data2);

				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});

		service.execute(new Runnable() {
			@Override
			public void run() {
				try {
					String data1 = "GRSXX";
					System.out.println("线程" + Thread.currentThread().getName() + "正在把数据 " + data1 + "交换出去");
					Thread.sleep((long) (Math.random() * 10000));
					String data2 = (String) exchanger.exchange(data1);
					System.out.println("线程" + Thread.currentThread().getName() + "换回的数据为 " + data2);

				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
	}
}

运行效果：