Problem with wait() / notify()

[James Hodgkiss]

I'm having a problem with my wait / notify code. I understand pretty much how it all works, but the problem is that notify() is being called before wait() and I'm not sure the best way to fix it.

Rather, than post my entire code, I've created this little application which demonstrates the problem.

package threadtest;

public class ThreadTest extends Thread {

    public static void main(String[] args) {
        ThreadTest tt = new ThreadTest();
        tt.start();

        //pause so run() method reaches the wait() instruction
        try {
            Thread.sleep(1000);
        }
        catch(Throwable e) {   
        }

        System.out.println("Do something...");
        tt.doSomethingAndRepeat();
    }
    
    public synchronized void run() {
        System.out.println("running...");
        while (true) {
            try {
                System.out.println("wait...");
                wait();
            }
            catch(Throwable e) {
                e.printStackTrace();
            }
            System.out.println("Do something again..."); //this output should be shown over and over again...
            doSomethingAndRepeat(); //...however, the problem is that this line results in notify() being called before wait() is called.
        }
    }
    
    private synchronized void doSomethingAndRepeat() {
        System.out.println("doing it...");
        try {
            Thread.sleep(2000);
        }
        catch(Throwable e) {   
        }
        System.out.println("...done it");
        
        System.out.println("notify...");
        notify();
    }
   
}

The associated output is:

running...
wait...
Do something...
doing it...
...done it
notify...
Do something again...
doing it...
...done it
notify...
wait...

I can see why the problem happens, but is there an elegant way to solve it?

Cheers,
James

PS - Why I'm here, can anyone suggest a more elegant solution than "Thread.sleep(1000);" ?

[Matthew Brown]

Don't you need two loops in two separate threads? At the moment, other than the first call to doSomethingAndRepeat in the main method, you've got the calls to wait and notify in the same thread. Which means the thread is waiting for itself.

This probably isn't what you wanted, but here's a similar example where two threads take it in turns.

public class ThreadTest extends Thread {
    private final static Object sync = new Object();

    public ThreadTest(String name) {
        super(name);
    }

    public static void main(String[] args) {
        Thread threadA = new ThreadTest("A");
        Thread threadB = new ThreadTest("B");

        threadA.start();
        threadB.start();

        try {
            Thread.sleep(1000); // give threads time to reach waiting state
        } catch (InterruptedException ex) {}

        // Wake one up
        synchronized(sync) {
            sync.notify();
        }
    }


    @Override
    public void run() {
        System.out.format("Thread %s running...\n", getName());

        while (true) {
            synchronized(sync) {
                System.out.format("Thread %s waiting\n", getName());
                try {
                    sync.wait();
                }
                catch (InterruptedException ex) {}
            }

            System.out.format("Thread %s woken up, doing something...\n", getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {}
            System.out.format("Thread %s finished, notifying\n", getName());

            synchronized(sync) {
                sync.notify();
            }
        }
    }
}

[James Hodgkiss]

Thanks for the reply. I decided to go for a less elegant polling solution in the end. Cheers, James.