¿Cuál es el equivalente de Java de ManualResetEvent?

Question

¿Cuál es el equivalente de Java de ManualResetEvent?

Answer 1

Lo más cercano que conozco es el Semaphore. Simplemente úselo con un "permiso" de 1, y aquire/release será prácticamente el mismo que el ManualResetEvent.

Un semáforo inicializado a uno, y que se utiliza tal que sólo tiene al más un permiso disponible, puede servir como un bloqueo de exclusión mutua. Esto es más conocido como semáforo binario , porque solo tiene dos estados : un permiso disponible o cero permisos disponibles. Cuando se usa de esta manera , el semáforo binario tiene la propiedad (a diferencia de muchos de bloqueo implementaciones), que el "bloqueo" puede ser liberado de un hilo que no sea el propietario (como semáforos no tienen noción de propiedad). Esto puede ser útil en algunos contextos especializados , como la recuperación de bloqueo .

Answer 2

Basado en:

ManualResetEvent permite hilos para comunicarse entre sí por señalización. Normalmente, esta comunicación se refiere a una tarea que debe completar un subproceso antes de que puedan continuar otros subprocesos .

desde aquí:

http://msdn.microsoft.com/en-us/library/system.threading.manualresetevent.aspx

que posiblemente desea mirar las barreras en el paquete de concurrencia de Java - específicamente CyclicBarrier creo:

http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/CyclicBarrier.html

Bloquea un número fijo de hilos hasta que se haya producido un evento en particular. Todos los hilos deben unirse en un punto de barrera.

Answer 3

Pruebe CountDownLatch con el recuento de uno.

CountDownLatch startSignal = new CountDownLatch(1); 

Answer 4

creo que el quid de la ERM es .NET afinidad hilo y su capacidad para permitir que todos los hilos esperando pasar cuando se llama Set. Encontré que el uso del Semáforo funciona bien. Sin embargo, si tengo 10 o 15 hilos esperando, entonces me encuentro con otro problema. Específicamente, ocurre cuando se llama a Set. En .Net, se lanzan todos los hilos en espera. Usar un semphore no libera todo. Así que lo envolví en una clase. NOTA: Estoy muy familiarizado con el enhebrado .NET. Soy relativamente nuevo en el enhebrado y la sincronización de Java. Sin embargo, estoy dispuesto a saltar y obtener algunos comentarios reales. Aquí está mi aplicación con la hipótesis de que un principiante de Java haría:

public class ManualEvent { 
private final static int MAX_WAIT = 1000; 
private final static String TAG = "ManualEvent"; 
private Semaphore semaphore = new Semaphore(MAX_WAIT, false); 

private volatile boolean signaled = false; 
public ManualEvent(boolean signaled) { 
    this.signaled = signaled; 
    if (!signaled) { 
     semaphore.drainPermits(); 
    } 
} 

public boolean WaitOne() { 
    return WaitOne(Long.MAX_VALUE); 
} 

private volatile int count = 0; 
public boolean WaitOne(long millis) { 
    boolean bRc = true; 
    if (signaled) 
     return true; 

    try { 
     ++count; 
     if (count > MAX_WAIT) { 
      Log.w(TAG, "More requests than waits: " + String.valueOf(count)); 
     } 

     Log.d(TAG, "ManualEvent WaitOne Entered"); 
     bRc = semaphore.tryAcquire(millis, TimeUnit.MILLISECONDS); 
     Log.d(TAG, "ManualEvent WaitOne=" + String.valueOf(bRc)); 
    } 
    catch (InterruptedException e) { 
     bRc = false; 
    } 
    finally { 
     --count; 
    } 

    Log.d(TAG, "ManualEvent WaitOne Exit"); 
    return bRc; 
} 

public void Set() { 
    Log.d(TAG, "ManualEvent Set"); 
    signaled = true; 
    semaphore.release(MAX_WAIT); 
} 

public void Reset() { 
    signaled = false; 
    //stop any new requests 
    int count = semaphore.drainPermits(); 
    Log.d(TAG, "ManualEvent Reset: Permits drained=" + String.valueOf(count)); 
} 

}

También tenga en cuenta que estoy básicamente apostando a que no hay más de 1000 solicitudes en espera para un lanzamiento en un momento dado.Al liberar y adquirir en lotes, estoy intentando liberar cualquier hilo de espera. Tenga en cuenta que la llamada a WaitOne está trabajando 1 permiso a la vez.

Answer 5

class ManualResetEvent { 

    private final Object monitor = new Object(); 
    private volatile boolean open = false; 

    public ManualResetEvent(boolean open) { 
    this.open = open; 
    } 

    public void waitOne() throws InterruptedException { 
    synchronized (monitor) { 
     while (open==false) { 
      monitor.wait(); 
     } 
    } 
    } 

    public boolean waitOne(long milliseconds) throws InterruptedException { 
    synchronized (monitor) { 
     if (open) 
     return true; 
     monitor.wait(milliseconds); 
     return open; 
    } 
    } 

    public void set() {//open start 
    synchronized (monitor) { 
     open = true; 
     monitor.notifyAll(); 
    } 
    } 

    public void reset() {//close stop 
    open = false; 
    } 
}