Un método latch.await() de CountDownLatch frente a Thread.join()

Question

Vi que un miembro de stackoverflow sugiere usar Thread.join() para tener un hilo "principal" esperando a que se completen 2 hilos de "tareas".

Con frecuencia haré algo diferente (se muestra a continuación) y quiero saber si hay algún problema con mi enfoque.

final CountDownLatch latch = new CountDownLatch(myItems.length); 

for (Item item : myItems) { 
    //doStuff launches a Thread that calls latch.countDown() as it's final act 
    item.doStuff(latch); 
} 

latch.await(); //ignoring Exceptions for readability 

Answer 1

Su solución es más fácil de escalar. Thread.join() era una forma perfecta de resolver su problema antes de que se crearan CountdownLatch y los demás sincronizadores.

En términos de legibilidad, yo elegiría el enfoque CountdownLatch para unirme a cada hilo. Esto también le permite cambiar la implementación de Item para enviarlo a un servicio Ejecutor en lugar de usar Threads directamente.

Answer 2

El bloqueo de cuenta regresiva es preferido para iniciar simultáneamente todos los hilos al mismo tiempo.

Answer 3

Preferiría usar un Futuro (fácil si está utilizando un ExecutorService). Luego, después de enviar todas las tareas, aguarde a que todas terminen.

Collection<Future<Void>> futures = new ArrayList<Future<Void>>(myItems.length()); 
for (Runnable item : myItems) { 
    futures.add(executor.submit(item, null)); 

for (Future<Void> future : futures) 
    future.get(); //easy to add a timeout here 

El for-loop final se puede separar fácilmente en un método útil. Esto encapsula la sincronización y facilita agregar tiempos de espera.

También es más aplicable al caso general, donde los hilos de trabajo realmente necesitan devolver un resultado. (Si no le importa qué terminan los hilos de trabajo, ¿por qué necesita esperarlos?)