java并发工具类

java.util.concurrent包下的工具类CountDownLatch、CyclicBarrier、Semaphore
转载地址：

java并发工具类

countDownLatch

countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。
是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完了，然后在闭锁上等待的线程就可以恢复工作了。

构造器

//参数count为计数值
public CountDownLatch(int count) {  };  

重要方法

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

示例

public class Parallellimit {

	public static void main(String[] args) {
		ExecutorService pool = Executors.newCachedThreadPool();
		CountDownLatch cdl = new CountDownLatch(5);
		for (int i = 0; i < 5; i++) {
			CountRunnable runnable = new CountRunnable(cdl);
			pool.execute(runnable);
		}
	}

	static class CountRunnable implements Runnable {
		private CountDownLatch countDownLatch;

		public CountRunnable(CountDownLatch countDownLatch) {
			this.countDownLatch = countDownLatch;
		}

		@Override
		public void run() {
			try {
				synchronized (countDownLatch) {
					/*** 每次减少一个容量*/
					countDownLatch.countDown();
					System.out.println("thread counts = " + (countDownLatch.getCount()));
				}
				countDownLatch.await();
				System.out.println("concurrency counts = " + (5 - countDownLatch.getCount()));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

结果

thread counts = 4
thread counts = 3
thread counts = 2
thread counts = 1
thread counts = 0
concurrency counts = 5
concurrency counts = 5
concurrency counts = 5
concurrency counts = 5
concurrency counts = 5

CyclicBarrier

从字面上的意思可以知道，这个类的中文意思是“循环栅栏”。大概的意思就是一个可循环利用的屏障。

它的作用就是会让所有线程都等待完成后才会继续下一步行动。

举个例子，就像生活中我们会约朋友们到某个餐厅一起吃饭，有些朋友可能会早到，有些朋友可能会晚到，但是这个餐厅规定必须等到所有人到齐之后才会让我们进去。这里的朋友们就是各个线程，餐厅就是 CyclicBarrier。

构造器

//parties是参与线程的个数
public CyclicBarrier(int parties)
//barrierAction是最后一个到达线程要做的任务
public CyclicBarrier(int parties, Runnable barrierAction)

重要方法

//线程调用 await() 表示自己已经到达栅栏
public int await() throws InterruptedException, BrokenBarrierException
//BrokenBarrierException 表示栅栏已经被破坏，破坏的原因可能是其中一个线程 await() 时被中断或者超时
public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException

示例

public class Parallellimit {

	static class TaskThread extends Thread {
		CyclicBarrier barrier;

		public TaskThread(CyclicBarrier barrier) {
			this.barrier = barrier;
		}

		@Override
		public void run() {
			try {
				Thread.sleep(1000);
				System.out.println(getName() + " 到达栅栏 A");
				barrier.await();
				System.out.println(getName() + " 冲破栅栏 A");

				Thread.sleep(2000);
				System.out.println(getName() + " 到达栅栏 B");
				barrier.await();
				System.out.println(getName() + " 冲破栅栏 B");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		int threadNum = 3;
		CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {

			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + " 完成最后任务");
			}
		});

		for(int i = 0; i < threadNum; i++) {
			new TaskThread(barrier).start();
		}
	}
}

结果

Thread-0 到达栅栏 A
Thread-2 到达栅栏 A
Thread-1 到达栅栏 A
Thread-1 完成最后任务
Thread-1 冲破栅栏 A
Thread-2 冲破栅栏 A
Thread-0 冲破栅栏 A
Thread-0 到达栅栏 B
Thread-2 到达栅栏 B
Thread-1 到达栅栏 B
Thread-1 完成最后任务
Thread-1 冲破栅栏 B
Thread-0 冲破栅栏 B
Thread-2 冲破栅栏 B

CyclicBarrier 与 CountDownLatch 区别

• CountDownLatch 是一次性的，CyclicBarrier 是可循环利用的
• CountDownLatch 参与的线程的职责是不一样的，有的在倒计时，有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。

Semaphore

Semaphore 字面意思是信号量的意思，它的作用是控制访问特定资源的线程数量。
Semaphore 是一个计数信号量，必须由获取它的线程释放。

构造器

//permits 表示许可线程的数量
public Semaphore(int permits)
//fair 表示公平性，如果这个设为 true 的话，下次执行的线程会是等待最久的线程
public Semaphore(int permits, boolean fair)

重要方法

//acquire() 表示阻塞并获取许可
public void acquire() throws InterruptedException
//release() 表示释放许可
public void release()

示例

 public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        
        //信号量，只允许 3个线程同时访问
        Semaphore semaphore = new Semaphore(3);

        for (int i=0;i<10;i++){
            final long num = i;
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        //获取许可
                        semaphore.acquire();
                        //执行
                        System.out.println("Accessing: " + num);
                        Thread.sleep(new Random().nextInt(5000)); // 模拟随机执行时长
                        //释放
                        semaphore.release();
                        System.out.println("Release..." + num);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        executorService.shutdown();
    }

结果

Accessing: 0
Accessing: 1
Accessing: 2
Release...0
Accessing: 3
Accessing: 4
Release...1
Release...4
Accessing: 6
Release...3
Accessing: 7
Release...2
Accessing: 5
Accessing: 8
Release...7
Release...8
Accessing: 9
Release...9
Release...6
Release...5

Exchanger

可以看成是一个双向栅栏
Thread1线程到达栅栏后，会首先观察有没其它线程已经到达栅栏，如果没有就会等待，如果已经有其它线程（Thread2）已经到达了，就会以成对的方式交换各自携带的信息，因此Exchanger非常适合用于两个线程之间的数据交换。

Phaser

JDK1.7开始引入的一个同步工具类，适用于一些需要分阶段的任务的处理。它的功能与 CyclicBarrier和CountDownLatch有些类似，类似于一个多阶段的栅栏，并且功能更强大
多阶段栅栏，可以在初始时设定参与线程数，也可以中途注册/注销参与者，当到达的参与者数量满足栅栏设定的数量后，会进行阶段升级（advance）