Was ist Java entspricht ManualResetEvent?

Was ist Java entspricht ManualResetEvent ?

Der nächste, den ich kenne, ist der Semaphor . Verwenden Sie es einfach mit einer “Permit” -Zählung von 1, und Aquire / Release entspricht in etwa dem, was Sie von ManualResetEvent wissen.

Ein Semaphor, der auf Eins initialisiert wurde und der so verwendet wird, dass er nur höchstens eine Erlaubnis hat, kann als eine gegenseitige Ausschlusssperre dienen. Dies wird häufiger als binärer Semaphor bezeichnet, da er nur zwei Zustände hat: eine Erlaubnis verfügbar oder Nullgenehmigungen verfügbar. Wenn der binäre Semaphor auf diese Weise verwendet wird, hat er die Eigenschaft (im Gegensatz zu vielen Lock-Implementierungen), dass die “Sperre” von einem anderen Thread als dem Eigentümer freigegeben werden kann (da Semaphore keine Eigentumsrechte haben). Dies kann in einigen speziellen Kontexten hilfreich sein, beispielsweise bei der Deadlock-Wiederherstellung.

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

Versuchen Sie CountDownLatch mit der Anzahl von eins.

 CountDownLatch startSignal = new CountDownLatch(1); 

Beyogen auf:

Mit ManualResetEvent können Threads über Signalisierung miteinander kommunizieren. Typischerweise betrifft diese Kommunikation eine Aufgabe, die ein Thread abschließen muss, bevor andere Threads fortfahren können.

von hier:

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

Vielleicht möchten Sie die Barrieren im Java-Concurrency-Paket betrachten – speziell CyclicBarrier glaube ich:

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

Es blockiert eine feste Anzahl von Threads, bis ein bestimmtes Ereignis aufgetreten ist. Alle Fäden müssen an einem Sperrpunkt zusammenkommen .

Ich glaube, der core des .NET MRE ist die Thread-Affinität und seine Fähigkeit, alle wartenden Threads durchlaufen zu lassen, wenn Set aufgerufen wird. Ich fand die Verwendung des Semaphore gut funktioniert. Wenn jedoch 10 oder 15 Threads warten, stoße ich auf ein anderes Problem. Insbesondere tritt es auf, wenn Set aufgerufen wird. In .Net werden alle wartenden Threads freigegeben. Die Verwendung einer Semphore gibt nicht alle frei. Also habe ich es in einer class eingepackt. Hinweis: Ich kenne .NET-Threading sehr gut. Ich bin relativ neu in Java Threading und Synchronisation. Nichtsdestotrotz bin ich bereit, einzugreifen und echtes Feedback zu bekommen. Hier ist meine Implementierung mit Annahmen, die ein Java-Neuling machen würde:

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

}

Beachten Sie auch, dass ich im Grunde wette, dass es nicht mehr als 1000 Anfragen gibt, die zu einem bestimmten Zeitpunkt auf eine Veröffentlichung warten. Durch Loslassen und Sammeln in Batches versuche ich alle wartenden Threads freizugeben. Beachten Sie, dass der Aufruf von WaitOne immer nur 1 Erlaubnis erlaubt.