问个并发的问题：CyclicBarrier和CountDownLatch的区别

[剑指苍穹]

我知道CyclicBarrier使多个线程互相等待，CountDownLatch使一个线程或多个线程等待其他线程，但是那不是CountDownLatch完全可以替代CyclicBarrier了，代码如下:

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

public class line3 implements Runnable{
	private CountDownLatch cd;
	private int id;
	public line3(CountDownLatch cd,int id){
		this.cd=cd;
		this.id=id;
	}
	public void run() {
			try {
				TimeUnit.MILLISECONDS.sleep(id*1000);//doSomeThing...
				cd.countDown();//这样子不是和CyclicBarrier效果一样...
				System.out.println("countDown"+id);
				cd.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("line3  "+id);
	}
	public static void main(String[] args) {
		CountDownLatch cd=new CountDownLatch(10);
		ExecutorService es=Executors.newCachedThreadPool();
		
		for (int i = 0; i < 10; i++) {
			es.execute(new line3(cd,i));
		}
		es.shutdown();
	}
}

另外书上说：CountDownLatch只触发一次,CylicBarrier可以触发多次,看不大明白，求高手通俗点的解释..或者给个例子也行..

[剑指苍穹]

各位高手哥哥们呢？？在线等呢,折腾一下午了没搞明白，搞不明白睡不着觉啊...

[剑指苍穹]

有高手解决了，发上来各位童鞋一起学习！！！
CountDownLatch不能重复使用示例：

import java.util.concurrent.*;


public class line3 implements Runnable{
	private CountDownLatch cd;
	private int id;
	public line3(CountDownLatch cd,int id){
		this.cd=cd;
		this.id=id;
	}
	public void run() {
			try {
				TimeUnit.MILLISECONDS.sleep(id*1000);
				cd.countDown();
				System.out.println("countDown "+id);
				cd.await();
				
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("line "+id+" Dead");
	}
	public static void main(String[] args) {
		final CountDownLatch cd=new CountDownLatch(10);
		final ExecutorService es=Executors.newCachedThreadPool();
		
		for (int i = 0; i < 9; i++) {
			es.execute(new line3(cd,i));
		}
		es.execute(new Runnable() {
			@Override
			public void run() {
				try {
					TimeUnit.MILLISECONDS.sleep(9*1000);
					cd.countDown();
					System.out.println("countDown "+9);
					cd.await();
					for (int i = 10; i < 20; i++) {//这里id为10-20区别于前10个进程，但是等待的时间稍有点长
						es.execute(new line3(cd,i));
					}
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});
		try {
			TimeUnit.SECONDS.sleep(15);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		es.shutdown();
		System.out.println("main Dead");
	}
}

CyclicBarrier示例：

import java.util.concurrent.*;

public class line2  {
		final CyclicBarrier barrier;
		
		//线程数
		int count;
		
		class Worker implements Runnable{
			int index;
			Worker(int index){
				this.index = index;
			}
			public void run() {
				System.out.println("第" + index + "个线程休眠"+(2 * index)+"秒！");
				try {
					Thread.sleep(2000 * index);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("第" + index + "个线程结束休眠！");
				
				try {
					//等待其它线程都处理完毕后，再继续以下代码的执行
					barrier.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					e.printStackTrace();
				}
				
				System.out.println("第" + index + "个线程继续剩下的任务");
			}
		}
		
		public line2(int count){
			this.count = count;
			
			//公共屏障点 等待到5个线程后，执行相应的barrierAction
			barrier = new CyclicBarrier(count, new Runnable() {
				public void run(){
					System.out.println("全部线程已执行完毕！");
					System.out.println("----------------------");
					for(int i=1;i<=5;i++){		//当全部线程执行完，重新添加线程，重用CyclicBarrier对象									
						new Thread(new Worker(i)).start();//此程序无限循环需手动结束
					}
					try {
						TimeUnit.MILLISECONDS.sleep(3000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
			
			for(int i=1;i<=5;i++){
				new Thread(new Worker(i)).start();
			}
		}
		
		public static void main(String[] args) {
			new line2(5);
		}
	}

[火龙果被占用了]

我认为这两个同步器的区别在 API 的文档中已经说明得很清楚了。

CyclicBarrier（循环障栅）从名字中就可以看出来是可以循环使用的。
CountDownLatch（倒计数门闩）顾名思义就是倒计数器，应该没有再来一次的倒计数器吧，哈哈。

[剑指苍穹]

[Quote=引用 3 楼 bao110908 的回复:]
我认为这两个同步器的区别在 API 的文档中已经说明得很清楚了。

CyclicBarrier（循环障栅）从名字中就可以看出来是可以循环使用的。
CountDownLatch（倒计数门闩）顾名思义就是倒计数器，应该没有再来一次的倒计数器吧，哈哈。
[/Quote]
关键一直没明白CyclicBarrier重复使用是咋样重复使用的（本人比较菜鸟，只相信亲眼见到的运行结果，别人说的不行....），所以总感觉完全可以用CountDownLatch替代CyclicBarrier......

[nyq1999]

循环赛和单场比赛的区别