线程间通信

——引入
线程间进行通信后大大提高了CPU的利用率，也会使程序员对各线程的处理过程进行有效把控与监督。
Java在Object类中提供了wait()、notify()、notifyAll()等方法用于解决线程间的通信问题，由于Java中所有类都是Object类的子类或间接子类，因此任何类的实例对象都可以直接使用这些方法。
线程间通信的常用方法：
1>void wait()：使当前线程放弃同步锁并进入等待，直到其它线程进入此同步锁，并调用notify()或notifyAll()方法唤醒该线程为止。
2>void notify()：唤醒此同步锁上等待的第一个调用wait()方法的线程。
3>void notifyAll()：唤醒此同步锁上调用wait()方法的所有线程。
需要注意的是：wait()、notify()和notifyAll()这三个方法的调用者都应该是同步锁对象，如果这三个方法的调用者不是同步锁对象，Java虚拟机就会抛出IllegalMonitorStataException异常。
一.wait/notify机制的原理
前提：拥有相同锁的线程才可以实现.wait/notify机制。
wait()方法是Object类的方法，它的作用是使当前执行wait()方法的线程等待，在wait()所在的代码行处暂停执行，并释放锁，直到接到通知或被中断为止。在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步代码块中调用wait()方法。通过通知机制使某个线程继续执行wait()方法后面的代码时，对线程的选择是按照wait()方法的顺序确定的，并需要重新获得锁。如果调用wait()方法时没有持有适当的锁，则抛出IllegalMonitorStataException，它是RuntimeException的一个子类，因此不需要try-catch语句捕获异常。
notify()方法要在同步方法或同步代码块中调用，即在调用前，线程必须获得锁，如果调用notify()时没有持有适当的锁，则会抛出IllegalMonitorStataException。该方法用来通知那些可能等待该锁的其它线程，如果有多个线程等待，则按照执行wait()方法的顺序对处于wait状态的线程发出一次通知notify，并使该线程重新获得锁。需要说明的是，执行notify()方法后，当前线程不会马上释放该锁，呈wait状态的线程也不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized同步区域后，当前线程才会释放锁，而呈wait状态的现成才可以获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕后，它会释放该对象锁，此时如果没有再次使用notify语句，那么其它呈wait状态的线程因为没有得到通知，会继续处于wait状态。
总结:wait()方法使线程暂停运行，而notify()方法通知暂停的线程继续运行。
例1：简单应用

import java.util.Scanner;

public class Demo0 {
        private static Object object=new Object();
        public static class MyThread extends Thread {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                }
                synchronized (object) {
                    try {
                        object.wait();//哪个线程调用wait，哪个线程放入等待集中
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int i = 100; i < 110; i++) {
                    System.out.println(i);
                }
            }
        }
        public static void main(String[] args) {
        Thread t=new MyThread();
        t.start();
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入点东西");
        sc.nextLine();
        synchronized (object){
            object.notify();//notify只唤醒一个，但是不保证是哪一个
        }
    }
}

运行结果：

例2：

class MyThread1 extends Thread{
    private Object lock;

    public MyThread1(Object lock){
        super();
        this.lock=lock;
    }

    @Override
    public void run() {
        try{
            synchronized (lock){
                System.out.println("开始 wait time="+System.currentTimeMillis());
                lock.wait();
                System.out.println("结束 wait time="+System.currentTimeMillis());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
class MyThread2 extends Thread{
    private Object lock;

    public MyThread2(Object lock){
        super();
        this.lock=lock;
    }

    @Override
    public void run() {
            synchronized (lock){
                System.out.println("开始 notify wait time="+System.currentTimeMillis());
                lock.notify();
                System.out.println("结束 notify wait time="+System.currentTimeMillis());
            }
    }
}
public class Test {
    public static void main(String[] args) {
        try{
            Object lock=new Object();

            MyThread1 t1=new MyThread1(lock);
            t1.start();

            Thread.sleep(3000);

            MyThread2 t2=new MyThread2(lock);
            t2.start();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行结果：

解释：
从程序运行结果来看，3s后线程被通知(notify)唤醒。
必须执行完notify()方法所在的同步synchronized代码块后才释放锁。