CountDownLatch vs. Semaphore

Czy jest jakaś korzyść z używania

java.util.concurrent.CountdownLatch

zamiast

java.util.concurrent.Semaphore?

O ile mogę powiedzieć, następujące fragmenty są prawie równoważne:

1. Semafor

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

Z wyjątkiem tego, że w przypadku # 2 zatrzask nie może być ponownie użyty i, co ważniejsze, musisz wiedzieć z wyprzedzeniem, ile wątków zostanie utworzonych (lub poczekać, aż wszystkie zostaną uruchomione przed utworzeniem zatrzasku).

Więc w jakiej sytuacji może być preferowany zatrzask?

questionAnswers(6)

yourAnswerToTheQuestion