闭锁CountDownLatch与栅栏CyclicBarrier

一、闭锁与栅栏介绍(jdk1.5)

闭锁(CountDownLatch) :在并发时的同步辅助类，在一组线程正在完成某个任务之前，允许一个或多个线程一直等待。即 一组线程等待某一事件发生，事件没有发生前，所有线程将阻塞等待；而事件发生后，所有线程将开始执行；闭锁最初处于封闭状态，当事件发生后闭锁将被打开，一旦打开，闭锁将永远处于打开状态。

栅栏(CyclicBarrier)：在并发时的同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点。利用栅栏，可以使线程相互等待，直到所有线程都到达某一点，然后栅栏将打开，所有线程将通过栅栏继续执行CyclicBarrier支持一个可选的Runnable 参数，当线程通过栅栏时，runnable对象将被调用。构造函数CyclicBarrier(int parties,Runnable barrierAction)，当线程在CyclicBarrier对象上调用await()方法时，栅栏的计数器将增加1，当计数器为parties时，栅栏将打开。

区别：闭锁用于所有线程等待一个外部事件的发生；栅栏则是所有线程相互等待，直到所有线程都到达某一点时才打开栅栏，然后线程可以继续执行。

二、 闭锁与栅栏实例

1、闭锁

假定有这么个场景:有三个工人在为老板干活，这个老板有一个习惯，就是当三个工人把一天的活都干完了的时候，他就来检查所有工人所干的活。记住这个条件：三个工人先全部干完活，老板才检查。所以在这里用Java代码设计两个类，Worker代表工人，Boss代表老板，具体的代码实现如下：

package com.studyproject.lock;

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/***
 * 
 * 闭锁(一个线程去等待其它线程做完所有之后再去做其它的事情)
 * */
public class TestLatch {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newCachedThreadPool();
		CountDownLatch latch = new CountDownLatch(3);
		Work w1 = new Work(latch, "张三");
		Work w2 = new Work(latch, "李四");
		Work w3 = new Work(latch, "王二");
		Boss boss = new Boss(latch);
		executor.execute(w3);
		executor.execute(w2);
		executor.execute(w1);
		executor.execute(boss);
		executor.shutdown();
	}

}

class Work implements Runnable {
	private CountDownLatch downLatch;
	private String name;

	public Work(CountDownLatch downLatch, String name) {
		this.downLatch = downLatch;
		this.name = name;
	}

	@Override
	public void run() {

		System.out.println(this.name + "正在干活!");
		try {
			TimeUnit.SECONDS.sleep(new Random().nextInt(10));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println(this.name + "活干完了！");
		this.downLatch.countDown();
	}

}

class Boss implements Runnable {
	private CountDownLatch downLatch;

	public Boss(CountDownLatch downLatch) {
		this.downLatch = downLatch;
	}

	@Override
	public void run() {

		System.out.println("老板正在等所有的工人干完活......");
		try {
			this.downLatch.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println("工人活都干完了，老板开始检查了！");
	}
}

2、栅栏

假定场景：三个工人，他们三个合作建桥，有三个桩，每人打一个，同时打完之后才能一起搭桥（搭桥需要三人一起合作）。也就是说三个人都打完桩之后才能继续工作。实现如下：

package com.studyproject.lock;

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 
 * 栅栏<br>
 * 三个工人，他们三个合作建桥，有三个桩，每人打一个，同时打完之后才能一起搭桥（搭桥需要三人一起合作）。也就是说三个人都打完桩之后才能继续工作
 * */
public class CycTest {
	public static void main(String[] args) {
		ExecutorService executorpool = Executors.newFixedThreadPool(3);
		CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
		CycWork work1 = new CycWork(cyclicBarrier, "张三");
		CycWork work2 = new CycWork(cyclicBarrier, "李四");
		CycWork work3 = new CycWork(cyclicBarrier, "王五");
		executorpool.execute(work1);
		executorpool.execute(work2);
		executorpool.execute(work3);
		executorpool.shutdown();
	}
}

class CycWork implements Runnable {
	private CyclicBarrier cyclicBarrier;
	private String name;

	public CycWork(CyclicBarrier cyclicBarrier, String name) {
		this.name = name;
		this.cyclicBarrier = cyclicBarrier;
	}

	@Override
	public void run() {
		System.out.println(name + "正在打桩，毕竟不轻松。。。。。");
		try {
			Thread.sleep(5000);
			System.out.println(name + "不容易，终于把桩打完了。。。。");
			cyclicBarrier.await();
		} catch (Exception e) {
			e.printStackTrace();
		}

		System.out.println(name + "：其他逗b把桩都打完了，又得忙活了。。。");

	}

}

三、实现原理分析

1、闭锁原理：

CountDown类中主要有三个方法:

a、构造函数

public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
 }

b、对计数器减一

 public void countDown() {    //对计数器减一，表示有一个事件已经发生了
        sync.releaseShared(1); 
   }

c、等到计数器为0

public void await() throws InterruptedException { //等到计数器为0
        sync.acquireSharedInterruptibly(1);
}

其中count表示需要等待的线程个数，countDown是对这个值进行减减

2、栅栏原理

CyclicBarrier类中主要有以下三个方法：

a、构造函数

public CyclicBarrier(int parties) {
        this(parties, null);
 }

parties主是执行任务的线程个数，内部会赋值给count

b、等待其他任务进行，直到所有任务都结束

public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen;
        }
    }

其中doWait方法中不停对Index赋值，当index == 0 时

final Runnable command = barrierCommand; 其实是可以设置的，这个Runnable可以传进来，当我们希望所有线程都达到某一时刻之后，用什么线程执行接下来的工作，当没有传Runnable进来时，就继续执行(唤醒其他线程)，否则就runnable.run()（唤醒其他线程之前执行）