Gibt es einen Vorteil bei der Verwendung

java.util.concurrent.CountdownLatch

anstatt

java.util.concurrent.Semaphore?

Soweit ich das beurteilen kann, sind die folgenden Fragmente fast gleichwertig:

1. Semaphor

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();

Abgesehen davon, dass in Fall 2 das Latch nicht wiederverwendet werden kann und vor allem müssen Sie im Voraus wissen, wie viele Threads erstellt werden (oder warten, bis alle gestartet wurden, bevor Sie das Latch erstellen).

In welcher Situation ist der Riegel also vorzuziehen?