Java 多线程 ：入门（2）- 线程间协作：挂起当前线程（wait）与通知其他线程继续执行（notify\ notifyAll）

public class TestNotifyByFlag {
    private String flag[] = {"true"};class NotifyThread extends Thread{
        public NotifyThread(String name){
            super(name);
        }
        public void run(){            
            synchronized(flag){
                flag[0] = "false";
                flag.notifyAll();
                System.out.println("Message1: NotifyThread仍然持有锁，因为代码段还未执行完毕。");
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("Message2: 这一句在synchronized代码段之外，此时锁已经释放了，所以这一句几时能运行就不一定了。");
        }
    }
    
    class WaitThread extends Thread{
        public WaitThread(String name){
            super(name);
        }
        
        public void run(){
            synchronized(flag){
                while(flag[0] != "false"){
                    System.out.println(getName()+" beginWaiting!");
                    long startToWait = System.currentTimeMillis();
                    try{
                        flag.wait();
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    long waitTime = System.currentTimeMillis() - startToWait;
                    System.out.println("waitTime: "+waitTime);
                }
                System.out.println(getName()+" end waiting!");
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("Main Thread Run!");
        TestNotifyByFlag test = new TestNotifyByFlag();
        NotifyThread notify = test.new NotifyThread("notifty01");
        WaitThread wait01 = test.new WaitThread("wait01");
        WaitThread wait02 = test.new WaitThread("wait02");
        WaitThread wait03 = test.new WaitThread("wait03");
        wait01.start();
        wait02.start();
        wait03.start();    
        try{
            Thread.sleep(5000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        notify.start();
    }
}

Main Thread Run!
wait01 beginWaiting!
wait02 beginWaiting!
wait03 beginWaiting!
Message1: NotifyThread仍然持有锁，因为代码段还未执行完毕.
waitTime: 4999
wait03 end waiting!
waitTime: 4999
wait02 end waiting!
waitTime: 5000
wait01 end waiting!
Message2: 这一句在synchronized代码段之外，此时锁已经释放了.

...(若flag是String)对在同步块中对flag进行了赋值操作，使得flag引用的对象改变，这时候再调用notify方法时，因为没有控制权所以抛出异常。
我们可以改进一下，将flag改成一个JavaBean，然后更改它的属性不会影响到flag的引用。我们这里改成数组来试试，也可以达到同样的效果...

public class TestNotifyByInterruption {
...
    class Car{
        private boolean waxOn = false;
        public synchronized void waxed(){
            waxOn = true;
            notifyAll();
        }
        public synchronized void buffed(){
            waxOn = false;
            notifyAll();
        }
        public synchronized void waitForWaxing() throws InterruptedException{
            while(waxOn == false){
                wait();
            }
        }
        public synchronized void waitForBuffing() throws InterruptedException{
            while(waxOn == true){
                wait();
            }
        }
    }
    
    class WaxOn implements Runnable{
        private Car car;
        public WaxOn(Car car){
            this.car = car;
        }
        public void run(){
            try{
                while(!Thread.interrupted()){
                    print("Wax On!");
                    TimeUnit.MILLISECONDS.sleep(500);
                    car.waxed();
                    car.waitForBuffing();
                }
            }catch(InterruptedException e){
                print("WaxOn Exiting via interrupt");
            }
            print("Ending WaxOn Task");
        }
    }
    
    class WaxOff implements Runnable{
        private Car car;
        public WaxOff(Car car){
            this.car = car;
        }
        public void run(){
            try{
                while(!Thread.interrupted()){
                    car.waitForWaxing();
                    print("Wax Off!");
                    TimeUnit.MILLISECONDS.sleep(500);
                    car.buffed();
                }
            }catch(InterruptedException e){
                print("WaxOff Exiting via interrupt");
            }
            print("Ending WaxOff Task");
        }
    }
    
    
    public static void main(String[] args) throws InterruptedException {
        TestNotifyByInterruption test = new TestNotifyByInterruption();
        Car car = test.new Car();
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(test.new WaxOff(car));
        exec.execute(test.new WaxOn(car));
        TimeUnit.MILLISECONDS.sleep(5000);
        exec.shutdownNow();
    }

}

Wax On!
Wax Off!
Wax On!
Wax Off!
Wax On!
Wax Off!
Wax On!
Wax Off!
Wax On!
Wax Off!
WaxOn Exiting via interrupt
WaxOff Exiting via interrupt
Ending WaxOff Task
Ending WaxOn Task

public class TestNotify {
class Obj{
        int num = 20;

        public int getNum() {
            return num;
        }

        public synchronized void setNum(int num) {
            System.out.println("setNum() started!");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.num = num;
            System.out.println("setNum() finished!");
        }
    }
    
    class TaskA implements Runnable{
        private Obj obj;
        public TaskA(Obj obj){
            this.obj = obj;
        }
        public void run(){
                System.out.println("TaskA: getNum():"+obj.num);
                System.out.println("TaskA: num:"+obj.num);
        }
    }
    
    
    class TaskB implements Runnable{
        private Obj obj;
        public TaskB(Obj obj){
            this.obj = obj;
        }
        public void run(){
                obj.setNum(35);
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        TestNotify test = new TestNotify();
        Obj obj = test.new Obj();
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(test.new TaskB(obj));
        exec.execute(test.new TaskB(obj));
        Thread.sleep(1000);
        exec.execute(test.new TaskA(obj));
    }
}

setNum() started!
TaskA: getNum():20
TaskA: num:20
setNum() finished!
setNum() started!
setNum() finished!