CountDownLatch和CyclicBarrier的区别,举例分析

 

 

 

 

 

 

	import java.util.concurrent.CountDownLatch;

	public class TestCountDownLatch2 extends Thread {
		private int id;
		public TestCountDownLatch2(int id){
			this.id=id;
		}
		
		/**
		 * CountDownLatch 是并发包中提供的一个可用于控制多个线程同时开始某个动作的类，其
		 * 采用的方式为减计数的方式，当计数减至零时位于latch.await()后的代码才会被执行。
		 */
		private static CountDownLatch latch = new CountDownLatch(10);

		public static void main(String[] args) {
			long start = System.currentTimeMillis();
			int i = 0;
			while (i < 10) {
				i++;
				new TestCountDownLatch2(i).start();
			}
			try {
				latch.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("use time:" + (System.currentTimeMillis() - start));
		}

		public void run() {
			
			try {
				Thread.sleep(1000);
				System.out.println("..start.."+id);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			latch.countDown();
		System.out.println("..end.."+id);
		}
	}

 

 

运行结果：

..start..5
..start..2
..end..5
..start..6
..start..4
..end..4
..start..3
..end..3
..start..7
..end..7
..start..8
..end..8
..end..6
..start..1
..end..2
..end..1
..start..9
..end..9
..start..10
use time:1004
..end..10

 

结果分析：线程7还没有开始，线程4已经结束了，因此得出结果

CountDownLatch里的线程是到了运行的目标后继续干自己的其他事情（run方法latch.countDown();之后的代码）

 

 

	import java.util.concurrent.BrokenBarrierException;
	import java.util.concurrent.CyclicBarrier;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.TimeoutException;

	public class TestCyclicBarrier2 extends Thread {
		/**
		 * CyclicBarrier 和CountDownLatch不同，CyclicBarrier是当await 的数量达到了设置的数量后，
		 * 才继续往下执行
		 */
		static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);
		private int id;

		public TestCyclicBarrier2(int id) {
			this.id = id;
		}

		public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
			long start = System.currentTimeMillis();
			int i = 0;
			while (i < 10) {
				i++;
				new TestCyclicBarrier2(i).start();
			}
			//cyclicBarrier.await()//加上这句话会一直阻塞在这里（下面那句话暂时不会打印出来）直到所有线程都到达了，另外，如果加上句话， new CyclicBarrier(10);
			//改为 new CyclicBarrier(11);
			System.out.println("use time:" + (System.currentTimeMillis() - start));
		}

		public void run() {
			try {
				
				//cyclicBarrier.await(1000, TimeUnit.MILLISECONDS);
				System.out.println("--start__:" + id);
				cyclicBarrier.await();
				
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			} catch (BrokenBarrierException e) {
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("----end:" + id);
		}
	}

 

 

运行结果：

--start__:1
--start__:4
--start__:3
--start__:2
--start__:6
--start__:8
use time:1
--start__:5
--start__:7
--start__:10
--start__:9
----end:8
----end:5
----end:10
----end:9
----end:2
----end:1
----end:6
----end:3
----end:7
----end:4

 

结果分析：10个线程都开始了，后来才有线程结束

CyclicBarrier的线程需要等待其他线程后才能继续完成run方法其他逻辑

 

 总结

CountDownLatch 是计数器, 线程完成一个就记一个, 就像 报数一样, 只不过是递减的.

而CyclicBarrier更像一个水闸, 线程执行就想水流, 在水闸处都会堵住, 等到水满(线程到齐)了, 才开始泄流.

CountDownLatch里的线程是到了运行的目标后继续干自己的其他事情，CyclicBarrier的线程需要等待其他线程后才能继续完成下面的工作。