Wie kann ich einen wartenden Thread benachrichtigen, ohne den Haupt-Thread anzuhalten?

Question

Ich möchte, dass mein Haupt-Thread bei einem bestimmten Ereignis einen anderen Thread benachrichtigt, aber ohne sich selbst anzuhalten. Der andere Thread ist eine Endlosschleife, und ich brauche es nach jeder Iteration zu warten, bis der Hauptthread es wieder aufwacht.

Dies scheint das Warte-/Benachrichtigungsmuster auszuschließen, da es den Thread unterbricht, der notify auf dem gemeinsam genutzten Monitor aufruft. Ich habe auch über CyclicBarrier nachgedacht, aber ich möchte nicht, dass der Hauptthread Barrier.await aufruft, und warte, bis der andere Thread Barrier.aait aufruft, weil es lange dauern kann ...

Irgendeine Idee? Vielen Dank !

Answer 1

machen die wartenden Thread wie folgt aus:

class MyThread extends Thread() { 
private volatile boolean go; 

public void wakeUpBuddy() { 
    go=true; 
    synchronized(this) { 
     notify(); 
    } 
} 

public void run() { 

    while(!interrupted()) { 
    // some work before wait 

    synchronized(this) { 
     while(!go) { 
     wait(); 
     } 
     go = false; 
    } 

    // some work after release 
    } 
} 


} 

dann von dem Haupt-Thread Anruf auf die Instanz von MyThread.wakeUpBuddy(); und es wird einen Durchlauf gehen und auf einen anderen Anruf warten.

Answer 2

Wie wäre es mit Observer Muster?

import java.util.Observable; 
import java.util.Observer; 
import java.util.concurrent.TimeUnit; 

public class Main extends Observable { 

    public static void main(String... args) { 

     final MyThread t = new MyThread(); 

     final Main m = new Main(); 
     m.addObserver(t); 

     // start the thread 
     t.start(); 

     for (int i = 0; i < 25; i++) { 
      if (i % 5 == 0) { // event received? 
       m.setChanged(); 
       m.notifyObservers(i); 
      } 

      try { 
       Thread.sleep(TimeUnit.SECONDS.toMillis(1)); 
      } catch (Exception ex) { 

      } 
     } 

    } 

} 

class MyThread extends Thread implements Observer { 

    private boolean wait = true; 

    @Override 
    public void run() { 

     while (true) { 

      while (wait) { 
       try { 
        Thread.sleep(TimeUnit.SECONDS.toMillis(1)); 
       } catch (InterruptedException ex) { 
        // interrupted 
       } 
      } 

      System.out.println("I am invoked .."); 
      wait = true; 
     } 

    } 

    @Override 
    public void update(Observable o, Object arg) { 
     System.out.println("Update received .. " + arg); 
     wait = false; 
    } 

}