cómo utilizar notificar y esperar

Question

¿Puede esperar/notificarse para utilizar en una secuencia? Quiero decir que tengo un oyente y en el momento en que se llama a ese oyente, quiero habilitar un hilo para que haga su trabajo. ¿Cómo podría hacerlo?

ACTUALIZACIÓN: Mis datos están escritos en una base de datos ... y se escriben cada vez que se llama al oyente. Ahora el hilo que he creado lee esos datos y los envía a alguna parte .... Siguiente ... Obtengo otros datos y hago lo mismo ... El otro hilo necesita saber cuál fue el último dato que lo leyó para que pueda comenzar a leer desde donde se fue ...

Echa un vistazo aquí : using wait and notify within one thread Así es como mi problema parece like.Thx

Tengo el siguiente:

synchronized (syncToken) 
{ 
    try { 
     syncToken.wait(); 

    } catch (InterruptedException e) { 
     e.printStackTrace(); 
    } 
} 
System.out.println("MyThread: " + s); 

en MyThread .... así que cuando lo haga

MyThread t = new MyThread(syncToken); 
t.start(); 

puse mi hilo en espera ... sí?

Y cuando hago esto:

syncToken.notify(); 

me sale mi hilo de nuevo en marcha .... pero la ejecución de la siguiente línea es la que después de esperar()?

Quiero decir esto: System.out.println("MyThread: " + s); ????

Cuando u notificar a un thred hace él continúa su ejecución con la línea después de esperar() ??? Thx

Answer 1

El siguiente es un ejemplo sencillo de concurrencia entre dos hilos diferentes. En el ejemplo, el hilo principal inicia un hilo MyThread y cada 3 segundos establece un dato en la instancia MyThread y luego MyThread lo imprime. La idea es tener un objeto sincronizado que wait en él y notify en el extremo de la utilización de otros temas que puedan utilizarlo:

Test.java:

package stack; 

public class Test { 
    public static void main (String args[]) 
    { 
     Object syncToken = new Object(); 
     MyThread t = new MyThread(syncToken); 
     t.start(); 
     for (int i = 0; i < 10; i++) 
     { 
      try { 
       Thread.sleep(3000); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 
      synchronized(syncToken) 
      { 
       t.setText("Iteration " + i); 
       syncToken.notify(); 
      } 
     } 
    } 
} 

MyThread.java:

package stack; 

public class MyThread extends Thread{ 

    String s; 
    Object syncToken; 
    public MyThread(Object syncToken) 
    { 
     this.s = ""; 
     this.syncToken = syncToken; 
    } 

    public void run() 
    { 
     while(true) // you will need to set some condition if you want to stop the thread in a certain time... 
     { 
      synchronized (syncToken) 
      { 
       try { 
        syncToken.wait(); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 
      System.out.println("MyThread: " + s); 
     } 
    } 

    public void setText(String s) 
    { 
     this.s = s; 
    } 
} 

En este ejemplo, el hilo principal establece una cadena (cada 3 segundos) y el hilo MyThread lo imprime.

Adáptelo a sus necesidades, no debe ser demasiado difícil.

Answer 2

Tuve un problema similar. He creado un árbitro utilizado por dos hilos (en su caso puede ser oyentes hilo y el hilo de tareas): oyente:

arbiter.waitConsumer(); 
// prepare data 
arbiter.dataLoaded(); 

hilo tarea:

while(true){ 
    arbiter.waitProducer(); 
    // consume data 
    arbiter.dataConsumed(); 
} 

árbitro:

public class Arbiter { 
private boolean dataLoaded = false; 
public synchronized void waitProducer(){ 
    while(!dataLoaded){ 
     try { 
      wait(); 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } 
    } 
} 
public synchronized void waitConsumer(){ 
    while(dataLoaded){ 
     try { 
      wait(); 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } 
    } 
} 
public synchronized void dataLoaded(){ 
    dataLoaded = true; 
    notify(); 
}public synchronized void dataConsumed(){ 
    dataLoaded = false; 
    notify(); 
}} 

El oyente y la tarea se sincronizarán contra el monitor de árbitros.¿Probablemente puede llamar a la fila o tubería de su árbitro y almacenar la fecha para consumir en ella?