在调用wait和notify之后，我尝试从主线程加入两个线程

Question

Firstly, I try to define a class that contains 2 synchronized methods, the first one contains a wait() calling, and the second contains notify() calling.

 class Xa {
 public synchronized void printX() {
    try {
        wait();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    System.out.println("XXX");
}

public synchronized void notifyX() {
    System.out.println("111");
    notify();
}
}

Then I try to make two threads in the main, the first one call the printX() method of an object of the Xa class, and the second one call the notifyX() method of the same object, and finally the main thread join the two threads.

And I repeat this scenario with a for loop

public class TryQ {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    Thread t1 = null;
    Thread t2 = null;
    for(int i=1 ; i<=100; i++) {
        Xa x = new Xa();

        t1 = new Thread() {
            @Override
            public void run() {
                x.printX();
            }
        };

        t2 = new Thread() {
            @Override
            public void run() {
                x.notifyX();
            }
        };

        t1.start();
        t2.start();

        try {
            t1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            t2.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }       
}
}

The problem is, without joining, both the first and the second thread, print 100 times exactly, but when I try to join them by the main thread, I have maximum 2 or 3 lines of output... and the program is still running!

Why?

Answer 1

The problem exists whether you use join or not.

The problem is, if t2 executes notifyX first,

public synchronized void notifyX() {
    System.out.println("111");
    notify();
}

then t1 calls printX , t1 will get block forever!

public synchronized void printX() {
    try {
        wait();   <--- since t2 has finished, t1 will get stuck here!
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    System.out.println("XXX");
}

The difference is:

• without join , though the first t1 is stuck, the main thread will create a new t1 and run.
• with join , since the first t1 is stuck, the join will block the main thread, so there won't be next generation.