Question

Earlier I posted a problem about implementing wait and notify, but I wasn’t very clear, so here is a more specific question.

In the long code block below there is one wait and one notify. The notify is supposed to stop the wait and cause it to stop waiting. At the moment, i think the wait works, but the notify does not. Could someone explain why the notify doesn’t notify the wait? Thanks!

Note: the rest of the code works i’m only interested in these two specific parts.

import com.fmr.ipgt.email.*;
import java.io.File;
import java.io.IOException;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import javax.mail.MessagingException;

class MyQuery {
synchronized void qQuery() throws Exception {
    String query = ".z.k"; // The query that is used to query q; this can be changed here.
    int version = 0;
    c qConn = null;
    qConn = new c(Main.host,Main.port); // Connect to the q database
      while (Main.healthy) {
          Object o = qConn.k(query); // Query q
          version = c.t(o);
          if(!(version==0)) {
              System.out.println(version);
              System.out.println("database healthy");
              NewThread.suspendFlag = false;
              notify(); 
              break; // End the process if the database responds
          }
          }

       System.out.println("reaches loop end");
  }
}

class MyThread implements Runnable {
  MyQuery myResource;

  MyThread(String name, MyQuery so) {
    myResource = so;
    new Thread(this, name).start();
  }

  public void run() {

    try {
      myResource.qQuery(); // Begin a method to query q.
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

class NewThread implements Runnable {
       String name; // name of thread
       Thread t;
       static boolean suspendFlag;
    private int minutes;
       NewThread(int minutes) {
           this.minutes = minutes;
           System.out.println("reaches constructor");
          t = new Thread(this);
          suspendFlag = true;
          t.start(); // Start the thread
       }
       // This is the entry point for thread.
       public void run() {
          try {
             synchronized(this) {
                while(suspendFlag) {

                   System.out.println("reaches wait");
                   wait(minutes*60000);

                   System.out.println("reaches end");
                   if(suspendFlag) {
                       Main.setHealth(false);
                    Main.sendMessages(); // The database has not responded for the given time. Report that it is unhealthy.
                   }
                   break;
                }
              }
          } catch (InterruptedException e) {
             System.out.println(name + " interrupted.");
          } catch (MessagingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
       }
    }

public class Main {

private static String[] recipients;
private static String subject = "Database Failure";
private static String message = "The database has failed or is in a hung state";
private static String from;
static String host;
static int port;
private static String emails;
private static int minutes;
static boolean healthy = true;
public static void main(String args[]) throws Exception {

    // Import information from the configuration file
      SAXBuilder builder = new SAXBuilder();
      File xmlFile = new File("/export/home/rhadm/file.xml"); // Note: The directory for the configuration file may need to be changed

      try {

        Document document = (Document) builder.build(xmlFile);
        Element rootNode = document.getRootElement();
        List list = rootNode.getChildren("parameters");
           Element node = (Element) list.get(0);

          host = node.getChildText("host");
           port = Integer.parseInt(node.getChildText("port"));
           emails = node.getChildText("emails");
           String delims = "[ ]+";
           recipients = emails.split(delims); // parse email list
           minutes = Integer.parseInt(node.getChildText("time"));
           from = node.getChildText("from");

      } catch (IOException io) {
        System.out.println(io.getMessage());
      } catch (JDOMException jdomex) {
        System.out.println(jdomex.getMessage());
      }
    MyQuery unhealthy = new MyQuery();
    NewThread ob1 = new NewThread(minutes);
    new MyThread("MyThread", unhealthy);  // Create new Thread


  }
  public static void setHealth(boolean health){
      System.out.println("database unhealthy");
    healthy  = health;  
  }

  public static void sendMessages() throws MessagingException {
        System.out.println("sending emails");
      FCAPMailSender.postMail(recipients,subject,message,from);
  }
  }

Answer 1

You are synchronizing on different objects. The notify will only effect objects synchronized-waiting on the same object & instance.

The waiting thread is synchronized & waiting on a NewThread while the notifying thread is doing so on a MyQuery instance

Have a shared object.

private final Object LOCK = new Object();
synchronized(LOCK){
  LOCK.wait();
}
synchronized(LOCK){
  LOCK.notify();
}