并发工具类：CountDownLatch、CyclicBarrier、Semaphore

在多线程的场景下，有些并发流程需要人为来控制，在JDK的并发包里提供了几个并发工具类：CountDownLatch、CyclicBarrier、Semaphore。

一、CountDownLatch

 1 import java.util.concurrent.CountDownLatch;
 2
 3
 4 public class CountDownLatchTest
 5 {　　　　//设置N为2
 6     static CountDownLatch c = new CountDownLatch(2);
 7     public static void main(String[] args) throws Exception
 8     {
 9         Thread t1 = new Thread(new Runnable()
10         {
11
12             @Override
13             public void run()
14             {
15                 System.out.println("1");　　　　　　　　　　　//将N减1
16                 c.countDown();
17             }
18         });
19
20         Thread t2 = new Thread(new Runnable()
21         {
22
23             @Override
24             public void run()
25             {
26                 System.out.println("2");
27                 c.countDown();
28             }
29         });
30         t1.start();
31         t2.start();　　　　　　//让当前线程等待，直到计数N为0
32         c.await();
33         System.out.println("3");
34     }
35 }

执行结果：

1
2
3

这里会存在两种结果：123或者213，但是绝对不会出现3打印在1、2前面的。

new CountDownLatch(2);

这个CountDownLatch的构造函数接收一个int类型的参数作为计数器，N表示阻塞的线程必须等待N次countDown才能执行。

每次调用CountDownLatch的countDown方法时，N就会减1，而这个方法可以使用在任何地方，这里的N点可以是N个线程，也可以是一个线程中N个步骤。

而CountDownLatch的await方法则会阻塞当前线程，直到N为0的时候才能执行。

我们将上面的程序改造下，让线程中有两个打印动作，并且第二个动作前线程休眠一段时间：

 1 import java.util.concurrent.CountDownLatch;
 2
 3
 4 public class CountDownLatchTest
 5 {
 6     static CountDownLatch c = new CountDownLatch(2);
 7     public static void main(String[] args) throws Exception
 8     {
 9         Thread t1 = new Thread(new Runnable()
10         {
11
12             @Override
13             public void run()
14             {
15                 System.out.println("1");
16                 c.countDown();
17                 try
18                 {
19                     Thread.sleep(500);
20                     System.out.println("2");
21                 }
22                 catch (InterruptedException e)
23                 {
24                     e.printStackTrace();
25                 }
26             }
27         });
28
29         Thread t2 = new Thread(new Runnable()
30         {
31
32             @Override
33             public void run()
34             {
35                 System.out.println("3");
36                 c.countDown();
37             }
38         });
39         t1.start();
40         t2.start();
41         c.await();
42         System.out.println("4");
43     }
44 }

执行结果：

这个结果是由于在打印完1、3之后，N已经变化为0，主线程执行打印4，由于线程1休眠，所以2最后才打印。

在上面的程序中，如果将N设置为3，则主线程中的打印4永远不会执行，因为没有N永远只会到1而不会减少到0.

在这里我们想起了线程的join方法，这个方法也是可以阻塞当前线程，等待某线程执行完成。通过对比，我们可以发现使用CountDownLatch这个工具类更灵活，因为countDown可以用在任何线程的任何地方。

CountDownLatch适合一个大任务拆分成多个小任务，然后在所有子任务完成后，通知其他的后续操作开始执行。

二、同步屏障CyclicBarrier

CyclicBarrier默认的构造方法CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达屏障，然后当前线程被阻塞，直到被拦截的线程全部都到达了屏障，然后前面被阻塞的线程才能开始执行，否则会被一直阻塞。

 1 public class CyclicBarrierTest
 2 {
 3     static CyclicBarrier c = new CyclicBarrier(3);
 4
 5     public static void main(String[] args)
 6         throws Throwable, BrokenBarrierException
 7     {
 8         Thread t1 = new Thread(new Runnable()
 9         {
10             @Override
11             public void run()
12             {
13                 try
14                 {
15                     c.await();
16                 }
17                 catch (InterruptedException e)
18                 {
19                     e.printStackTrace();
20                 }
21                 catch (BrokenBarrierException e)
22                 {
23                     e.printStackTrace();
24                 }
25                 System.out.println("1");
26
27             }
28         });
29         Thread t2 = new Thread(new Runnable()
30         {
31             @Override
32             public void run()
33             {
34                 try
35                 {
36                     c.await();
37                 }
38                 catch (InterruptedException e)
39                 {
40                     e.printStackTrace();
41                 }
42                 catch (BrokenBarrierException e)
43                 {
44                     e.printStackTrace();
45                 }
46                 System.out.println("2");
47             }
48         });
49
50         t1.start();
51         t2.start();
52         c.await();
53         System.out.println("3");
54     }
55 }

执行结果：

3
1
2

上述中被屏障拦截的线程有3个，其中线程1和线程2执行的时候先到达屏障，然后被阻塞，主线程执行第52行到达屏障，至此阻塞的三个线程全部到达屏障，然后阻塞的线程可以去竞争CPU开始执行。

如果将拦截的线程数修改为4：

static CyclicBarrier c = new CyclicBarrier(4);

这样的话被拦截的线程数有4个，但是只有三个线程调用await方法告诉CyclicBarrier，我到达了屏障。所以这三个线程都会被阻塞。

另外还有一点就是CyclicBarrier的计数器可以重置，例如设置的是拦截线程数量为2，但是有3个线程调用了await()方法表示到达了屏障，这个时候会出现最先达到屏障的两个线程顺利执行完毕，而最后到达的第三个线程则一直被阻塞，因为它等不到另外一个线程到达屏障了。

而如果拦截线程的数量依旧为2，但是有4个线程调用了await()方法，那么这4个线程是分两批执行的，前两个线程满足拦截的线程数，到达屏障后放行；然后CyclicBarrier的计数器重置，后面两个线程到达屏障后放行。

 1 import java.util.concurrent.BrokenBarrierException;
 2 import java.util.concurrent.CyclicBarrier;
 3
 4 import sun.java2d.SunGraphicsEnvironment.T1Filter;
 5
 6
 7 public class CyclicBarrierTest
 8 {
 9     static CyclicBarrier c = new CyclicBarrier(2);
10
11     public static void main(String[] args) throws Throwable, BrokenBarrierException
12     {
13         Thread t1 = new Thread(new Runnable()
14         {
15             @Override
16             public void run()
17             {
18                 try
19                 {
20                     c.await();
21                 }
22                 catch (InterruptedException e)
23                 {
24                     e.printStackTrace();
25                 }
26                 catch (BrokenBarrierException e)
27                 {
28                     e.printStackTrace();
29                 }
30                 System.out.println("1");
31
32             }
33         });
34         Thread t2 = new Thread(new Runnable()
35         {
36             @Override
37             public void run()
38             {
39                 try
40                 {
41                     c.await();
42                 }
43                 catch (InterruptedException e)
44                 {
45                     e.printStackTrace();
46                 }
47                 catch (BrokenBarrierException e)
48                 {
49                     e.printStackTrace();
50                 }
51                 System.out.println("2");
52             }
53         });
54
55         Thread t3 = new Thread(new Runnable()
56         {
57             @Override
58             public void run()
59             {
60                 try
61                 {
62                     c.await();
63                 }
64                 catch (InterruptedException e)
65                 {
66                     e.printStackTrace();
67                 }
68                 catch (BrokenBarrierException e)
69                 {
70                     e.printStackTrace();
71                 }
72                 System.out.println("3");
73
74             }
75         });
76         t1.start();
77         t2.start();
78         t3.start();
79         c.await();
80         System.out.println("4");
81     }
82 }

CyclicBarrier可以用于多线程计算数据，最后合并结果的场景；由于CyclicBarrier的计数器可以重置，所以可以使用它处理更为复杂的业务场景，而CountDownLatch计数器只能使用一次。

三、信号量Semaphore

无论是内部锁synchronized还是重入锁ReentrantLock，一次都只允许一个线程访问某一个资源，而信号量却可以指定多个线程同时访问某一资源；主要用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。

 1 public class SemaphoreTest implements Runnable
 2 {
 3     final Semaphore s = new Semaphore(5);
 4     @Override
 5     public void run()
 6     {
 7         try
 8         {
 9             s.acquire();
10             Thread.sleep(1000);
11             System.out.println(Thread.currentThread().getName() + " is done");
12             s.release();
13         }
14         catch (InterruptedException e)
15         {
16             e.printStackTrace();
17         }
18     }
19 }

public class MainTest
{public static void main(String[] args){SemaphoreTest s = new SemaphoreTest();//创建一个可重用固定线程数的线程池，线程数量为20ExecutorService threadPool= Executors.newFixedThreadPool(20);for(int i=0;i<20;i++){threadPool.submit(s);}threadPool.shutdown();}
}

执行的结果是每五个线程为一组打印消息。

线程池里面有20个可重复使用的线程数量，但是信号量只有5个，也就是每次只能并发5个线程执行，其他线程阻塞。

信号量为5，可以认为线程池里有5把锁，每个线程调用acquire和release分别表示获取锁和释放锁，这样，通过信号量就可以调度多个线程的执行。

转载于:https://www.cnblogs.com/dongguacai/p/6023028.html