Qual è l'equivalente di java di ManualResetEvent?

Question

Qual è l'equivalente di java di ManualResetEvent?

Answer 1

Il più vicino che conosco è il Semaphore. Usalo con un conteggio "permesso" pari a 1, e aquire/release sarà più o meno lo stesso di quello che sai dallo ManualResetEvent.

Un semaforo inizializzato a uno, e che viene utilizzato tale da presentare solo in massimo un permesso disponibile, può servire come serratura mutua esclusione. Questo è più comunemente noto come semaforo binario , perché ha solo due stati : un permesso disponibile o zero autorizzazioni disponibili. Se utilizzato in questo modo , il semaforo binario ha la proprietà (a differenza di molti Blocco implementazioni), che il "blocco" può essere rilasciato da un thread diverso dal proprietario (come semafori non hanno alcuna nozione di proprietà). Ciò può essere utile in alcuni contesti specializzati , ad esempio il ripristino deadlock .

Answer 2

base:

ManualResetEvent consente fili di comunicare tra loro mediante segnalazione. In genere, questa comunicazione riguarda un'attività che deve essere completata da prima che altri thread possano continuare.

da qui:

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

possibilmente desidera guardare le barriere nel pacchetto concorrenza Java - specificamente CyclicBarrier credo:

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

Blocca un numero fisso di thread fino a quando si verifica un evento particolare. Tutti i thread devono riunirsi in un punto di barriera .

Answer 3

Prova CountDownLatch con conteggio di uno.

CountDownLatch startSignal = new CountDownLatch(1); 

Answer 4

credo che il punto cruciale del .NET MRE è affinità di thread e la sua capacità di lasciare che tutti i thread in attesa passano attraverso quando Set viene chiamato. Ho trovato che l'uso del Semaphore funziona bene. Tuttavia, se ricevo 10 o 15 thread in attesa, mi imbatto in un altro problema. In particolare, si verifica quando viene chiamato Set. In .Net, tutti i thread in attesa vengono rilasciati. L'uso di un semphore non rilascia tutto. Così l'ho avvolto in una classe. NOTA: ho molta familiarità con .NET threading. Sono relativamente nuovo al threading e alla sincronizzazione di Java. Ciononostante, sono disposto a entrare e ottenere un feedback reale. Ecco la mia implementazione con assunzioni che un novizio Java renderebbe:

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

}

Si noti inoltre che sto praticamente scommettendo sul fatto che non c'è più di 1000 richieste in attesa di un rilascio in un dato momento.Rilasciando e acquisendo in lotti, sto tentando di rilasciare qualsiasi thread in attesa. Nota che la chiamata a WaitOne sta lavorando 1 permesso alla volta.

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; 
    } 
}