线程的通信

一、线程通信方法

1）wait() 与 notify() 和 notifyAll()
①wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
②notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
③notifyAll ()：唤醒正在排队等待资源的所有线程结束等待。

2）这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。

3）因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

1.wait方法

1）在当前线程中调用方法： 对象名.wait()
2）使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
3）调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
4）调用此方法后，当前线程将释放对象监控权 ，然后进入等待
5）在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

2.notify()/notifyAll()

1）在当前线程中调用方法： 对象名.notify()
2）功能：唤醒等待该对象监控权的一个/所有线程。
3）调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

二、代码示例

class Communication implements Runnable {
	int i = 1;
	public void run() {
		while (true) {
			synchronized (this) {
				notify(); //唤醒
				if (i <= 100) {
					System.out.println(Thread.currentThread().getName() + 
					":" + i++);
				} else
				break;
				try {
					wait(); //阻塞
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

三、经典例题：生产者/消费者问题

1）生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通
知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如
果店中有产品了再通知消费者来取走产品。
2）这里可能出现两个问题：
①生产者比消费者快时，消费者会漏掉一些数据没有取到。
②消费者比生产者快时，消费者会取相同的数据。

代码如下（示例）：

class Clerk{
    private int productCount = 0;
    public synchronized void produceProduct() {
        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName()
                    + "：开始生产第" + productCount + "个产品");
            notify();
        }else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumeProduct() {
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName()
                    + "开始消费第" + productCount + "个产品");
            productCount--;
            notify();
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{ //生产者
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：开始生产产品...");
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}
class Consumer extends Thread{ //消费者
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：开始消费产品...");
        while (true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        Consumer c1 = new Consumer(clerk);
        Consumer c2 = new Consumer(clerk);
        p1.setName("生产者1");
        c1.setName("消费者1");
        p1.start();
        c1.start();
        c2.start();
    }
}