[置顶] JDK-CountDownLatch-实例、源码和模拟实现

Conception

A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
根据CountDownLatch的document，就是说CountDownLatch作为一个同步的助手，可以阻塞一个线程，等待另一个线程结束了再执行。

所以CountDownLatch的作用在于：通过阻塞来协调线程间的执行顺序。

CountDownLatch最重要的方法为await()和countDown()。首先，初始化指定一个count，每次countDown()都会count--，而await()就是阻塞调用它的方法，直到count==0。

所以可以把CountDownLatch看成同步的计数器，什么时候倒数到0就执行，否则阻塞。

Demo

我们首先做一个CountDownLatch的demo，看看它是怎么一个阻塞。

count初始化为2，所以count.await()会阻塞主线程，直到两个processor都countDown()，即count==0的时候才会执行，打印出"Processors has been done."

public class CountDownLatchTest {
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch count = new CountDownLatch(2);
		ExecutorService exc = Executors.newSingleThreadExecutor();

		System.out.println("Before submit the processor.");
		exc.submit(new CountProcessor(count, "P1"));
		exc.submit(new CountProcessor(count, "P2"));
		System.out.println("Has submited the processor.");

		count.await();
		System.out.println("Processors has been done.");
		exc.shutdown();
	}
}

class CountProcessor extends Thread {
	private CountDownLatch count;
	private String name;
	public CountProcessor(CountDownLatch count, String name) {
		this.count = count;
		this.name = name;
	}
	@Override
	public void run() {
		try {
			Thread.currentThread().sleep(1000);
			System.out.println(this.name + " has been done.");
			count.countDown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

修改一下上面的程序，我们可以模拟一个百米赛跑的现场：

首先运动员进场：前期数据准备和线程池的初始化。

准备工作完成后统一起跑：传入的begin.await()一直阻塞着Runner.run()，在前期准备完成后，begin.countDown()后begin.count==0，阻塞结束，Runner起跑。

比赛一直进行，直到所有选手冲过终点：end.await()会阻塞主线程，所以最后的那条print语句不会提前打印，而是等待Runner.run()结束执行end.countDown()，减少3次直到end.count==0才接触阻塞，宣布比赛结束。

这就是CountDownLatch的经典场景，统一开始，统一结束。

public class CountDownLatchTest {
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch begin = new CountDownLatch(1);
		CountDownLatch end = new CountDownLatch(3);
		ExecutorService exc = Executors.newCachedThreadPool();

		System.out.println("Runners are comming.");
		exc.submit(new CountProcessor(begin, end, "Runner_1", 1000));
		exc.submit(new CountProcessor(begin, end, "Runner_2", 2000));
exc.submit(new CountProcessor(begin, end, "Runner_3", 3000));
		System.out.println("Ready.");

		Thread.currentThread().sleep(1000);
		System.out.println("Go.");
		begin.countDown();

		end.await();
		System.out.println("All runners Finish the match.");
		exc.shutdown();
	}
}

class CountProcessor extends Thread {
	private CountDownLatch beginCount;
	private CountDownLatch endCount;
	private String name;
	private int runningTime;
	public CountProcessor(CountDownLatch beginCount, CountDownLatch endCount, String name, int runningTime) {
		this.beginCount = beginCount;
		this.endCount = endCount;
		this.name = name;
		this.runningTime = runningTime;
	}

	@Override
	public void run() {
		try {
			this.beginCount.await();
			System.out.println(this.name + " start.");
			Thread.currentThread().sleep(this.runningTime);
			System.out.println(this.name + " breast the tape.");
			this.endCount.countDown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

Source Code

我们来看JDK中CountDownLatch是怎么定义的，以及其中的主要方法。

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

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
}

public void countDown() {
        sync.releaseShared(1);
}

public long getCount() {
        return sync.getCount();
}
}

很显然，CountDownLatch的逻辑都封装在内部类Sync中，这也是通过装饰者模式来提高封装性的普遍做法。

Sync继承了AbstractQueuedSynchronizer，这里的调用关系有点麻烦，我就不一一展开了，我贴了部分关键的代码（如下）。

概括一下，CountDownLatch的count存放在以volatile声明的变量state。在await()的时候for轮询state，一直轮询以达到阻塞的效果，直到state==0。而countDown()就是通过CompareAndSet的方式来递减state。

private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
}

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
private volatile int state;
private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
}
}

Simulator

从上面可以看出来，其实CountDownLatch的实现很简单，countDown的时候原子修改，await的时候循环判断volatile来阻塞。

所以完全可以通过原子类来实现，而且还更加beautiful。以下，我用AtomicInteger来模拟CountDownLatch的实现。

测试程序还是和上面的赛跑程序一样的，只是把CountDownLatch替换成了CountDownLatchSimulator。

最后测试结果还是一样的，只是过程简单了许多，因为JDK把很多防止冲突的逻辑都封装在原子类了。其中await的时候，可以在循环中加上sleep，能减低系统轮询的消耗。

【
我只是做了一个简单的实现，至于性能和安全性方面，还希望大神们指导】

public class CountDownLatchSimulator {
	private AtomicInteger count;
	public CountDownLatchSimulator(int count) {
		this.count = new AtomicInteger(count);
	}

	public void await() throws InterruptedException {
		while (this.count.get() != 0) {
//			Thread.currentThread().sleep(100);
		}
	}

	public void countDown() {
		this.count.getAndDecrement();
	}

	public static void main(String[] args) throws InterruptedException {
		CountDownLatchSimulator begin = new CountDownLatchSimulator(1);
		CountDownLatchSimulator end = new CountDownLatchSimulator(3);
		ExecutorService exc = Executors.newCachedThreadPool();

		System.out.println("Runners are comming.");
		exc.submit(new CountProcessor2(begin, end, "Runner_1", 1000));
		exc.submit(new CountProcessor2(begin, end, "Runner_2", 2000));
		exc.submit(new CountProcessor2(begin, end, "Runner_3", 3000));
		System.out.println("Ready.");

		Thread.currentThread().sleep(2000);
		System.out.println("Go.");
		begin.countDown();

		end.await();
		System.out.println("All runners Finish the match.");
		exc.shutdown();
	}
}

class CountProcessor2 extends Thread {

	private CountDownLatchSimulator beginCount;
	private CountDownLatchSimulator endCount;
	private String name;
	private int runningTime;
	public CountProcessor2(CountDownLatchSimulator beginCount, CountDownLatchSimulator endCount, String name, int runningTime) {
		this.beginCount = beginCount;
		this.endCount = endCount;
		this.name = name;
		this.runningTime = runningTime;
	}

	@Override
	public void run() {
		try {
			this.beginCount.await();
			System.out.println(this.name + " start.");
			Thread.currentThread().sleep(this.runningTime);
			System.out.println(this.name + " breast the tape.");
			this.endCount.countDown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}