package test;
public class NotifyTest {
    private String flag[] = { "true" };

    class NotifyThread extends Thread {
        public NotifyThread(String name) {
            super(name);
        }

        public void run() {
            try {
                sleep(1000);// 推迟3秒钟通知
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (flag) {
                flag[0] = "false";
                
                // notify并不会立即唤醒wait的进程，
                // 必须等待当前同步块执行完毕！
                //flag.notify();
                
                flag.notifyAll();
                

//                try {
//                    sleep(20000);// 推迟3秒钟通知
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                
            }
        }
    };

    class WaitThread extends Thread {
        public WaitThread(String name) {
            super(name);
        }

        public void run() {
            synchronized (flag) {
                while (flag[0] != "false") {
                    System.out.println(getName() + " begin waiting!");
                    long waitTime = System.currentTimeMillis();

                    try {
                        flag.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    waitTime = System.currentTimeMillis() - waitTime;
                    System.out.println("wait time :" + waitTime);
                }
                System.out.println(getName() + " end waiting!");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("Main Thread Run!");
        NotifyTest test = new NotifyTest();
        NotifyThread notifyThread = test.new NotifyThread("notify01");
        WaitThread waitThread01 = test.new WaitThread("waiter01");
        WaitThread waitThread02 = test.new WaitThread("waiter02");
        WaitThread waitThread03 = test.new WaitThread("waiter03");
        WaitThread waitThread04 = test.new WaitThread("waiter04");
        WaitThread waitThread05 = test.new WaitThread("waiter05");
        notifyThread.start();
        waitThread01.start();
        waitThread02.start();
        waitThread03.start();
        waitThread04.start();
        waitThread05.start();
    }
}


打印：

Main Thread Run!
waiter02 begin waiting!
waiter01 begin waiting!
waiter03 begin waiting!
waiter04 begin waiting!
waiter05 begin waiting!
wait time :999
waiter05 end waiting!
wait time :999
waiter04 end waiting!
wait time :999
waiter03 end waiting!
wait time :1000
waiter01 end waiting!
wait time :1000
waiter02 end waiting!

void java.lang.Thread.interrupt()
Interrupts this thread.

Unless the current thread is interrupting itself, which is always permitted, the checkAccess method of this thread is invoked, which may cause a SecurityException to be thrown.

If this thread is blocked in an invocation of the wait(), wait(long), or wait(long, int) methods of the Object class, or of the join(), join(long), join(long, int), sleep(long), or sleep(long, int), methods of this class, then its interrupt status will be cleared and it will receive an InterruptedException.

If this thread is blocked in an I/O operation upon an interruptible channel then the channel will be closed, the thread‘s interrupt status will be set, and the thread will receive a java.nio.channels.ClosedByInterruptException.

If this thread is blocked in a java.nio.channels.Selector then the thread‘s interrupt status will be set and it will return immediately from the selection operation, possibly with a non-zero value, just as if the selector‘s wakeup method were invoked.

If none of the previous conditions hold then this thread‘s interrupt status will be set.

Interrupting a thread that is not alive need not have any effect.