CountDownLatch vs. Semaphore(CountDownLatch vs. Semaphore)

 有什么优势使用 
 
 java.util.concurrent.CountdownLatch 
 
 代替 
 
 java.util.concurrent.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();
 
 除了在＃2的情况下，锁存器不能重复使用，更重要的是，您需要事先知道将创建多少个线程（或等待它们在创建锁存器之前全部启动）。 
 
 那么在什么情况下，锁存器会更好？ 

Is there any advantage of using
 
java.util.concurrent.CountdownLatch 
 
instead of
 
java.util.concurrent.Semaphore? 
 
As far as I can tell the following fragments are almost equivalent:
 
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();
 
Except that in case #2 the latch cannot be reused and more importantly you need to know in advance how many threads will be created (or wait until they are all started before creating the latch.)
 
So in what situation might the latch be preferable?

原文：https://stackoverflow.com/questions/184147