CountDownLatch - 理解 await 和 countDown

Question

根据Javadoc文档: CountDownLatch会初始化为一个给定的计数。await方法会阻塞，直到当前计数达到零。

这意味着在下面的代码中，由于我将CountDownLatch初始化为1，所有线程应该在latch调用countdown时从await方法中解除阻塞。

但是，主线程正在等待所有线程完成。并且，我没有将主线程加入到其他线程的末尾。为什么主线程还在等待？

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

public class Sample implements Runnable {

    private CountDownLatch latch;

    public Sample(CountDownLatch latch)
    {
        this.latch = latch;
    }
    private static AtomicLong number = new AtomicLong(0);

    public long next() {
         return number.getAndIncrement();
    }

    public static void main(String[] args) {

        CountDownLatch latch = new CountDownLatch(1);
        for (int threadNo = 0; threadNo < 4000; threadNo++) {
          Runnable t = new Sample(latch);
          new Thread(t).start();
        }
        try {
            latch.countDown();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            latch.await();
            Thread.sleep(100);
            System.out.println("Count:"+next());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

- user982733

Answer 1

请尝试运行以下修改后的代码：

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

public class Test implements Runnable {

    private CountDownLatch latch;

    public Test(CountDownLatch latch)
    {
        this.latch = latch;
    }
    private static AtomicLong number = new AtomicLong(0);

    public long next() {
         return number.getAndIncrement();
    }

    public static void main(String[] args) {

        CountDownLatch latch = new CountDownLatch(1);
        for (int threadNo = 0; threadNo < 1000; threadNo++) {
          Runnable t = new Test(latch);
          new Thread(t).start();
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println( "done" );
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000 + (int) ( Math.random() * 3000 ));
            System.out.println(next());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            latch.countDown();
        }
    }

}

你应该看到类似于以下内容：

0
已完成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这表明主线程确实在第一个线程调用 latch.countDown() 后从 latch.await() 调用中解除阻塞。

- ulmangt

Answer 2

你正在启动4000个线程，而它们只等待100毫秒。很可能会使系统不堪重负（并且所有线程将在大约相同的时间结束）。在线程启动时添加一个睡眠时间，并尝试增加超时时间以使其按照您的期望工作。

- jtahlborn

---

我在Thread.sleep(1000 + (int) ( Math.random() * 3000 ));的调用中添加了一些随机性，以及在latch.await()之后添加了一个打印语句，结果如预期。 - ulmangt

我已经更改了实现方式，你能否回复一下为什么它会表现出这样的行为？为什么主线程要等待所有线程完成？我没有放置任何join来要求主线程等待直到所有线程完成。 - user982733

在使用倒计时门闩时，我们需要考虑两件事情 -

1. 在一行代码中阻塞N个线程/任务，即thread.await。
2. 您必须有唤醒每个等待线程的标准，并记住唤醒可以由其他线程完成，因为其余线程正在等待！

- hi.nitish

Answer 3

这是一个很好的参考例子。无论依赖线程需要多长时间准备好（通过调用await()），主线程都会暂停并等待它们准备好。

import lombok.SneakyThrows;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchDemo {
    @SneakyThrows
    public static void main(String[] args) {
        CountDownLatch cl = new CountDownLatch(4);
        ExecutorService es = Executors.newFixedThreadPool(4);
        DependentService ds1 = new DependentService(cl, "DependenService 1");
        DependentService ds2 = new DependentService(cl, "DependenService 2");
        DependentService ds3 = new DependentService(cl, "DependenService 3");
        DependentService ds4 = new DependentService(cl, "DependenService 4");
        es.submit(ds1);
        es.submit(ds2);
        es.submit(ds3);
        es.submit(ds4);
        Thread.sleep((long) (Math.random() * 100));
        System.out.println("Main Thread ready");
        es.shutdownNow();
    }


    private static class DependentService implements Runnable {
        private final String name;
        private final CountDownLatch cl;

        public DependentService(CountDownLatch cl, String name) {
            this.cl = cl;
            this.name = name;
        }

        @SneakyThrows
        @Override
        public void run() {
            System.out.println(name + "working");
            cl.await();
            System.out.println(name + " Initialised!");
        }
    }
}

在输出中，“主线程已准备就绪”将始终是最后一行。

DependenService 2working
DependenService 4working
DependenService 1working
DependenService 3working
Main Thread ready

---

- Mak