多线程——线程交互

在实际功能中，会存在一些线程交互的情况。比如：一个线程执行某个操作，当操作的对象到达某种状态时，会等待其他线程来执行。

下面代码的功能是，一个线程对一个数字执行减少方法，当减到1时，等待增加线程操作。

public class Thread_interactive extends Thread {
    public static void main(String[] args) {
        //初始化并赋值
        operation op = new operation();
        op.Num=100;
        //减少线程
        Thread t1 = new Thread() {
            public void run() {
                while (true) {
                    try {
                        op.Reduce();
                        //等待是为了让减少操作执行的更快点，不然一边减少一边增加，数字不会减少到1的
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
        //增加线程
        Thread t2 = new Thread() {
            public void run() {
                while (true) {
                    try {
                        op.Add();
                        //多等一会，比减少线程慢一些
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t2.start();
    }
}

class operation {
    public int Num;
    public synchronized void Add() {
        Num++;
        System.out.println("Add当前数字是：" + Num);
        this.notify();
    }

    public synchronized void Reduce() throws InterruptedException {
        //如果Num减少到1就等待
        if (Num == 1) {
            this.wait();
        }
        Num--;
        System.out.println("Reduce当前数字是：" + Num);
    }
}

最后输出结果是：数字会不停减少，只到1就会增加。但是由于增加线程比减少线程慢，所以最后会一直在1、2之间徘徊。

wait、notify和notifyAll

wait:让占用了这个同步对象的线程，临时释放当前的占用，并且等待。 所以调用wait是有前提条件的，一定是在synchronized块里，否则就会出错。

notify:通知一个等待在这个同步对象上的线程，你可以苏醒过来了，有机会重新占用当前对象了。当这个线程执行完再次释放后，之前等待的线程会重新开始占用，并不会一直等下去。

notifyAll:通知所有的等待在这个同步对象上的线程，你们可以苏醒过来了，有机会重新占用当前对象了。