Java 并发编程 - CountDownLatch
J.U.C 之 AQS - CountDownLatch
- 1、关于 CountDownLatch
- 2、CountDownLatch 源码分析
- 2.1 源码示例
- 2.2 源码分析
- 3、实用示例
- 3.1 await() + countDown()
- 3.2 await(timeout, timeUnit) + countDown()
1、关于 CountDownLatch
countDownLatch 是一个同步辅助类，通过他可以完成类似于线程堵塞功能。这个类使一个线程等待其他线程各自执行完毕后再执行。
countDownLatch 是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。
2、CountDownLatch 源码分析
2.1 源码示例
package java.util.concurrent;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
/**
* A synchronization aid that allows one or more threads to wait until
* a set of operations being performed in other threads completes.
*
* A {@code CountDownLatch} is initialized with a given count.
* The {@link #await await} methods block until the current count reaches
* zero due to invocations of the {@link #countDown} method, after which
* all waiting threads are released and any subsequent invocations of
* {@link #await await} return immediately. This is a one-shot phenomenon
* -- the count cannot be reset. If you need a version that resets the
* count, consider using a {@link CyclicBarrier}.
*
*
A {@code CountDownLatch} is a versatile synchronization tool
* and can be used for a number of purposes. A
* {@code CountDownLatch} initialized with a count of one serves as a
* simple on/off latch, or gate: all threads invoking {@link #await await}
* wait at the gate until it is opened by a thread invoking {@link
* #countDown}. A {@code CountDownLatch} initialized to N
* can be used to make one thread wait until N threads have
* completed some action, or some action has been completed N times.
*
*
A useful property of a {@code CountDownLatch} is that it
* doesn't require that threads calling {@code countDown} wait for
* the count to reach zero before proceeding, it simply prevents any
* thread from proceeding past an {@link #await await} until all
* threads could pass.
*
*
Sample usage: Here is a pair of classes in which a group
* of worker threads use two countdown latches:
*
* - The first is a start signal that prevents any worker from proceeding
* until the driver is ready for them to proceed;
*
- The second is a completion signal that allows the driver to wait
* until all workers have completed.
*
*
* {@code
* class Driver { // ...
* void main() throws InterruptedException {
* CountDownLatch startSignal = new CountDownLatch(1);
* CountDownLatch doneSignal = new CountDownLatch(N);
*
* for (int i = 0; i < N; ++i) // create and start threads
* new Thread(new Worker(startSignal, doneSignal)).start();
*
* doSomethingElse(); // don't let run yet
* startSignal.countDown(); // let all threads proceed
* doSomethingElse();
* doneSignal.await(); // wait for all to finish
* }
* }
*
* class Worker implements Runnable {
* private final CountDownLatch startSignal;
* private final CountDownLatch doneSignal;
* Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
* this.startSignal = startSignal;
* this.doneSignal = doneSignal;
* }
* public void run() {
* try {
* startSignal.await();
* doWork();
* doneSignal.countDown();
* } catch (InterruptedException ex) {} // return;
* }
*
* void doWork() { ... }
* }}
*
* Another typical usage would be to divide a problem into N parts,
* describe each part with a Runnable that executes that portion and
* counts down on the latch, and queue all the Runnables to an
* Executor. When all sub-parts are complete, the coordinating thread
* will be able to pass through await. (When threads must repeatedly
* count down in this way, instead use a {@link CyclicBarrier}.)
*
*
{@code
* class Driver2 { // ...
* void main() throws InterruptedException {
* CountDownLatch doneSignal = new CountDownLatch(N);
* Executor e = ...
*
* for (int i = 0; i < N; ++i) // create and start threads
* e.execute(new WorkerRunnable(doneSignal, i));
*
* doneSignal.await(); // wait for all to finish
* }
* }
*
* class WorkerRunnable implements Runnable {
* private final CountDownLatch doneSignal;
* private final int i;
* WorkerRunnable(CountDownLatch doneSignal, int i) {
* this.doneSignal = doneSignal;
* this.i = i;
* }
* public void run() {
* try {
* doWork(i);
* doneSignal.countDown();
* } catch (InterruptedException ex) {} // return;
* }
*
* void doWork() { ... }
* }}
*
* Memory consistency effects: Until the count reaches
* zero, actions in a thread prior to calling
* {@code countDown()}
* happen-before
* actions following a successful return from a corresponding
* {@code await()} in another thread.
*
* @since 1.5
* @author Doug Lea
*/
public class 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;
}
}
}
private final Sync sync;
/**
* 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);
}
/**
* Causes the current thread to wait until the latch has counted down to
* zero, unless the thread is {@linkplain Thread#interrupt interrupted}.
*
* If the current count is zero then this method returns immediately.
*
*
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:
*
* - The count reaches zero due to invocations of the
* {@link #countDown} method; or
*
- Some other thread {@linkplain Thread#interrupt interrupts}
* the current thread.
*
*
* If the current thread:
*
* - has its interrupted status set on entry to this method; or
*
- is {@linkplain Thread#interrupt interrupted} while waiting,
*
* 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);
}
/**
* Causes the current thread to wait until the latch has counted down to
* zero, unless the thread is {@linkplain Thread#interrupt interrupted},
* or the specified waiting time elapses.
*
* If the current count is zero then this method returns immediately
* with the value {@code true}.
*
*
If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until one of three things happen:
*
* - The count reaches zero due to invocations of the
* {@link #countDown} method; or
*
- Some other thread {@linkplain Thread#interrupt interrupts}
* the current thread; or
*
- The specified waiting time elapses.
*
*
* If the count reaches zero then the method returns with the
* value {@code true}.
*
*
If the current thread:
*
* - has its interrupted status set on entry to this method; or
*
- is {@linkplain Thread#interrupt interrupted} while waiting,
*
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared.
*
* If the specified waiting time elapses then the value {@code false}
* is returned. If the time is less than or equal to zero, the method
* will not wait at all.
*
* @param timeout the maximum time to wait
* @param unit the time unit of the {@code timeout} argument
* @return {@code true} if the count reached zero and {@code false}
* if the waiting time elapsed before the count reached zero
* @throws InterruptedException if the current thread is interrupted
* while waiting
*/
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
/**
* Decrements the count of the latch, releasing all waiting threads if
* the count reaches zero.
*
* 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.
*
*
If the current count equals zero then nothing happens.
*/
public void countDown() {
sync.releaseShared(1);
}
/**
* Returns the current count.
*
* This method is typically used for debugging and testing purposes.
*
* @return the current count
*/
public long getCount() {
return sync.getCount();
}
/**
* Returns a string identifying this latch, as well as its state.
* The state, in brackets, includes the String {@code "Count ="}
* followed by the current count.
*
* @return a string identifying this latch, as well as its state
*/
public String toString() {
return super.toString() + "[Count = " + sync.getCount() + "]";
}
}
2.2 源码分析
1、CountDownLatch 类 只有一个构造方法，参数count为计数值
/**
* 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);
}
2、CountDownLatch 类中比较重要的3个方法
/** 调用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() { // …… };
3、实用示例
3.1 await() + countDown()
package com.lcao.aqs;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author
* @title: CountDownLatchExample
* @description: TODO
* @date 2020/4/20 9:52
*/
@Slf4j
public class CountDownLatchExample {
// 定义线程数
private static int threadCount = 300;
public static void main(String[] args) throws Exception {
// 申明一个 newCacheThreadPool 线程池
ExecutorService threadPool = Executors.newCachedThreadPool();
// 初始化 CoutDownLatch 时给定一个计数值 threadCount。
final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0 ; i < threadCount; i++) {
final int num = i;
threadPool.execute(new Runnable() {
@Override
public void run() {
try {
testMethod(num);
} catch (Exception e) {
log.info("线程调用失败!");
e.printStackTrace();
} finally {
//将 Count 值减1
countDownLatch.countDown();
}
}
});
}
// 调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
countDownLatch.await();
log.info("所有线程都执行完了，这个信息一定是最后执行的！");
threadPool.shutdown();
}
private static void testMethod(int num) throws Exception {
Thread.sleep(100);
log.info("{}-线程执行：num = {}",Thread.currentThread().getId(),num);
}
}
3.2 await(timeout, timeUnit) + countDown()
package com.lcao.aqs;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* @author
* @title: CountDownLatchExample
* @description: TODO
* @date 2020/4/20 9:52
*/
@Slf4j
public class CountDownLatchExample {
// 定义线程数
private static int threadCount = 300;
public static void main(String[] args) throws Exception {
// 申明一个 newCacheThreadPool 线程池
ExecutorService threadPool = Executors.newCachedThreadPool();
// 初始化 CoutDownLatch 时给定一个计数值 threadCount。
final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0 ; i < threadCount; i++) {
final int num = i;
threadPool.execute(new Runnable() {
@Override
public void run() {
try {
testMethod(num);
} catch (Exception e) {
log.info("线程调用失败!");
e.printStackTrace();
} finally {
//将 Count 值减1
countDownLatch.countDown();
}
}
});
}
// 等待1000 毫秒 后count值还没变为0的话就会继续执行
countDownLatch.await(1000, TimeUnit.MILLISECONDS);
log.info("这条消息不一定是最后显示！！！");
threadPool.shutdown();
}
private static void testMethod(int num) throws Exception {
Thread.sleep(1000);
log.info("{}-线程执行：num = {}",Thread.currentThread().getId(),num);
}
}
.