Warten bis Thread an einem Semaphore angekommen ist

[markusbischof]

Hallo,

ich bin zwar kein Java-Neuling, bräuchte aber dennoch etwas Unterstützung für mein Problem:

Ich möchte in meinem Programm einen Thread so lange anhalten, bis ein anderer an einem Semaphore angekommen ist. Der Code dazu sieht ungefähr folgendermaßen aus:

public static void main(String[] args) throws Exception
{
    final Semaphore s = new Semaphore(0);
    Thread t = new Thread(new Runnable()
    {
        public void run()
        {
             // dies soll der Punkt sein, an dem der Thread "fertig" ist
             s.tryAcquire();
                        
             // ...Programmlogik
        }
    });
    t.start();
	
    // dieses Konstrukt ist sehr unschön, wie geht das besser?
    while(!s.hasQueuedThreads())
    {
        Thread.sleep(1);
    }
}

Gerne würde ich Konstrukt mit dem Thread.Sleep(1) irgendwie besser hinkriegen, denn der wartende Thread soll "schnellstmöglich" weiterlaufen, sobald der andere Thread am Semaphore angekommen ist. Nur wir schafft man das ohne "busy waiting"?

Ich habe mir auch schon überlegt, den Hauptthread auf einem weiteren Semaphore warten zu lassen, den der andere Thread vor Erreichen der eigentlichen Semaphores setzt. Nur dann ist immer noch nicht 100% sicher, dass der gestartete Thread tatsächlich am Semaphore steht.

Freue mich über interessante Antworten!

Viele Grüße,
Markus

 

[SlaterB]

Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 11.6 Synchronisation über Warten und Benachrichtigen

 

[markusbischof]

Hallo,

erstmal Danke für die schnelle Antwort. Ich habe mir das Kapitel nochmal etwas genauer durchgesehen, aber für mein Szenario nicht das passende gefunden. Hast du vielleicht noch einen kleinen Hinweis, welches Synchronisationsobjekt das Richtige für mich sein könnte?

Mir ist klar, dass ich in irgendeiner Weise aus dem gestarteten Thread dem anderen mitteilen muss, dass der Thread nun "bereit" ist. Mach ich das z.B. über einen Semaphore, ist das aber nicht 100% das, was ich eigentlich will, weil ich immer noch nicht konkret an der Stelle bin, an der ich eigentlich sein will. Mein angedachter Code sähe folgendermaßen aus:

public static void main(String[] args) throws Exception
{
    final Semaphore s = new Semaphore(0);
    final Semaphore startSemaphore = new Semaphore(0);
    Thread t = new Thread(new Runnable()
    {
        public void run()
        {
             // dem Hauptthread mitteilen, dass wir nun "so gut wie fertig" sind
             startSemaphore.release();

             // dies soll der Punkt sein, an dem der Thread "fertig" ist
             try
             {
               s.acquire();
             }
             catch(Exception ex)
             {}
                   
             // ...Programmlogik
        }
    });
    t.start();
    
    // warten bis der neu gestartete Thread an seiner definierten Stelle ist (s.acquire())
    startSemaphore.acquire();

    // liefert das wirklich immer true?
    System.out.println("Neuer Thread fertig: "+s.hasQueuedThreads());
}

Das Problem das ich hier sehe ist, dass nach dem Setzen des "startSemaphore.release()" aus dem neuen Thread der Hauptthread das acquire bekommt und nun das System.out.println "false" ausgeben könnte. Das passiert genau dann, wenn durch das Thread-Sheduling nach dem "release"-Aufruf direkt der Haupthread weiterläuft, ohne dass der gestartete Thread noch weiter Rechenzeit bekommt.

Ich hoffe ich kann zumindest einigermaßen erklären, was mein Problem ist! Manchmal ist es gar nicht so einfach, "genau" zu beschreiben, welches Problem man sieht/hat...

Grüße,
Markus

 

[SlaterB]

auf das Thread-Sheduling kannst du eh keinen Einfluss nehmen, davon sollte nichts in deinem Programm abhängen,
ansonsten unabhängig vom Semaphor:

der Hauptthread wartet an irgendeinem Monitor: wait(), der Thread t benachrichtigt den Hauptthread, wenn es soweit ist: notify()

wait()/ notify() sind im Buch erklärt bzw. andere modernere Mechanismen

11.6.3 Warten mit wait() und Aufwecken mit notify() Zur nächsten ÜberschriftZur vorigen Überschrift

Nachdem im vorigen Abschnitt der Weg mit den Java-5-Klassen und -Schnittstellen beschritten wurde, wollen wir uns abschließend mit den Möglichkeiten beschäftigen, die Java seit der Version 1.0 mitbringt.
[..]

 

[markusbischof]

Hm,

das habe ich soweit verstanden.

Ich denke ich werde es mit dem wait/notify umsetzen (bzw. mit der doppelten Semaphor-Lösung aus meinem zweiten Post), und im dem Hauptthread nach dem wait noch eine Schleife einbauen die blockiert bis der andere Thread tatsächlich im Semaphor steht. Das busy-waiting wird somit stark verkürzt.

Vielen Dank!