并发编程-并发工具类（二）

二、CountDownLatch 闭锁

闭锁在上面文章 并发编程-线程间的协作（四）中的测试类有使用到，使用他进行并发测试。

那闭锁是什么呢？为什么可以使用它进行并发测试呢？

CountDownLatch 这个类能够使一个线程等待其他线程完成各自工作后在执行。

打开CountDownLatch 这了类看到了

 /**
     * Synchronization control For CountDownLatch.
     * Uses AQS state to represent count.
     */
    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;
            }
        }
    }

可以看到CountDownLatch使用了AQS（AbstractQueuedSynchronizer ）实现了一把锁用于表示计数。当完成一个任务的时候计数器减一（countDown（）方法），

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

  public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

当计数器值到达 0 时，它表示所有的已 经完成了任务，然后在闭锁上等待 CountDownLatch.await()方法的线程就可以恢 复执行任务

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

下面上演示代码：CountDownLatch 的使用相对而言就比较简单了

import java.util.concurrent.CountDownLatch;

/**
 * CountDownLatch 代码演示
 * 
 * @author ckj
 *
 */
public class CountDownLatchTest {

	static CountDownLatch latch = new CountDownLatch(6);

	static class MyThread implements Runnable {

		public void run() {

			latch.countDown();//执行计数器扣点
			System.out.println(Thread.currentThread().getName() + "执行扣点当前点数为" + latch.getCount());
		}

	}

	public static void main(String[] args) throws InterruptedException {
		//进行6次扣点
		for (int i = 0; i < 6; i++) {
			Thread.sleep(1000);
			new Thread(new MyThread()).start();
		}
		latch.await();//线程阻塞，等待扣点结束后执行主线程
		System.out.println("主线程执行当前点数为" + latch.getCount());

	}

}