线程通信问题--生产者和消费者问题

一、问题引入：首先实现一个线程通信的实例，使用两个线程交替打印输出100以内的数字。

代码实现如下：

package com.baozi.exer;

public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }

}

class Number implements Runnable {
    private int number = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                notify();
                if (number <= 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

wait()、notify()、notifyAll()三个方法的介绍：

• wait()：某个对象调用wait()方法能让当前线程阻塞，并且当前线程还会释放所拥有的锁
• 调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；
• 调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；

备注：wait()、notify()、notifyAll()三个方法都是定义在同步代码块或者是同步方法中的，并且都是同步代码块或者同步方法的同步监视器进行调用这些方法。

二、为什么这三个方法都是定义在Object类中，而不是定义在Thread类中？

　　这三个方法都是定义在Object类中，因为我们知道，这三个方法都是存在于同步代码块或者同步方法中的，而且必须是该代码块的同步监视器进行调用这些方法，那么因为同步监视器是任何一个类的对象都可以充当，如果要保证任何一个类的对象都有这三个方法并且能进行调用，就只能把这三个方法方法所有类的父类--Object类中。

三、Sleep()方法和Wait()方法有什么异同？

相同点：一旦执行这两个方法，都会使当前线程进入阻塞状态

不同点：

• 两个方法声明的位置不同：sleep()方法是在Thread类中声明为一个静态方法，而wait()方法是定义在Object类中
• 两个方法的使用位置不同：sleep可以在任何位置使用，但是wait()方法只能在同步代码块或者是同步方法中使用
• sleep()方法执行完之后虽然会使当前线程进入阻塞状态，但是并不会使当前线程释放所拥有的锁，但是wait()方法不但会让当前的线程进入阻塞状态，还会是当前的线程释放拥有的锁。

四、经典的线程通信问题：生产者和消费者问题

package com.baozi.java2;

/**
 * 线程通信的应用：生产者消费者问题
 * 分析：
 * 1、是否是多线程的问题：是多线程问题，至少要包含生产者线程和消费者线程
 * 2、是否有共享数据的问题？有共享数据：产品（这里只用了一个产品的个数进行表示）
 * 3、如何解决线程的安全问题：使用同步机制
 * 4、如何解决线程之间的通信问题？wait()和notify()/notifyAll()
 */
//店员类
class Clerk {
    private int productNumber = 0;
    //生产产品
    public synchronized void produceProductor() {
        if(productNumber<20){
            productNumber++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productNumber+"个产品");
          //只要生产者生产出至少一个产品，就能唤醒消费者线程进行消费
            notify();
        }else{
            //当产品的个数大于20的时候，生产者线程就要进入阻塞状态，等待消费者线程消费产品之后在进行生产
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumerProduct() {
        if(productNumber>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productNumber+"个产品");
            productNumber--;
            //只要消费者线程进行了一次消费，就能唤醒生产者线程进行生产
            notify();
        }else{
            //当产品的个数小于等于0的时候，消费者线程就要进入阻塞状态，等待生产者生产出产品之后在进行消费
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//生产者类
class Productor extends Thread {
    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":开始生产产品.....");
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProductor();
        }
    }
}

//消费者类
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(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumerProduct();
        }
    }
}
//测试类，创建一个生产者生产商品，创建一个消费者消费产品
public class ProductorTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Thread p1 = new Productor(clerk);
        p1.setName("生产者1");
        Thread c1 = new Consumer(clerk);
        c1.setName("消费者1");
        p1.start();
        c1.start();
    }
}