CountDownLatch 与信号量

Question

使用

java.util.concurrent.CountDownLatch.html 是否有任何优势？ util.concurrent.CountdownLatch

而不是

java.util.concurrent.Semaphore？

据我所知，以下片段几乎是等效的：

1. Semaphore

final Semaphore sem = new Semaphore(0);
for (int i = 0; i < num_threads; ++ i)
{
  Thread t = new Thread() {
    public void run()
    {
      try
      {
        doStuff();
      }
      finally
      {
        sem.release();
      }
    }
  };
  t.start();
}

sem.acquire(num_threads);

2：CountDownLatch

final CountDownLatch latch = new CountDownLatch(num_threads);
for (int i = 0; i < num_threads; ++ i)
{
  Thread t = new Thread() {
    public void run()
    {
      try
      {
        doStuff();
      }
      finally
      {
        latch.countDown();
      }
    }
  };
  t.start();
}

latch.await();

除了第二种情况，锁存器不能重用，更重要的是你需要提前知道将创建多少个线程（或者等到它们全部启动后再使用）创建闩锁。）

那么在什么情况下闩锁可能更可取呢？

Answer 1

CountDownLatch 用于启动一系列线程，然后等待，直到所有线程完成（或者直到它们调用 countDown() 给定的次数。

信号量用于控制正在使用资源的并发线程的数量。该资源可以是文件之类的东西，也可以是通过限制执行线程数量的 CPU。当不同的线程调用 acquire() 和 release( 时，信号量的计数可能会上下波动。 )

在您的示例中，您实际上是使用 Semaphore 作为一种 CountUPLatch，因为您的目的是使用 CountdownLatch< 来等待所有线程完成。 /code> 让你的意图更清晰。

Answer 2

简短摘要：

1. 信号量 和 CountDownLatch 有不同的用途。

2. 使用Semaphore来控制线程对资源的访问。

3. 使用CountDownLatch等待所有线程完成

信号量 来自 docs.oracle.com ：

信号量维护一组许可。 如果有必要，每个 acquire() 都会阻塞，直到许可可用，然后获取它。 每个release()都会添加一个许可，可能会释放一个阻塞的获取者。 然而，没有使用实际的许可对象； Semaphore 只是保留可用数量的计数并相应地执行操作。

它是如何工作的？

信号量用于控制访问文件、网络套接字等资源的并发线程数。

信号量使用计数器值进行初始化，该计数器值提供允许的最大许可。

acquire() 将减少许可数量。 release() 将增加许可证数量。 在任何时候，都不可能有更多的资源所有者超过允许的许可证数量。

当您的资源数量有限时（可能是线程数、网络套接字数、网络打印机数等），它很有用。

Javadocs 中的 CountDownLatch 定义：

一种同步辅助工具，允许一个或多个线程等待，直到其他线程中执行的一组操作完成。

它是如何工作的？

CountDownLatch 通过设置一个用线程数初始化的计数器来工作。 当线程完成其执行时，计数器就会递减。 当所有线程完成执行后，计数器将归零。

CountDownLatch 使用案例：通过 howtodoinjava.com 作者：Lokesh Gupta

1. 最大并行度
2. 等待所有线程完成后再开始执行其他任务
3. 死锁检测

Answer 3

假设您走进高尔夫专卖店，希望找到一个四人组，

当您排队等待一位专卖店服务员的开球时间时，实际上您调用了 proshopVendorSemaphore.acquire()，一次你得到一个开球时间，你调用proshopVendorSemaphore.release()。注意：任何免费服务员都可以为你服务，即共享资源。

现在您走到启动器处，他启动一个 CountDownLatch(4) 并调用 await() 等待其他人，对于您称为签入的部分，即 CountDownLatch.countDown() 四人组的其余部分也是如此。 当所有人都到达时，出发者继续前进（await() call returns)

现在，在九个洞之后，当你们每个人休息时，假设让出发者再次参与，他使用“新” CountDownLatch(4) 开球第 10 洞，与第 1 洞相同的等待/同步。

但是，如果发球手使用 CyclicBarrier 开始，他可以在第 1 洞中重置相同的实例10 代替第二个锁存器，它使用 & 扔。

Answer 4

查看免费提供的源代码，这两个类的实现没有什么神奇之处，因此它们的性能应该大致相同。 选择能让您的意图更加明显的一项。

Answer 5

CountdownLatch 使线程等待 await() 方法，直到计数达到零。 因此，也许您希望所有线程都等待 3 次调用某项，然后所有线程都可以运行。 Latch 通常无法重置。

信号量允许线程检索许可，这可以防止同时执行太多线程，如果无法获得继续所需的许可，则会阻塞。 许可可以返回到信号量，允许其他等待线程继续进行。

Answer 6

信号量通过使用计数器来控制对共享资源的访问。 如果计数器大于零，则允许访问。 如果为零，则访问被拒绝。 计数器正在计算允许访问共享资源的许可。 因此，要访问资源，线程必须获得信号量的许可。

CountDownlatch 使线程等待，直到发生一个或多个事件。 countDownLatch 最初是通过对锁存器释放之前发生的事件数进行计数来创建的。 每次发生事件时，计数都会递减。

Answer 7

简短的回答：

代码没有很好地描述其哲学。

CountdownLatch 原理

用于等待直到已知数量的资源被释放。

示例：我即将开始 10 项工作，我想等到所有工作都完成。 与轮询和检查 10 项是否全部完成相反。

信号量原理

用于获取资源，直到资源耗尽，然后等待资源可用。

示例：我有一定数量的作业排队，并且我愿意分配最多 10 个线程来处理该队列。 当所有 10 个线程都忙时，下一个作业必须等待，直到有一个线程可用。 与轮询和检查线程是否可用于该作业相反。

Answer 8

CountDownLatch 经常用于与您的示例完全相反的情况。 通常，您会在 await() 上阻塞许多线程，当倒计时达到零时，这些线程将同时启动。

final CountDownLatch countdown = new CountDownLatch(1);

for (int i = 0; i < 10; ++ i) {
   Thread racecar = new Thread() {    
      public void run() {
         countdown.await(); //all threads waiting
         System.out.println("Vroom!");
      }
   };
   racecar.start();
}
System.out.println("Go");
countdown.countDown();   //all threads start now!

您还可以将其用作 MPI 样式的“屏障”，使所有线程在继续之前等待其他线程赶上某个点。

final CountDownLatch countdown = new CountDownLatch(num_thread);

for (int i = 0; i < num_thread; ++ i) {
   Thread t= new Thread() {    
      public void run() {
         doSomething();
         countdown.countDown();
         System.out.printf("Waiting on %d other threads.",countdown.getCount());
         countdown.await();     //waits until everyone reaches this point
         finish();
      }
   };
   t.start();
}

总而言之，CountDownLatch 可以按照您在示例中所示的方式安全地使用。