CountDownLanth(计数器) + CyclicBarrier(回环栅栏) + Semaphore（信号量）

CountDownLatch用法

CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。(运行主线程开启子线程的时候，子线程还没有结束的时候，主线程可以一直等待，直到初始化的现成的计数器count为0,主线程就可以不用等待继续执行了）

public CountDownLatch(int count) { };//构造方法，参数count为计数值
public void await() throws InterruptedException { };//调用此方法线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };//将count值减1

package JUC;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

/**
 * @author Heian
 * @time 19/04/01 23:28
 */
public class CountDownLanthDemo {
    static class Test implements Runnable{
        private CountDownLatch countDownLatch;
        public Test(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }
        //子线程的工作
        @Override
        public void run() {
            try {
                System.out.println("子线程开始工作，子线程为："+ Thread.currentThread ().getName ());
                TimeUnit.SECONDS.sleep (3);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }finally {
                System.out.println ("countDownLatch大小" + countDownLatch.getCount ());//这里会出现数据不一致情况，并行访问同一个资源导致
                countDownLatch.countDown ();//执行完线程数量-1
            }
        }
    }
    private static void doLastWork(){
        System.out.println ("你做完了工作，该轮到我了");
    }

    public static void main(String[] args) throws InterruptedException{
        CountDownLatch countDownLatch = new CountDownLatch (5);//定义5个子线程
        IntStream.range (0,5).forEach (value -> {
            new Thread (new Test(countDownLatch)).start ();
        });
        countDownLatch.await ();//阻塞main线程，需要等到自定义线程执行完成后方能执行
        doLastWork();
    }
}

CyclicBarrier用法

回环栅栏：让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。叫做栅栏，大概是描述所有线程被栅栏挡住了，当都达到时，一起跳过栅栏执行，也算形象。我们可以把这个状态就叫做barrier。

public CyclicBarrier(int parties)；//参数parties指让多少个线程或者任务等待至barrier状态
public CyclicBarrier(int parties, Runnable barrierAction);//参数barrierAction为当这些线程都达到barrier状态时会执行的内容。
public int await() throws InterruptedException, BrokenBarrierException { };//用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };//这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。

package JUC;

import java.util.concurrent.CyclicBarrier;
import java.util.stream.IntStream;

/**
 * @author Heian
 * @time 19/04/03 16:32
 */

public class CyclicBarrierDemo {

    static class runtask implements Runnable{
        private CyclicBarrier cyclicBarrier;
        public runtask(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
        @Override
        public void run() {
            try {
                System.out.println (Thread.currentThread ().getName () +  "准备睡眠");
                cyclicBarrier.await ();
                Thread.sleep (5000);
                System.out.println (Thread.currentThread ().getName () + "开始跳出栅栏");
            } catch (Exception e) {
                e.printStackTrace ();
            }
        }
    }

    public static void main(String[] args) throws Exception{
        //这里可以模拟junit并发测试  一次性发1000个请求，只有当请求数量达到了，才跳出栅栏出发
        CyclicBarrier cyclicBarrier = new CyclicBarrier (3);
        IntStream.range (0,3).forEach (value -> {//当线程不足时，不会触发跳出栅栏动作
            new Thread (new runtask(cyclicBarrier)).start ();
        });

    }


}

Semaphore用法

Semaphore字面意思为信号量，Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

构造方法

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

下面四个方法常用都会被阻塞

public void acquire() throws InterruptedException { } //获取一个许可若无许可能够获得，则会一直等待，直到获得许可
public void acquire(int permits) throws InterruptedException { } //获取permits个许可
public void release() { } //释放一个许可注意，在释放许可之前，必须先获获得许可。
public void release(int permits) { } //释放permits个许可

如果想立即得到执行结果，可以使用下面几个方法

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
备注：另外还可以通过availablePermits()方法得到可用的许可数目。

假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现：

package JUC;

import java.util.concurrent.Semaphore;
import java.util.stream.IntStream;

/**
 * @author Heian
 * @time 19/04/03 21:36
/
public class SemaphoreDemo {

    static class worker implements Runnable{
        private int workerNo;
        private Semaphore semaphore;
        public worker(int workerNo, Semaphore semaphore) {
            this.workerNo = workerNo;
            this.semaphore = semaphore;
        }
        @Override
        public void run() {
            try {
                semaphore.acquire ();//没有的话就会处于阻塞
                System.out.println (this.workerNo +  "员工号获得机器上生产的许可");
                Thread.sleep (5000);
                semaphore.release ();
                System.out.println (this.workerNo + "员工号释放机器");
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
        }
    }

    public static void main(String[] args) {
        int permits = 5;//许可数  机器数目
        Semaphore semaphore = new Semaphore (permits);
        int workefs = 8;
        IntStream.range (0,workefs).forEach (value -> {
            new Thread (new worker(value,semaphore)).start ();
        });
    }
}

0员工号释放机器
1员工号释放机器
2员工号释放机器
7员工号获得机器上生产的许可
6员工号获得机器上生产的许可
3员工号释放机器
5员工号获得机器上生产的许可
4员工号释放机器
5员工号释放机器
7员工号释放机器
6员工号释放机器

三个辅助类的总结：

（1）CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

（2）Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限，上面例子就是对锁的数量进行了控制。

参考自：http://www.importnew.com/21889.html