等待并通过实施Runnable和扩展线程示例进行通知

Question

I am implementing the logic to understand wait and notify works i found something which i am not able to analyze when i am extending the class with thread then wait and notify is working as expected but when i am implementing the runnable interface then output will be differ

public class AdderThread extends Thread {

int total;

@Override
public void run() {

    synchronized (this) {
        for (int i = 0; i < 1000; i++) {
            total += i;
        }

        notify();
    }

}





public class WaitNotify {

public static void main(String[] args) {

    AdderThread addrTh = new AdderThread();
    addrTh.start();
    // -1243309312

    System.out.println("Total without Wait() " + addrTh.total);


}

}

When Implementing Runnable gives me correct answer means it is waitng for the thread to complete the task but when i am using extends thread it is giving me answer as 0 ie it is not waiting for thread to complete the task.

public class WaitNotify {

public static void main(String[] args) {

    AdderThread addrTh = new AdderThread();
    addrTh.start();
    // -1243309312

    System.out.println("Total Before Wait " + addrTh.total);
    synchronized (addrTh) {

        try {
            System.out.println("Waiting for Sum...");
            addrTh.wait();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("Total " + addrTh.total);
    }

}

}

Answer 1

Your new thread can call notify() before the main thread calls `wait()." The wait() call will wait forever in that case because notify() does not do anything at all if some other thread is not already waiting for it.

wait() and notify() are low-level operations that are meant to be used in a very specific way:

See Java wait() does not get waked by notify() for more information.

---

The difference between the case where you implement Runnable and the case where you extend Thread is due to the fact that this refers to an anonymous inner class in the first case, and it refers to the Thread object in the latter case.

That matters because the thread machinery uses wait() and notify() for its own purposes. So if your wait() call comes too late to be waked up by the notify() call in your code, it may still get waked up by a notify() in library code (eg, when the thread terminates). That won't happen when you implement Runnable because there's no reason why the library would ever notify it.