Java CyclicBarrier 设置线程等待点

package J2SE.thread;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
 * CyclicBarrier  barrier = new CyclicBarrier(int points);//声明时要有点的数量
 *  barrier.await(); 设置了一个  公共屏障点，，线程都到达该点后才继续往下执行 
 */
public class CyclicBarrierTest {
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		int nums = 3;
		final CyclicBarrier barrier = new CyclicBarrier(nums);
		for (int i = 0; i < nums; i++) {
	
			MyRunn runn =  new MyRunn(i + "", barrier);
			service.execute(runn);
		}
		service.shutdown();
	}
	
	static class MyRunn implements Runnable {
		String name;
		CyclicBarrier barrier;
		
		public MyRunn(String name, CyclicBarrier barrier) {
			this.name = "thread-" + name;
			this.barrier = barrier;
		}

		@Override
		public void run() {
			try {
				Thread.sleep((long)(Math.random() * 100));
				System.out.println(name + "即将到达集合点1，" + 
						(barrier.getNumberWaiting() + 1 == barrier.getParties()?
								"都到齐了，继续走啊" : "正在等待"));
				barrier.await();

				Thread.sleep((long)(Math.random() * 100));
				System.out.println(name + "即将到达集合点2，" + 
						(barrier.getNumberWaiting() + 1 == barrier.getParties()?
								"都到齐了，继续走啊" : "正在等待"));
				barrier.await();
			
				Thread.sleep((long)(Math.random() * 100));
				System.out.println(name + "即将到达集合点3，" + 
						(barrier.getNumberWaiting() + 1 == (barrier.getParties())?
								"到达终点了，休息了" : "正在等待"));
				
				barrier.await();

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

输出结果

thread-1即将到达集合点1，正在等待

thread-2即将到达集合点1，正在等待

thread-0即将到达集合点1，都到齐了，继续走啊

thread-2即将到达集合点2，正在等待

thread-1即将到达集合点2，正在等待

thread-0即将到达集合点2，都到齐了，继续走啊

thread-0即将到达集合点3，正在等待

thread-2即将到达集合点3，正在等待

thread-1即将到达集合点3，到达终点了，休息了