CountDownLatch

CountDownLatch是一种灵活的闭锁实现。它可以使一个或多个线程等待一组事件的发生。

闭锁状态包括一个计数器，该计数器被初始化为一个正数，表示需要等待的事件的数量。countDown()方法递减计数器，表示有一个事件已经发生，而await方法等待计数器达到零，表示所有需要等待的事件都已经发生。如果计数器的值非零，那么await会一直阻塞直到计数器为零，或者等待中的线程中断，或者等待超时。

package com.citi.test.mutiplethread.demo0503;

import java.util.Date;
import java.util.concurrent.CountDownLatch;

public class TestHarness {
    public static void main(String[] args) {
        int counts=5;
        final CountDownLatch startGate=new CountDownLatch(1);
        final CountDownLatch endGate=new CountDownLatch(counts);
        for(int i=0;i<counts;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+" is starting");
                    try {
                        Thread.sleep(1000);
                        startGate.await();
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    endGate.countDown();
                }
            }).start();
        }
        long start=System.nanoTime();
        System.out.println(Thread.currentThread().getName()+" is running:"+new Date());
        startGate.countDown();
        System.out.println(Thread.currentThread().getName()+new Date());
        try {
            endGate.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        long end=System.nanoTime();
        System.out.println(end-start);
    }
}

原理：

内部是用AQS实现。其中的count就是AQS中的state，

countDownLatch 主要有几个重要方法。await(), await(long time, TimeUnit unit). countDown()

/**
 * Constructs a {@code CountDownLatch} initialized with the given count.
 *
 * @param count the number of times {@link #countDown} must be invoked
 *        before threads can pass through {@link #await}
 * @throws IllegalArgumentException if {@code count} is negative
 */
public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}
/**
 * Synchronization control For CountDownLatch.
 * Uses AQS state to represent count.
 这里可以看到是用AQS 中的state来表示这个count
 */
private static final class Sync extends AbstractQueuedSynchronizer {}

/**
 * Causes the current thread to wait until the latch has counted down to
 * zero, unless the thread is {@
 使当前线程等待直到闭锁倒数至零，除非线程被中断
 * <p>If the current count is zero then this method returns immediately.
 *如果当前计数是零，则这个方法直接返回。
 * <p>If the current count is greater than zero then the current
 * thread becomes disabled for thread scheduling purposes and lies
 * dormant until one of two things happen:
 如果当前计数大于0，则当前线程为了线程调度目的变得不可用，并处于休眠状态。
 * <ul>
 * <li>The count reaches zero due to invocations of the
 * {@link #countDown} method; or
 * <li>Some other thread {@linkplain Thread#interrupt interrupts}
 * the current thread.
 * </ul>
 *如果因为调用coutDown方法使计数变为0，或者其他线程中断当前线程。
 * <p>If the current thread:
 * <ul>
 * <li>has its interrupted status set on entry to this method; or
 * <li>is {@linkplain Thread#interrupt interrupted} while waiting,
 * </ul>
 * then {@link InterruptedException} is thrown and the current thread's
 * interrupted status is cleared.
 *如果当前线程在进入此方法时设置了中断状态，或者当等待的时候被中断，则抛出中断异常并且清空当前线程的中断状态。
 * @throws InterruptedException if the current thread is interrupted
 *         while waiting
 */
public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

AbstractQueuedSynchronizer.class
/**
 * Acquires in shared mode, aborting if interrupted.  Implemented
 * by first checking interrupt status, then invoking at least once
 * {@link #tryAcquireShared}, returning on success.  Otherwise the
 * thread is queued, possibly repeatedly blocking and unblocking,
 * invoking {@link #tryAcquireShared} until success or the thread
 * is interrupted.
 * @param arg the acquire argument
 * This value is conveyed to {@link #tryAcquireShared} but is
 * otherwise uninterpreted and can represent anything
 * you like.
 * @throws InterruptedException if the current thread is interrupted
 
 以共享模式获取，如果中断则中止。首先检查中断状态，然后至少调用一次{@link tryacquireshared}，成功返回。否则线程排队，可能重复阻塞和解除阻塞，调用{@link tryacquireshared}直到成功或线程被打断了。
 */
public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}

/**
 * Acquires in shared interruptible mode.
 * @param arg the acquire argument
 */
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);
    }
}

/**
 * Decrements the count of the latch, releasing all waiting threads if
 * the count reaches zero.
 *
 * <p>If the current count is greater than zero then it is decremented.
 * If the new count is zero then all waiting threads are re-enabled for
 * thread scheduling purposes.
 *
 * <p>If the current count equals zero then nothing happens.
 
 减少闭锁的计数，如果计数到达0，释放所有等待的线程。
 如果当前计数大于0，则将其递减。
 如果新的计数是0，则所有等待的线程为了线程调度的目的被重新启用
 如果当前计数等于0，则什么也不发生。
 */
public void countDown() {
    sync.releaseShared(1);
}

/**
 * Releases in shared mode.  Implemented by unblocking one or more
 * threads if {@link #tryReleaseShared} returns true.
 *
 * @param arg the release argument.  This value is conveyed to
 *        {@link #tryReleaseShared} but is otherwise uninterpreted
 *        and can represent anything you like.
 * @return the value returned from {@link #tryReleaseShared}
 */
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

/**
 * Release action for shared mode -- signal successor and ensure
 * propagation. (Note: For exclusive mode, release just amounts
 * to calling unparkSuccessor of head if it needs signal.)
 */
private void doReleaseShared() {
    /*
     * Ensure that a release propagates, even if there are other
     * in-progress acquires/releases.  This proceeds in the usual
     * way of trying to unparkSuccessor of head if it needs
     * signal. But if it does not, status is set to PROPAGATE to
     * ensure that upon release, propagation continues.
     * Additionally, we must loop in case a new node is added
     * while we are doing this. Also, unlike other uses of
     * unparkSuccessor, we need to know if CAS to reset status
     * fails, if so rechecking.
     */
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

/**
 * Implements timed condition wait.
 * <ol>
 * <li> If current thread is interrupted, throw InterruptedException.
 * <li> Save lock state returned by {@link #getState}.
 * <li> Invoke {@link #release} with
 *      saved state as argument, throwing
 *      IllegalMonitorStateException if it fails.
 * <li> Block until signalled, interrupted, or timed out.
 * <li> Reacquire by invoking specialized version of
 *      {@link #acquire} with saved state as argument.
 * <li> If interrupted while blocked in step 4, throw InterruptedException.
 * <li> If timed out while blocked in step 4, return false, else true.
 * </ol>
 */
public final boolean await(long time, TimeUnit unit)
        throws InterruptedException {
    if (unit == null)
        throw new NullPointerException();
    long nanosTimeout = unit.toNanos(time);
    if (Thread.interrupted())
        throw new InterruptedException();
    Node node = addConditionWaiter();
    int savedState = fullyRelease(node);
    long lastTime = System.nanoTime();
    boolean timedout = false;
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        if (nanosTimeout <= 0L) {
            timedout = transferAfterCancelledWait(node);
            break;
        }
        if (nanosTimeout >= spinForTimeoutThreshold)
            LockSupport.parkNanos(this, nanosTimeout);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
        long now = System.nanoTime();
        nanosTimeout -= now - lastTime;
        lastTime = now;
    }
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null)
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
    return !timedout;
}

 用两把锁实现一个线程等待一组线程执行完毕。可以计算这组线程的执行时间。

package com.citi.test.mutiplethread.demo5;

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {
    public static void main(String[] args) throws Exception {
        final CountDownLatch gate=new CountDownLatch(1);
        final CountDownLatch gate1=new CountDownLatch(5);
        for(int i=0;i<5;i++){
            final int index=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        gate.await();
                        System.out.println(Thread.currentThread().getName()+"线程创建");
                        Thread.sleep(index*1000);
                        System.out.println(Thread.currentThread().getName()+"开始运行");
                        gate1.countDown();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                }
            }).start();
        }
        System.out.println("主线程执行");
        long startTime=System.currentTimeMillis();
        gate.countDown();
        try {
            System.out.println("主线程等待线程运行");
            gate1.await();
            System.out.println("运行完毕,耗时："+(System.currentTimeMillis()-startTime));
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

一组线程等待另一组线程执行完毕，再执行。

package com.citi.test.mutiplethread.demo5;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

public class TestCountDownLatch3 {
    public static void main(String[] args) throws Exception {
        final AtomicInteger integer=new AtomicInteger();
        final CountDownLatch memberGate=new CountDownLatch(10);
        //需要先运行的线程。
        for(int i=0;i<10;i++){
            final int index=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000*index);
                        System.out.println(Thread.currentThread().getName()+" 运行完");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    for(int j=0;j<5;j++){
                        integer.incrementAndGet();
                    }
                    memberGate.countDown();
                }
            }).start();
        }
        for(int i=0;i<10;i++){
            final int index=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName()+"开始运行");
                        //需要等待上面的线程运行完毕再运行 这样就实现了一组线程等待另一组线程的场景
                        memberGate.await();
                        Thread.sleep(index*1000);
                        System.out.println(Thread.currentThread().getName()+" 运行");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

用一个CountDownLatch来实现主线程等待一组线程执行完毕。

package com.citi.test.mutiplethread.demo5;

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch4 {
    public static void main(String[] args) throws Exception {
        final CountDownLatch gate=new CountDownLatch(5);
        for(int i=0;i<5;i++){
            final int index=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName()+"开始运行");
                        Thread.sleep(index*1000);
                        gate.countDown();
                        System.out.println(Thread.currentThread().getName()+"运行完毕");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                }
            }).start();
        }
        gate.await();
        System.out.println("主线程执行");
        Thread.sleep(2000);
        System.out.println("运行完毕");
    }
}

其实，归根结底，都是通过new CountDownLatch(count)来让等待的线程等待，让需要先执行的线程在执行完毕之后调用latch.countDown()方法。