CountDownLatch和CyclicBarrier 的用法

CountDownLatch是减计数方式，计数==0时释放所有等待的线程；CyclicBarrier是加计数方式，计数达到构造方法中参数指定的值时释放所有等待的线程。
CountDownLatch当计数到0时，计数无法被重置；CyclicBarrier计数达到指定值时，计数置为0重新开始。
CountDownLatch每次调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响；CyclicBarrier只有一个await()方法，调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞。

1. import java.util.concurrent.CountDownLatch;
2. public class TestConcurrent extends Thread {
3. /**
4. * CountDownLatch 是并发包中提供的一个可用于控制多个线程同时开始某个动作的类，其
5. * 采用的方式为减计数的方式，当计数减至零时位于latch.await()后的代码才会被执行。
6. */
7. private static CountDownLatch latch = new CountDownLatch(10);
8. public static void main(String[] args) {
9. long start = System.currentTimeMillis();
10. int i = 0;
11. while (i < 10) {
12. i++;
13. new TestConcurrent().start();
14. }
15. try {
16. latch.await();
17. } catch (InterruptedException e) {
18. e.printStackTrace();
19. }
20. System.out.println("use time:" + (System.currentTimeMillis() - start));
21. }
22. public void run() {
23. System.out.println("...");
24. try {
25. Thread.sleep(100);
26. } catch (InterruptedException e) {
27. e.printStackTrace();
28. }
29. latch.countDown();
30. }
31. }

import java.util.concurrent.CountDownLatch;

public class TestConcurrent extends Thread {
	/**
	 * 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 TestConcurrent().start();
		}
		try {
			latch.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("use time:" + (System.currentTimeMillis() - start));
	}

	public void run() {
		System.out.println("...");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		latch.countDown();
	}
}

1. import java.util.concurrent.BrokenBarrierException;
2. import java.util.concurrent.CyclicBarrier;
3. import java.util.concurrent.TimeUnit;
4. import java.util.concurrent.TimeoutException;
5. public class TestCyclicBarrier extends Thread {
6. /**
7. * CyclicBarrier 和CountDownLatch不同，CyclicBarrier是当await 的数量达到了设置的数量后，
8. * 才继续往下执行
9. */
10. static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);
11. private int id;
12. public TestCyclicBarrier(int id) {
13. this.id = id;
14. }
15. public static void main(String[] args) {
16. long start = System.currentTimeMillis();
17. int i = 0;
18. while (i < 10) {
19. i++;
20. new TestCyclicBarrier(i).start();
21. }
22. System.out.println("use time:" + (System.currentTimeMillis() - start));
23. }
24. public void run() {
25. try {
26. System.out.println("----start:" + id);
27. cyclicBarrier.await(1000, TimeUnit.MILLISECONDS);
28. System.out.println("----start__:" + id);
29. } catch (InterruptedException e1) {
30. e1.printStackTrace();
31. } catch (BrokenBarrierException e) {
32. e.printStackTrace();
33. } catch (TimeoutException e) {
34. e.printStackTrace();
35. }
36. try {
37. Thread.sleep(100);
38. } catch (InterruptedException e) {
39. e.printStackTrace();
40. }
41. System.out.println("----end:" + id);
42. }
43. }