`
jaesonchen
  • 浏览: 312919 次
  • 来自: ...
社区版块
存档分类
最新评论

Java并发编程: 使用CountDownLatch协调子线程

 
阅读更多

1. CountDownLatch工具类介绍 

CountDownLatch是一个同步工具类,它允许一个或多个线程处于等待状态直到在其它线程中运行的一组操作完成为止。CountDownLatch用一个给定的计数来实现初始化。Await方法会一直处于阻塞状态,直到countDown方法调用而使当前计数达到零。当计数为零之后,所有处于等待的线程将被释放,await的任何后续调用将立即返回。这种现象只出现一次,计数是不能被重置的。如果你需要一个可以重置计数的版本,需要考虑使用CyclicBarrie. 

上面的介绍来自于CountDownLatch类的注释。 

Java代码  收藏代码
  1. /** 
  2.  * A synchronization aid that allows one or more threads to wait until 
  3.  * a set of operations being performed in other threads completes. 
  4.  * 
  5.  * <p>A {@code CountDownLatch} is initialized with a given [i]count[/i]. 
  6.  * The {@link #await await} methods block until the current count reaches 
  7.  * zero due to invocations of the {@link #countDown} method, after which 
  8.  * all waiting threads are released and any subsequent invocations of 
  9.  * {@link #await await} return immediately.  This is a one-shot phenomenon 
  10.  * -- the count cannot be reset.  If you need a version that resets the 
  11.  * count, consider using a {@link CyclicBarrier}. 
  12.  * 
  13.  */  



CountDownLatch中定义了一个内部类Sync,该类继承AbstractQueuedSynchronizer。从代码中可以看出,CountDownLatch的await,countDown以及getCount方法都调用了Sync的方法。CountDownLatch工具类相关的类图以及详细代码如下: 


 


Java代码  收藏代码
  1. /* 
  2.  * @(#)CountDownLatch.java  1.5 04/02/09 
  3.  * 
  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 
  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. 
  6.  */  
  7.   
  8. package java.util.concurrent;  
  9. import java.util.concurrent.locks.*;  
  10. import java.util.concurrent.atomic.*;  
  11.   
  12. /** 
  13.  * A synchronization aid that allows one or more threads to wait until 
  14.  * a set of operations being performed in other threads completes. 
  15.  * 
  16.  * <p>A <tt>CountDownLatch</tt> is initialized with a given 
  17.  * [i]count[/i].  The {@link #await await} methods block until the current 
  18.  * {@link #getCount count} reaches zero due to invocations of the 
  19.  * {@link #countDown} method, after which all waiting threads are 
  20.  * released and any subsequent invocations of {@link #await await} return 
  21.  * immediately. This is a one-shot phenomenon -- the count cannot be 
  22.  * reset.  If you need a version that resets the count, consider using 
  23.  * a {@link CyclicBarrier}. 
  24.  * 
  25.  * <p>A <tt>CountDownLatch</tt> is a versatile synchronization tool 
  26.  * and can be used for a number of purposes.  A 
  27.  * <tt>CountDownLatch</tt> initialized with a count of one serves as a 
  28.  * simple on/off latch, or gate: all threads invoking {@link #await await} 
  29.  * wait at the gate until it is opened by a thread invoking {@link 
  30.  * #countDown}.  A <tt>CountDownLatch</tt> initialized to [i]N[/i] 
  31.  * can be used to make one thread wait until [i]N[/i] threads have 
  32.  * completed some action, or some action has been completed N times. 
  33.  * <p>A useful property of a <tt>CountDownLatch</tt> is that it 
  34.  * doesn't require that threads calling <tt>countDown</tt> wait for 
  35.  * the count to reach zero before proceeding, it simply prevents any 
  36.  * thread from proceeding past an {@link #await await} until all 
  37.  * threads could pass. 
  38.  * 
  39.  * <p><b>Sample usage:</b> Here is a pair of classes in which a group 
  40.  * of worker threads use two countdown latches: 
  41.  * [list] 
  42.  * <li>The first is a start signal that prevents any worker from proceeding 
  43.  * until the driver is ready for them to proceed; 
  44.  * <li>The second is a completion signal that allows the driver to wait 
  45.  * until all workers have completed. 
  46.  * [/list] 
  47.  * 
  48.  * <pre> 
  49.  * class Driver { // ... 
  50.  *   void main() throws InterruptedException { 
  51.  *     CountDownLatch startSignal = new CountDownLatch(1); 
  52.  *     CountDownLatch doneSignal = new CountDownLatch(N); 
  53.  * 
  54.  *     for (int i = 0; i < N; ++i) // create and start threads 
  55.  *       new Thread(new Worker(startSignal, doneSignal)).start(); 
  56.  * 
  57.  *     doSomethingElse();            // don't let run yet 
  58.  *     startSignal.countDown();      // let all threads proceed 
  59.  *     doSomethingElse(); 
  60.  *     doneSignal.await();           // wait for all to finish 
  61.  *   } 
  62.  * } 
  63.  * 
  64.  * class Worker implements Runnable { 
  65.  *   private final CountDownLatch startSignal; 
  66.  *   private final CountDownLatch doneSignal; 
  67.  *   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) { 
  68.  *      this.startSignal = startSignal; 
  69.  *      this.doneSignal = doneSignal; 
  70.  *   } 
  71.  *   public void run() { 
  72.  *      try { 
  73.  *        startSignal.await(); 
  74.  *        doWork(); 
  75.  *        doneSignal.countDown(); 
  76.  *      } catch (InterruptedException ex) {} // return; 
  77.  *   } 
  78.  * 
  79.  *   void doWork() { ... } 
  80.  * } 
  81.  * 
  82.  * </pre> 
  83.  * 
  84.  * <p>Another typical usage would be to divide a problem into N parts, 
  85.  * describe each part with a Runnable that executes that portion and 
  86.  * counts down on the latch, and queue all the Runnables to an 
  87.  * Executor.  When all sub-parts are complete, the coordinating thread 
  88.  * will be able to pass through await. (When threads must repeatedly 
  89.  * count down in this way, instead use a {@link CyclicBarrier}.) 
  90.  * 
  91.  * <pre> 
  92.  * class Driver2 { // ... 
  93.  *   void main() throws InterruptedException { 
  94.  *     CountDownLatch doneSignal = new CountDownLatch(N); 
  95.  *     Executor e = ... 
  96.  * 
  97.  *     for (int i = 0; i < N; ++i) // create and start threads 
  98.  *       e.execute(new WorkerRunnable(doneSignal, i)); 
  99.  * 
  100.  *     doneSignal.await();           // wait for all to finish 
  101.  *   } 
  102.  * } 
  103.  * 
  104.  * class WorkerRunnable implements Runnable { 
  105.  *   private final CountDownLatch doneSignal; 
  106.  *   private final int i; 
  107.  *   WorkerRunnable(CountDownLatch doneSignal, int i) { 
  108.  *      this.doneSignal = doneSignal; 
  109.  *      this.i = i; 
  110.  *   } 
  111.  *   public void run() { 
  112.  *      try { 
  113.  *        doWork(i); 
  114.  *        doneSignal.countDown(); 
  115.  *      } catch (InterruptedException ex) {} // return; 
  116.  *   } 
  117.  * 
  118.  *   void doWork() { ... } 
  119.  * } 
  120.  * 
  121.  * </pre> 
  122.  * 
  123.  * @since 1.5 
  124.  * @author Doug Lea 
  125.  */  
  126. public class CountDownLatch {  
  127.     /** 
  128.      * Synchronization control For CountDownLatch. 
  129.      * Uses AQS state to represent count. 
  130.      */  
  131.     private static final class Sync extends AbstractQueuedSynchronizer {  
  132.         Sync(int count) {  
  133.             setState(count);   
  134.         }  
  135.           
  136.         int getCount() {  
  137.             return getState();  
  138.         }  
  139.   
  140.         public int tryAcquireShared(int acquires) {  
  141.             return getState() == 01 : -1;  
  142.         }  
  143.           
  144.         public boolean tryReleaseShared(int releases) {  
  145.             // Decrement count; signal when transition to zero  
  146.             for (;;) {  
  147.                 int c = getState();  
  148.                 if (c == 0)  
  149.                     return false;  
  150.                 int nextc = c-1;  
  151.                 if (compareAndSetState(c, nextc))   
  152.                     return nextc == 0;  
  153.             }  
  154.         }  
  155.     }  
  156.   
  157.     private final Sync sync;  
  158.     /** 
  159.      * Constructs a <tt>CountDownLatch</tt> initialized with the given 
  160.      * count. 
  161.      *  
  162.      * @param count the number of times {@link #countDown} must be invoked 
  163.      * before threads can pass through {@link #await}. 
  164.      * 
  165.      * @throws IllegalArgumentException if <tt>count</tt> is less than zero. 
  166.      */  
  167.     public CountDownLatch(int count) {   
  168.         if (count < 0throw new IllegalArgumentException("count < 0");  
  169.         this.sync = new Sync(count);  
  170.     }  
  171.   
  172.     /** 
  173.      * Causes the current thread to wait until the latch has counted down to  
  174.      * zero, unless the thread is {@link Thread#interrupt interrupted}. 
  175.      * 
  176.      * <p>If the current {@link #getCount count} is zero then this method 
  177.      * returns immediately. 
  178.      * <p>If the current {@link #getCount count} is greater than zero then 
  179.      * the current thread becomes disabled for thread scheduling  
  180.      * purposes and lies dormant until one of two things happen: 
  181.      * [list] 
  182.      * <li>The count reaches zero due to invocations of the 
  183.      * {@link #countDown} method; or 
  184.      * <li>Some other thread {@link Thread#interrupt interrupts} the current 
  185.      * thread. 
  186.      * [/list] 
  187.      * <p>If the current thread: 
  188.      * [list] 
  189.      * <li>has its interrupted status set on entry to this method; or  
  190.      * <li>is {@link Thread#interrupt interrupted} while waiting,  
  191.      * [/list] 
  192.      * then {@link InterruptedException} is thrown and the current thread's  
  193.      * interrupted status is cleared.  
  194.      * 
  195.      * @throws InterruptedException if the current thread is interrupted 
  196.      * while waiting. 
  197.      */  
  198.     public void await() throws InterruptedException {  
  199.         sync.acquireSharedInterruptibly(1);  
  200.     }  
  201.   
  202.     /** 
  203.      * Causes the current thread to wait until the latch has counted down to  
  204.      * zero, unless the thread is {@link Thread#interrupt interrupted}, 
  205.      * or the specified waiting time elapses. 
  206.      * 
  207.      * <p>If the current {@link #getCount count} is zero then this method 
  208.      * returns immediately with the value <tt>true</tt>. 
  209.      * 
  210.      * <p>If the current {@link #getCount count} is greater than zero then 
  211.      * the current thread becomes disabled for thread scheduling  
  212.      * purposes and lies dormant until one of three things happen: 
  213.      * [list] 
  214.      * <li>The count reaches zero due to invocations of the 
  215.      * {@link #countDown} method; or 
  216.      * <li>Some other thread {@link Thread#interrupt interrupts} the current 
  217.      * thread; or 
  218.      * <li>The specified waiting time elapses. 
  219.      * [/list] 
  220.      * <p>If the count reaches zero then the method returns with the 
  221.      * value <tt>true</tt>. 
  222.      * <p>If the current thread: 
  223.      * [list] 
  224.      * <li>has its interrupted status set on entry to this method; or  
  225.      * <li>is {@link Thread#interrupt interrupted} while waiting,  
  226.      * [/list] 
  227.      * then {@link InterruptedException} is thrown and the current thread's  
  228.      * interrupted status is cleared.  
  229.      * 
  230.      * <p>If the specified waiting time elapses then the value <tt>false</tt> 
  231.      * is returned. 
  232.      * If the time is  
  233.      * less than or equal to zero, the method will not wait at all. 
  234.      * 
  235.      * @param timeout the maximum time to wait 
  236.      * @param unit the time unit of the <tt>timeout</tt> argument. 
  237.      * @return <tt>true</tt> if the count reached zero  and <tt>false</tt> 
  238.      * if the waiting time elapsed before the count reached zero. 
  239.      * 
  240.      * @throws InterruptedException if the current thread is interrupted 
  241.      * while waiting. 
  242.      */  
  243.     public boolean await(long timeout, TimeUnit unit)   
  244.         throws InterruptedException {  
  245.         return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));  
  246.     }  
  247.   
  248.     /** 
  249.      * Decrements the count of the latch, releasing all waiting threads if 
  250.      * the count reaches zero. 
  251.      * <p>If the current {@link #getCount count} is greater than zero then 
  252.      * it is decremented. If the new count is zero then all waiting threads 
  253.      * are re-enabled for thread scheduling purposes. 
  254.      * <p>If the current {@link #getCount count} equals zero then nothing 
  255.      * happens. 
  256.      */  
  257.     public void countDown() {  
  258.         sync.releaseShared(1);  
  259.     }  
  260.   
  261.     /** 
  262.      * Returns the current count. 
  263.      * <p>This method is typically used for debugging and testing purposes. 
  264.      * @return the current count. 
  265.      */  
  266.     public long getCount() {  
  267.         return sync.getCount();  
  268.     }  
  269.   
  270.     /** 
  271.      * Returns a string identifying this latch, as well as its state. 
  272.      * The state, in brackets, includes the String  
  273.      * "Count =" followed by the current count. 
  274.      * @return a string identifying this latch, as well as its 
  275.      * state 
  276.      */  
  277.     public String toString() {  
  278.         return super.toString() + "[Count = " + sync.getCount() + "]";  
  279.     }  
  280.   
  281. }  



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求和。 

具体的代码如下: 

Java代码  收藏代码
  1. package my.concurrent.countdown;  
  2.   
  3. import java.util.concurrent.Callable;  
  4. import java.util.concurrent.CountDownLatch;  
  5.   
  6. public class Calculator implements Callable<Integer> {  
  7.   
  8.     //开始信号  
  9.     private final CountDownLatch startSignal;  
  10.       
  11.     //结束信号  
  12.     private final CountDownLatch doneSignal;  
  13.       
  14.     private int groupNumber = 0;  
  15.   
  16.     /** 
  17.      * @param startSignal 
  18.      * @param endSignal 
  19.      * @param groupId 
  20.      */  
  21.     public Calculator(CountDownLatch startSignal, CountDownLatch doneSignal,  
  22.             int groupNumber) {  
  23.         this.startSignal = startSignal;  
  24.         this.doneSignal = doneSignal;  
  25.         this.groupNumber = groupNumber;  
  26.     }  
  27.   
  28.     public Integer call() throws Exception {  
  29.   
  30.         startSignal.await();  
  31.   
  32.         Integer result = sum(groupNumber);  
  33.   
  34.         printCompleteInfor(groupNumber,result);  
  35.           
  36.         doneSignal.countDown();  
  37.   
  38.         return result;  
  39.     }  
  40.   
  41.     private Integer sum(int groupNumber) {  
  42.         if (groupNumber < 1) {  
  43.             throw new IllegalArgumentException();  
  44.         }  
  45.   
  46.         int sum = 0;  
  47.         int start = (groupNumber - 1) * 10 + 1;  
  48.         int end = groupNumber * 10;  
  49.         for (int i = start; i <= end; i++) {  
  50.             sum += i;  
  51.         }  
  52.         return sum;  
  53.     }  
  54.       
  55.     private void printCompleteInfor(int groupNumber, int sum)  
  56.     {  
  57.         System.out.println(String.format("Group %d is finished, the sum in this gropu is %d", groupNumber, sum));  
  58.     }  
  59.   
  60. }  



Java代码  收藏代码
  1. package my.concurrent.countdown;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.concurrent.CountDownLatch;  
  6. import java.util.concurrent.ExecutionException;  
  7. import java.util.concurrent.ExecutorService;  
  8. import java.util.concurrent.Executors;  
  9. import java.util.concurrent.Future;  
  10.   
  11. public class CountDownLatchTest {  
  12.   
  13.     public static void main(String[] args) throws Exception {  
  14.         /** 
  15.          * 1-100求和,分10个线程来计算,每个线程对10个数求和。 
  16.          */  
  17.         int numOfGroups = 10;  
  18.         CountDownLatch startSignal = new CountDownLatch(1);  
  19.           
  20.         CountDownLatch doneSignal = new CountDownLatch(numOfGroups);  
  21.           
  22.         ExecutorService service = Executors.newFixedThreadPool(numOfGroups);  
  23.         List<Future<Integer>> futures = new ArrayList<Future<Integer>>();  
  24.   
  25.         submit(futures, numOfGroups, service, startSignal, doneSignal);  
  26.           
  27.         /** 
  28.          * 开始,让所有的求和计算线程运行 
  29.          */  
  30.         startSignal.countDown();  
  31.           
  32.         /** 
  33.          * 阻塞,知道所有计算线程完成计算 
  34.          */  
  35.         doneSignal.await();  
  36.   
  37.         shutdown(service);  
  38.           
  39.         printResult(futures);  
  40.     }  
  41.   
  42.     private static void submit(List<Future<Integer>> futures, int numOfGroups,  
  43.             ExecutorService service, CountDownLatch startSignal,  
  44.             CountDownLatch doneSignal) {  
  45.         for (int groupNumber = 1; groupNumber <= numOfGroups; groupNumber++) {  
  46.             futures.add(service.submit(new Calculator(startSignal, doneSignal,  
  47.                     groupNumber)));  
  48.         }  
  49.     }  
  50.   
  51.     private static int getResult(List<Future<Integer>> futures)  
  52.             throws InterruptedException, ExecutionException {  
  53.         int result = 0;  
  54.         for (Future<Integer> f : futures) {  
  55.             result += f.get();  
  56.         }  
  57.         return result;  
  58.     }  
  59.   
  60.     private static void printResult(List<Future<Integer>> futures)  
  61.             throws InterruptedException, ExecutionException {  
  62.         System.out.println("[1,100] Sum is :" + getResult(futures));  
  63.     }  
  64.       
  65.     private static void shutdown(ExecutorService service)  
  66.     {  
  67.         service.shutdown();  
  68.     }  
  69.   
  70. }  



一次的执行结果如下: 
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并发编程:设计原则与模式(第二版)-3

    《Java并发编程:设计原则与模式(第二版)》是一本深入探讨Java多线程编程技术的权威著作。这本书详细阐述了在Java平台中进行高效并发处理的关键概念、设计原则和实用模式。以下是对该书内容的一些核心知识点的概述...

    java并发编程:设计原则与模式.rar

    《Java并发编程:设计原则与模式》是一本深入探讨Java多线程编程的书籍,它涵盖了并发编程中的关键概念、原则和模式。在Java中,并发处理是优化应用程序性能、提高资源利用率的重要手段,尤其在现代多核处理器的环境...

    Java并发编程:设计原则与模式(第二版)-3PDF

    《Java并发编程:设计原则与模式(第二版)》是一本深入探讨Java平台上的多线程和并发编程的权威著作。这本书旨在帮助开发者理解和掌握如何有效地编写可扩展且高效的并发程序。以下是书中涵盖的一些关键知识点: 1....

    Java 并发编程:设计原则与模式

    总的来说,“Java并发编程:设计原则与模式”涵盖了从基础到高级的并发编程概念,帮助开发者理解和应用Java平台的并发特性,以构建可扩展、高性能的多线程应用程序。通过深入学习和实践这些知识点,开发者可以在...

    一本经典的多线程书籍 Java并发编程 设计原则与模式 第二版 (英文原版)

    《Java并发编程 设计原则与模式 第二版》是一本深受程序员喜爱的经典书籍,由Addison Wesley出版。这本书深入探讨了Java平台上的多线程编程技术,为开发者提供了丰富的设计原则和模式,帮助他们理解和解决并发环境中...

    java并发编程实战源码,java并发编程实战pdf,Java

    《Java并发编程实战》是Java并发编程领域的一本经典著作,它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例,可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...

    《Java并发编程:设计原则与模式(第二版)》

    《Java并发编程:设计原则与模式(第二版)》是一本深入探讨Java多线程编程技术的权威著作。这本书详细阐述了如何在Java环境中高效、安全地进行并发编程,涵盖了多线程设计的关键原则和常见模式。对于Java开发者来说...

    Java 并发编程实战.pdf

    根据提供的信息,“Java 并发编程实战.pdf”这本书聚焦于Java并发编程的实践与应用,旨在帮助读者深入了解并掌握Java中的多线程技术及其在实际项目中的应用技巧。虽然部分内容未能提供具体章节或实例,但从标题及...

    Java并发编程的设计原则与模式

    本文将深入探讨Java并发编程的设计原则与模式,旨在帮助开发者理解并有效地应用这些原则和模式。 一、并发编程的基础概念 并发是指两个或多个操作在同一时间间隔内执行,而不是严格意义上的同一时刻。在Java中,...

    Java并发编程:设计原则与模式(第二版)_阅读密码www.zasp.net_仅提供试看如需要请购买原版书

    Java提供了丰富的并发工具和API,包括线程、锁、同步、并发集合、并发工具类以及Java内存模型(JMM),这些都是Java并发编程的基础。 1. **线程与进程**:在Java中,线程是程序执行的基本单元,而进程是系统分配...

    Java并发编程_设计原则和模式(CHM)

    Java并发编程是软件开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。本资源"Java并发编程_设计原则和模式(CHM)"聚焦于Java语言在并发环境下的编程技巧、...

    java并发编程2

    以上知识点覆盖了Java并发编程的主要方面,包括线程管理、同步机制、并发工具、设计模式、并发集合以及并发编程的最佳实践等,是理解和掌握Java并发编程的关键。在实际开发中,理解和熟练运用这些知识可以编写出高效...

    JAVA并发编程艺术pdf版

    通过深入学习《JAVA并发编程艺术》,开发者能更好地理解并发编程的原理,熟练运用Java提供的并发工具和API,解决实际开发中的多线程问题,提高软件的性能和稳定性。这是一本值得每一位Java开发者研读的书。

    《java并发编程的核心方法和框架》

    Java并发编程是Java开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。《java并发编程的核心方法和框架》这本书旨在深入探讨这一主题,帮助开发者掌握Java...

    《java 并发编程实战高清PDF版》

    在Java并发编程中,多线程是核心概念之一。多线程允许程序同时执行多个任务,从而充分利用系统资源,提高程序性能。然而,多线程编程也带来了同步和竞态条件等问题,这需要开发者具备良好的线程管理和同步机制的知识...

    Java并发编程实践高清pdf及源码

    《Java并发编程实践》是一本深入探讨Java多线程编程的经典著作,由Brian Goetz、Tim Peierls、Joshua Bloch、Joseph Bowles和David Holmes等专家共同编写。这本书全面介绍了Java平台上的并发编程技术,是Java开发...

    java并发编程:juc、aqs

    Java并发编程中的`JUC`(Java Util Concurrency)库是Java平台中用于处理多线程问题的核心工具包,它提供了一系列高效、线程安全的工具类,帮助开发者编写并发应用程序。`AQS`(AbstractQueuedSynchronizer)是JUC库中的...

    java并发编程与实践

    "Java并发编程与实践"文档深入剖析了这一主题,旨在帮助开发者理解和掌握如何在Java环境中有效地实现并发。 并发是指在单个执行单元(如CPU)中同时执行两个或更多任务的能力。在Java中,这主要通过线程来实现,...

    java并发编程艺术

    总而言之,《Java并发编程艺术》这本书将系统性地介绍Java并发编程的各种技术和最佳实践,帮助读者提升在多线程环境下的编程能力,从而设计出更加健壮、高效的Java应用。无论你是初级开发者还是经验丰富的工程师,这...

Global site tag (gtag.js) - Google Analytics