对CountDownLatch的初步学习

Posted JimKing

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了对CountDownLatch的初步学习相关的知识,希望对你有一定的参考价值。

CountDownLatch的中文翻译为"闭锁",在JDK1.5中 CountDownLatch类加入进来。为程序猿进行并发编程提供有利的帮助。

 

首先我们先看看JDK文档中对于CountDownLatch类的介绍:

A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
 大致意思是CountDownLatch为一个同步辅助工具,让一个或多个线程等待,直到其他的线程执行操作完成。

  它的功能可以在绝大部分情况上替代join()方法,甚至在实际运用中比join()方法的用法更灵活。

  操作过程:用CountDownLatch类创建实例,指定需要等待完成点个数。await()方法会阻塞当前线程,直到计数器减为零。每次线程执行调用countDown()方法,就会使计数器减1,直到计数器减为0时,等待的线程继续运行。

  • CountDownLatch类中的构造器:
    /**
     * 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); }

 

  • CountDownLatch类中的方法:

  1. await() 方法

    /**
     * Causes the current thread to wait until the latch has counted down to
     * zero, unless the thread is {@linkplain Thread#interrupt interrupted}.
     * 使当前线程等待直到闭锁的计数器为0,除非线程由于中断异常中断。
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

 

  2. await(long timeout, TimeUnit unit) 方法

    /**
     * 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.
   * 使当前线程等待直到闭锁计数器为0,除非线程遇到线程中断异常中断,或者超出指定的等待时间。 * @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)); }

 

  3. countDown() 方法

    /**
     * Decrements the count of the latch, releasing all waiting threads if
     * the count reaches zero.
     * 减少闭锁的计数,若计数达到0则释放所有等待线程
     * <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.
     */
    public void countDown() {
        sync.releaseShared(1);
    }

 

  4. getCount() 方法

    /**
     * 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();
    }

 

应用:

  有这么一道题:用4个线程并发执行从1加到100,每个线程只能加25个数,主线程需要等待子线程结束完成后才能结束。

  思想:可以用join()方法,也可以用CountDownLatch对象来暂停主线程。

  代码:

import java.util.concurrent.CountDownLatch;

public class Compute {
    public static int sum = 0;// 存储1加到100的数
    public static CountDownLatch count = new CountDownLatch(4);// 闭锁,计数器设置为4

    static class ComputeThread extends Thread {// 内部类
        int start, end;// 起始与结束

        public ComputeThread(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public void run() {// 每个线程都进行累加
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            System.out.println(currentThread().getName() + ":" + sum);
            count.countDown();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 建立4个线程
        ComputeThread c1 = new Compute.ComputeThread(1, 25);
        ComputeThread c2 = new Compute.ComputeThread(26, 50);
        ComputeThread c3 = new Compute.ComputeThread(51, 75);
        ComputeThread c4 = new Compute.ComputeThread(76, 100);
        // 启动4个线程
        c1.start();
        c2.start();
        c3.start();
        c4.start();
        // 让调用线程停止,等待计数器为0
        count.await();
        System.out.println(sum);
    }
}
 

以上是关于对CountDownLatch的初步学习的主要内容,如果未能解决你的问题,请参考以下文章

JUC并发编程 共享模式之工具 JUC CountdownLatch(倒计时锁) -- CountdownLatch应用(等待多个线程准备完毕( 可以覆盖上次的打印内)等待多个远程调用结束)(代码片段

Java中CountDownLatch使用初步

多线程等待所有子线程执行完使用总结——CyclicBarrier使用和源码初步分析

学习CountDownLatch

Java并发编程-CountDownLatch

Java并发编程-CountDownLatch