CountDownLatch、CyclicBarrier和Semaphore

1.CountDownLatch

CountDownLatch就像一个计数器，适用于执行给定数量的线程任务。

使用方法：

public CountDownLatch(int count) {  };

CountDownLatch只有这一种构造器，需要初始化要完成的任务数量。

可以使用await() 或者 await(long timeout, TimeUnit unit) 方法进行等待，当计数器减少为0时，继续执行之后的代码。每完成一个任务，都可以使用countDown()方法使数量减少1。

举例说明：

public class Test {
     public static void main(String[] args) {   
         final CountDownLatch latch = new CountDownLatch(2);
          
         new Thread(){
             public void run() {
                 try {
                     System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                    Thread.sleep(3000);
                    System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();
          
         new Thread(){
             public void run() {
                 try {
                     System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                     Thread.sleep(3000);
                     System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                     latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();
          
         try {
             System.out.println("等待2个子线程执行完毕...");
            latch.await();
            System.out.println("2个子线程已经执行完毕");
            System.out.println("继续执行主线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
     }
}

2.CyclicBarrier

CyclicBarrier和CountDownLatch很相像，区别在于CountDownLatch适用于主线程等待其它分线程跑完后，继续往下执行，而CyclicBarrier适用于各分线程彼此等待，当所有线程结束后再一起往下执行。

使用方法：

public CyclicBarrier(int parties) {
}

public CyclicBarrier(int parties, Runnable barrierAction) {
}

CyclicBarrier有两种构造器，其中一种与CountDownLatch相同，另外一种参数barrierAction定义了当这些线程都达到barrier状态时会执行的内容。

可以使用 await() 方法让该线程等待，等所有线程到达等待状态时，再同时执行之后的代码。还可以使用 await(long timeout, TimeUnit unit) 方法，在超时后让已经到达等待的线程执行之后的代码。

举例说明：

测试类

public class TestFinal {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3);
        barrier.reset();
        for (int i = 0; i < 5; i++) {
            new MyThread(barrier).start();
        }
        try {
            Thread.sleep(6000);
            System.out.println("-----------------------");
            System.out.println(barrier.getNumberWaiting() + "个线程正在等待");
            System.out.println("-----------------------");
            for (int i = 0; i < 2; i++) {
                new MyThread(barrier).start();
            }
            Thread.sleep(6000);
            System.out.println("-----------------------");
            System.out.println(barrier.getNumberWaiting() + "个线程正在等待");
            System.out.println("-----------------------");
            for (int i = 0; i < 2; i++) {
                new MyThread(barrier).start();
            }
            Thread.sleep(6000);
            System.out.println("-----------------------");
            System.out.println(barrier.getNumberWaiting() + "个线程正在等待");
            System.out.println("-----------------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

线程类

public class MyThread extends Thread{
    private CyclicBarrier cyclicBarrier;
    public MyThread(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run(){
        try {
            sleep(2000);
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            cyclicBarrier.await();
            sleep(2000);
            System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

结果

线程Thread-0正在写入数据...
线程Thread-4正在写入数据...
线程Thread-3正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2正在写入数据...
线程Thread-3写入数据完毕
线程Thread-4写入数据完毕
线程Thread-0写入数据完毕
-----------------------
2个线程正在等待
-----------------------
线程Thread-6正在写入数据...
线程Thread-5正在写入数据...
线程Thread-1写入数据完毕
线程Thread-2写入数据完毕
线程Thread-6写入数据完毕
-----------------------
1个线程正在等待
-----------------------
线程Thread-8正在写入数据...
线程Thread-7正在写入数据...
线程Thread-5写入数据完毕
线程Thread-8写入数据完毕
线程Thread-7写入数据完毕
-----------------------
0个线程正在等待
-----------------------

可以看出CyclicBarrier是可以重复使用的，适合反复的批量执行任务。

3.Semaphore

Semaphore可以控制同时访问的线程个数，适用于需要控制同时运行线程数量时使用。

使用方法：

public Semaphore(int permits) {          //参数permits表示许可数目，即同时可以允许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

通过 acquire() 或 acquire(int permits) 获取一个或 permits个许可，如果没有就等待，而 release() 或 release(int permits) 释放一个或permits个许可。

以上4种方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

举例说明：

public class Test {
    public static void main(String[] args) {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for(int i=0;i<N;i++)
            new Worker(i,semaphore).start();
    }
     
    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }
         
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();           
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}