concurrencia de java: flag/event

Question

Estoy buscando una bandera no reajustable o una clase de evento en las clases de concurrencia de Java, algo que puedo usar para verificar si algo se hace y es seguro para los hilos. Idealmente algo como:

public interface Event 
{ 
    /** returns true if signal() has been called */ 
    public boolean hasOccurred(); 
    /** returns when signal() has been called */ 
    public void await(); 
    public void signal();   
} 

¿Ya existe algo como esto? Estoy teniendo un calambre cerebral tratando de recordar

Answer 1

Creo que se está buscando un CountDownLatch - en particular, instanciarlo con un recuento de 1.

A continuación, sus operaciones son las siguientes:

• hasOccurred: latch.getCount() == 0
• esperan: latch.await()
• señal de: latch.countDown()

Si quieres que algo se puede restablecer y utilizar repetidamente, a continuación, un CyclicBarrier puede haber más de lo que busca. Los CountDownLatches, una vez que se han activado, no se pueden restablecer.

Editar: Vale la pena señalar que el CountDownLatch es más fácilmente composable para una operación más grande que la interfaz Event que mencionó. Entonces, por ejemplo, si esperara a que terminaran 4 hilos de trabajo, podría otorgar a cada trabajador su propio evento/1-count-latch y esperar cada uno por turno. Sin embargo, es más limpio simplemente crear un solo CountDownLatch con un recuento de 4, y compartirlo entre todos los trabajadores (algo que no requiere cambios en la lógica del trabajador, y eso no se podía hacer simplemente con múltiples eventos más pequeños).)

Answer 2

¿Quieres decir Condition?

class BoundedBuffer { 
    final Lock lock = new ReentrantLock(); 
    final Condition notFull = lock.newCondition(); 
    final Condition notEmpty = lock.newCondition(); 

    final Object[] items = new Object[100]; 
    int putptr, takeptr, count; 

    public void put(Object x) throws InterruptedException { 
    lock.lock(); 
    try { 
     while (count == items.length) 
     notFull.await(); 
     items[putptr] = x; 
     if (++putptr == items.length) putptr = 0; 
     ++count; 
     notEmpty.signal(); 
    } finally { 
     lock.unlock(); 
    } 
    } 

    public Object take() throws InterruptedException { 
    lock.lock(); 
    try { 
     while (count == 0) 
     notEmpty.await(); 
     Object x = items[takeptr]; 
     if (++takeptr == items.length) takeptr = 0; 
     --count; 
     notFull.signal(); 
     return x; 
    } finally { 
     lock.unlock(); 
    } 
    } 
}