Re: wait and spurious wakeups

On 2007-11-27, apm35@student.open.ac.uk <apm35@student.open.ac.uk> wrote:


If you have control over all the code executed by thread 1 and thread 2,
you can control whether thread 1 interrupts thread 2. In a Java program
a thread can interrupt another if it has a reference to the other thread.
Here is an example program.

public class InterruptedExample implements Runnable {
  private static Object lock = new Object();
  private static boolean ready;
                                                                                
  public void run() {
    synchronized(lock) {
      try {
        ready = true;
        lock.notify();
        lock.wait();
        System.out.println("run returned from wait()");
      } catch(InterruptedException e) {
        System.out.println("run interrupted");
      }
    }
  }
                                                                                
  static public void main(String[] args) {
    new InterruptedExample().instanceMain(args);
  }
                                                                                
  public void instanceMain(String[] args) {
    Thread threadToInterrupt = new Thread(new InterruptedExample());
    threadToInterrupt.start();
    synchronized(lock) {
      try {
        if (!ready) {
          lock.wait();
          System.out.println("main returned from wait()");
        }
      } catch(InterruptedException e) {
        System.out.println("main interrupted");
      } finally {
        threadToInterrupt.interrupt();
      }
    }
  }
}

Because java.lang.Thread has a enumerate(Thread[]) class method, any
thread can get references to all the threads of the program and invoke
interrupt() on any threads.