1. CountDownLatch工具类介绍
CountDownLatch是一个同步工具类,它允许一个或多个线程处于等待状态直到在其它线程中运行的一组操作完成为止。CountDownLatch用一个给定的计数来实现初始化。Await方法会一直处于阻塞状态,直到countDown方法调用而使当前计数达到零。当计数为零之后,所有处于等待的线程将被释放,await的任何后续调用将立即返回。这种现象只出现一次,计数是不能被重置的。如果你需要一个可以重置计数的版本,需要考虑使用CyclicBarrie.
上面的介绍来自于CountDownLatch类的注释。
- /**
- * A synchronization aid that allows one or more threads to wait until
- * a set of operations being performed in other threads completes.
- *
- * <p>A {@code CountDownLatch} is initialized with a given [i]count[/i].
- * 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}.
- *
- */
CountDownLatch中定义了一个内部类Sync,该类继承AbstractQueuedSynchronizer。从代码中可以看出,CountDownLatch的await,countDown以及getCount方法都调用了Sync的方法。CountDownLatch工具类相关的类图以及详细代码如下:
- /*
- * @(#)CountDownLatch.java 1.5 04/02/09
- *
- * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
- * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
- */
- package java.util.concurrent;
- import java.util.concurrent.locks.*;
- import java.util.concurrent.atomic.*;
- /**
- * A synchronization aid that allows one or more threads to wait until
- * a set of operations being performed in other threads completes.
- *
- * <p>A <tt>CountDownLatch</tt> is initialized with a given
- * [i]count[/i]. The {@link #await await} methods block until the current
- * {@link #getCount 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}.
- *
- * <p>A <tt>CountDownLatch</tt> is a versatile synchronization tool
- * and can be used for a number of purposes. A
- * <tt>CountDownLatch</tt> 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 <tt>CountDownLatch</tt> initialized to [i]N[/i]
- * can be used to make one thread wait until [i]N[/i] threads have
- * completed some action, or some action has been completed N times.
- * <p>A useful property of a <tt>CountDownLatch</tt> is that it
- * doesn't require that threads calling <tt>countDown</tt> 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.
- *
- * <p><b>Sample usage:</b> Here is a pair of classes in which a group
- * of worker threads use two countdown latches:
- * [list]
- * <li>The first is a start signal that prevents any worker from proceeding
- * until the driver is ready for them to proceed;
- * <li>The second is a completion signal that allows the driver to wait
- * until all workers have completed.
- * [/list]
- *
- * <pre>
- * 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() { ... }
- * }
- *
- * </pre>
- *
- * <p>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}.)
- *
- * <pre>
- * 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() { ... }
- * }
- *
- * </pre>
- *
- * @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 {
- Sync(int count) {
- setState(count);
- }
- int getCount() {
- return getState();
- }
- public int tryAcquireShared(int acquires) {
- return getState() == 0? 1 : -1;
- }
- public 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 <tt>CountDownLatch</tt> 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 <tt>count</tt> is less than zero.
- */
- 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 {@link Thread#interrupt interrupted}.
- *
- * <p>If the current {@link #getCount count} is zero then this method
- * returns immediately.
- * <p>If the current {@link #getCount count} is greater than zero then
- * the current thread becomes disabled for thread scheduling
- * purposes and lies dormant until one of two things happen:
- * [list]
- * <li>The count reaches zero due to invocations of the
- * {@link #countDown} method; or
- * <li>Some other thread {@link Thread#interrupt interrupts} the current
- * thread.
- * [/list]
- * <p>If the current thread:
- * [list]
- * <li>has its interrupted status set on entry to this method; or
- * <li>is {@link Thread#interrupt interrupted} while waiting,
- * [/list]
- * 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 {@link Thread#interrupt interrupted},
- * or the specified waiting time elapses.
- *
- * <p>If the current {@link #getCount count} is zero then this method
- * returns immediately with the value <tt>true</tt>.
- *
- * <p>If the current {@link #getCount count} is greater than zero then
- * the current thread becomes disabled for thread scheduling
- * purposes and lies dormant until one of three things happen:
- * [list]
- * <li>The count reaches zero due to invocations of the
- * {@link #countDown} method; or
- * <li>Some other thread {@link Thread#interrupt interrupts} the current
- * thread; or
- * <li>The specified waiting time elapses.
- * [/list]
- * <p>If the count reaches zero then the method returns with the
- * value <tt>true</tt>.
- * <p>If the current thread:
- * [list]
- * <li>has its interrupted status set on entry to this method; or
- * <li>is {@link Thread#interrupt interrupted} while waiting,
- * [/list]
- * then {@link InterruptedException} is thrown and the current thread's
- * interrupted status is cleared.
- *
- * <p>If the specified waiting time elapses then the value <tt>false</tt>
- * 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 <tt>timeout</tt> argument.
- * @return <tt>true</tt> if the count reached zero and <tt>false</tt>
- * 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.
- * <p>If the current {@link #getCount 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 {@link #getCount count} equals zero then nothing
- * happens.
- */
- public void countDown() {
- sync.releaseShared(1);
- }
- /**
- * Returns the current count.
- * <p>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
- * "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. CountDownLatch工具类的使用案例
CountDownLatch的作用是控制一个计数器,每个线程在运行完毕后执行countDown,表示自己运行结束,这对于多个子任务的计算特别有效,比如一个异步任务需要拆分成10个子任务执行,主任务必须知道子任务是否完成,所有子任务完成后才能进行合并计算,从而保证了一个主任务逻辑的正确性。(此段摘自于<<改善Java程序的151个建议>>, P254)
CountDownLatch最重要的方法是countDown()和await(),前者主要是倒数一次,后者是等待倒数到0,如果没有到达0,就只有阻塞等待了。
本实例主要使用CountDownLatch工具类来实现10个线程对1~100的求和,每个线程对10个数进行求和。第一个线程对1 – 10求和
第二个线程对 11 – 20求和
第三个线程对21 – 30 求和
…..
第十个线程对91 – 100求和。
具体的代码如下:
- package my.concurrent.countdown;
- import java.util.concurrent.Callable;
- import java.util.concurrent.CountDownLatch;
- public class Calculator implements Callable<Integer> {
- //开始信号
- private final CountDownLatch startSignal;
- //结束信号
- private final CountDownLatch doneSignal;
- private int groupNumber = 0;
- /**
- * @param startSignal
- * @param endSignal
- * @param groupId
- */
- public Calculator(CountDownLatch startSignal, CountDownLatch doneSignal,
- int groupNumber) {
- this.startSignal = startSignal;
- this.doneSignal = doneSignal;
- this.groupNumber = groupNumber;
- }
- public Integer call() throws Exception {
- startSignal.await();
- Integer result = sum(groupNumber);
- printCompleteInfor(groupNumber,result);
- doneSignal.countDown();
- return result;
- }
- private Integer sum(int groupNumber) {
- if (groupNumber < 1) {
- throw new IllegalArgumentException();
- }
- int sum = 0;
- int start = (groupNumber - 1) * 10 + 1;
- int end = groupNumber * 10;
- for (int i = start; i <= end; i++) {
- sum += i;
- }
- return sum;
- }
- private void printCompleteInfor(int groupNumber, int sum)
- {
- System.out.println(String.format("Group %d is finished, the sum in this gropu is %d", groupNumber, sum));
- }
- }
- package my.concurrent.countdown;
- import java.util.ArrayList;
- import java.util.List;
- import java.util.concurrent.CountDownLatch;
- import java.util.concurrent.ExecutionException;
- import java.util.concurrent.ExecutorService;
- import java.util.concurrent.Executors;
- import java.util.concurrent.Future;
- public class CountDownLatchTest {
- public static void main(String[] args) throws Exception {
- /**
- * 1-100求和,分10个线程来计算,每个线程对10个数求和。
- */
- int numOfGroups = 10;
- CountDownLatch startSignal = new CountDownLatch(1);
- CountDownLatch doneSignal = new CountDownLatch(numOfGroups);
- ExecutorService service = Executors.newFixedThreadPool(numOfGroups);
- List<Future<Integer>> futures = new ArrayList<Future<Integer>>();
- submit(futures, numOfGroups, service, startSignal, doneSignal);
- /**
- * 开始,让所有的求和计算线程运行
- */
- startSignal.countDown();
- /**
- * 阻塞,知道所有计算线程完成计算
- */
- doneSignal.await();
- shutdown(service);
- printResult(futures);
- }
- private static void submit(List<Future<Integer>> futures, int numOfGroups,
- ExecutorService service, CountDownLatch startSignal,
- CountDownLatch doneSignal) {
- for (int groupNumber = 1; groupNumber <= numOfGroups; groupNumber++) {
- futures.add(service.submit(new Calculator(startSignal, doneSignal,
- groupNumber)));
- }
- }
- private static int getResult(List<Future<Integer>> futures)
- throws InterruptedException, ExecutionException {
- int result = 0;
- for (Future<Integer> f : futures) {
- result += f.get();
- }
- return result;
- }
- private static void printResult(List<Future<Integer>> futures)
- throws InterruptedException, ExecutionException {
- System.out.println("[1,100] Sum is :" + getResult(futures));
- }
- private static void shutdown(ExecutorService service)
- {
- service.shutdown();
- }
- }
一次的执行结果如下:
Group 8 is finished, the sum in this gropu is 755
Group 2 is finished, the sum in this gropu is 155
Group 10 is finished, the sum in this gropu is 955
Group 5 is finished, the sum in this gropu is 455
Group 7 is finished, the sum in this gropu is 655
Group 3 is finished, the sum in this gropu is 255
Group 9 is finished, the sum in this gropu is 855
Group 1 is finished, the sum in this gropu is 55
Group 4 is finished, the sum in this gropu is 355
Group 6 is finished, the sum in this gropu is 555
[1,100] Sum is :5050
相关推荐
Java并发编程是软件开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。本资源"Java并发编程_设计原则和模式(CHM)"聚焦于Java语言在并发环境下的编程技巧、...
本文将深入探讨Java并发编程的设计原则与模式,旨在帮助开发者理解并有效地应用这些原则和模式。 一、并发编程的基础概念 并发是指两个或多个操作在同一时间间隔内执行,而不是严格意义上的同一时刻。在Java中,...
总的来说,“Java并发编程:设计原则与模式”涵盖了从基础到高级的并发编程概念,帮助开发者理解和应用Java平台的并发特性,以构建可扩展、高性能的多线程应用程序。通过深入学习和实践这些知识点,开发者可以在...
《Java并发编程实战》是Java并发编程领域的一本经典著作,它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例,可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
根据提供的信息,“Java 并发编程实战.pdf”这本书聚焦于Java并发编程的实践与应用,旨在帮助读者深入了解并掌握Java中的多线程技术及其在实际项目中的应用技巧。虽然部分内容未能提供具体章节或实例,但从标题及...
以上知识点覆盖了Java并发编程的主要方面,包括线程管理、同步机制、并发工具、设计模式、并发集合以及并发编程的最佳实践等,是理解和掌握Java并发编程的关键。在实际开发中,理解和熟练运用这些知识可以编写出高效...
通过深入学习《JAVA并发编程艺术》,开发者能更好地理解并发编程的原理,熟练运用Java提供的并发工具和API,解决实际开发中的多线程问题,提高软件的性能和稳定性。这是一本值得每一位Java开发者研读的书。
Java并发编程是Java开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。《java并发编程的核心方法和框架》这本书旨在深入探讨这一主题,帮助开发者掌握Java...
《Java并发编程 设计原则与模式 第二版》是一本广受赞誉的经典书籍,由著名计算机科学家Doug Lea撰写,英文原版名为"Concurrent Programming in Java - Design Principles and Patterns, Second Edition"。...
总而言之,《Java并发编程艺术》这本书将系统性地介绍Java并发编程的各种技术和最佳实践,帮助读者提升在多线程环境下的编程能力,从而设计出更加健壮、高效的Java应用。无论你是初级开发者还是经验丰富的工程师,这...
在Java并发编程中,多线程是核心概念之一。多线程允许程序同时执行多个任务,从而充分利用系统资源,提高程序性能。然而,多线程编程也带来了同步和竞态条件等问题,这需要开发者具备良好的线程管理和同步机制的知识...
《Java并发编程实践》是一本深入探讨Java多线程编程的经典著作,由Brian Goetz、Tim Peierls、Joshua Bloch、Joseph Bowles和David Holmes等专家共同编写。这本书全面介绍了Java平台上的并发编程技术,是Java开发...
Java并发编程中的`JUC`(Java Util Concurrency)库是Java平台中用于处理多线程问题的核心工具包,它提供了一系列高效、线程安全的工具类,帮助开发者编写并发应用程序。`AQS`(AbstractQueuedSynchronizer)是JUC库中的...
"Java并发编程与实践"文档深入剖析了这一主题,旨在帮助开发者理解和掌握如何在Java环境中有效地实现并发。 并发是指在单个执行单元(如CPU)中同时执行两个或更多任务的能力。在Java中,这主要通过线程来实现,...
Java并发编程中的多线程协作机制 在 Java 并发编程中,多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中,多个线程之间如何协作、同步和通信,以达到共同完成某个任务的目的。Java 提供了多种...
Java并发编程实践是Java开发中不可或缺的一个领域,它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点,旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...
### Java 并发核心编程知识点解析 #### 一、Java并发概述 自Java诞生之初,其设计者就赋予了该语言强大的并发处理能力。Java语言内置了对线程和锁的支持,这...理解和掌握这些概念和技术是成功进行并发编程的关键。
本书首先会介绍Java并发编程的基础概念,包括线程的创建与管理、同步机制如synchronized关键字和Lock接口,以及如何避免常见的并发问题,如死锁、活锁和饥饿。这些基础知识是理解并发编程的基石,通过深入浅出的讲解...
Java并发编程是Java开发者必须掌握的关键技能之一,它涉及到如何在多线程环境中高效、安全地执行程序。并发编程能够充分利用多核处理器的计算能力,提高应用程序的响应速度和整体性能。《Java编程并发实战》这本书是...
根据提供的文件信息,“JAVA并发编程实践 中文 高清 带书签 完整版 Doug Lea .pdf”,我们可以推断出这份文档主要聚焦于Java并发编程的技术实践与理论探讨。下面将从多个角度来解析这个文档可能涵盖的关键知识点。 ...