llamando a Object.notify() antes de Object.wait()

Question

Si no hay un subproceso en espera, utilizando Object.wait(), las llamadas a Object.notify() o Object.notifyAll() no tienen ningún efecto. Tengo un escenario en el que si llamo al Object.notify() cuando el conjunto de espera está vacío, una llamada posterior a Object.wait() no debe poner el hilo en espera. ¿Cómo se puede lograr esto? Los semáforos pueden ser una solución en la que puedo pensar. ¿Hay una solución más elegante?

Answer 1

Este tipo de escenario parece ser un ajuste perfecto para un Semaphore. Llame al Semaphore.release() en lugar de notify() y Semaphore.acquire() en lugar de esperar.

Answer 2

Utilice una bandera para indicar una notificación. Lea la bandera antes de ingresar a esperar y actúe en consecuencia.

boolean stopped = false; 

public void run(){ 
    synchronized(object){ 
     while(!stopped) 
     object.wait(); 
    } 

} 

public void stop(){ 
    synchronized(object){ 
    stopped=true; 
    object.notify(); 
    } 

} 

Answer 3

me gustaría utilizar Semaphore, CyclicBarrier o posiblemente CountDownLatch - lo que es una mejor opción para su escenario real. Creo que es una buena idea reutilizar las abstracciones existentes en lugar de utilizar los mecanismos de bajo nivel usted mismo, a menos que esos mecanismos le den exactamente el comportamiento que desea (que no lo hacen en este caso).

Answer 4

he implementado como este

Tema A:

req.run(); 
synchronized (req) { 
        try { 
         req.wait(3000); 
         rawResponse = eq.ReturnXML; 
         logger.info("[" + refID + "] Response recieved: " + rawResponse); 
         responseRecieved = true; 
         req.notify(); 
        } catch (InterruptedException ex) { 
         logger.error("Error waiting on req", ex); 
        } 
       } 

Tema B:

synchronized (req) { 
     while (!responseRecieved) { 
      try { 
       req.wait(3000); 
      } catch (InterruptedException ex) { 
       logger.error("Error waiting on req while trying to get state", ex); 
      } 
     } 
    } 

Tema A hace la solicitud y espera una respuesta, mientras tanto Tema B es solo esperando la respuesta. Si una respuesta ya ha llegado, no espera.