在Java中使用notify时，线程和可运行之间有什么区别吗？

Question

When I try to do some test about notify() in Java, I found some confusion.

Here I have two thread b1 and b2, they have the reference to another thread a. In b1 and b2, they will call wait(). And in thread a, it will call notify(). As I know, it will call b1 or b2 to start again. It is true when I realize this using Runnable. But when I realize this using Thread, b1 and b2 both start again. Can any one explain this?

Here is the code.

Realized using Runnable:

Thread A:

public class threada implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        String name = Thread.currentThread().getName();
        System.out.println(name+" started");
        synchronized(this){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(name + "end");
            notify();
        }
    }
}

Thread B:

public class threadb implements Runnable{

    private threada ta;
    public threadb(threada a){
        ta = a;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        String name = Thread.currentThread().getName();
        System.out.println(name + " started");
        synchronized(ta){
            try {
                ta.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(name + "end");
        }
    }

}

Main:

public class threadmain {
    public static void main(String...args){
        threada a = new threada();

        threadb b1 = new threadb(a);
        threadb b2 = new threadb(a);

        new Thread(b1, "b1").start();
        new Thread(b2, "b2").start();

        new Thread(a, "a").start();
    }
}

The Result:

b1 started
a started
b2 started
aend
b1end

Realized using Thread:

Thread A:

public class ThreadA extends Thread{

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name+" started");
        synchronized(this){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(name + "end");
            notify();
        }
    }
}

Thread B:

public class ThreadB extends Thread{

    private ThreadA ta;
    public ThreadB(ThreadA a){
        ta = a;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
//      super.run();
        String name = Thread.currentThread().getName();
        System.out.println(name + " started");
        synchronized(ta){
            try {
                ta.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(name + "end");
        }
    }
}

Main :

public class ThreadMain {
    public static void main(String... args) throws InterruptedException {
        ThreadA a = new ThreadA();

        ThreadB b1 = new ThreadB(a);
        ThreadB b2 = new ThreadB(a);
        b1.setName("b1");
        b2.setName("b2");

        b1.start();
        b2.start();

        Thread.sleep(10);

        a.setName("a");
        a.start();
    }
}

The result:

b1 started
b2 started
a started
aend
b1end
b2end

Answer 1

Interestingly the the solution to your question is documented for Thread.join()

As a thread terminates the this.notifyAll method is invoked

So one of your threads was awoken by the notify() call and the other by the thread A ending and thus sending a notifyAll() on itself. So every time a thread dies everything waiting on it will awaken.

This didn't happen for the Runnable version as the wait was linked to the Runnable objects and not the Thread.

Answer 2

At any rate, you have to implement your threads in a way where if notifyAll() get called then there will be no race condition or any problems in your code such as deadlock

and as a rule of thumb, use notifyAll() instead of notify().

Answer 3

Your ThreadB does not have a reference to the ThreadA instance - you never initialize it. You must pass the ThreadA instance to the ThreadB instances, or if the main code has visibility of the field, you can set it directly.

Also, as per the javadocs:

• notify() notifies one randomly chosen waiter
• notifyAll() notifies all waiters

It seems you should be calling notifyAll() .

Answer 4

notify is a method on Object which is generally the same on all objects. You could use a plain Object or a String or List or byte[] and it would do the same thing. Note: if you are going to use notify, you generally use wait() instead of sleep() so the notify does something.