生产者与消费者线程之间的通信

题目：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处 取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图 生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通 知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如 果店中有产品了再通知消费者来取走产品。

1. 首先考虑：是否是多线程问题？当然是，并且有哪些线程呢？生产者线程，消费者线程 （这里的线程不止一个）；
2. 考虑是否存在有线程安全问题？线程安全首先考虑是否有共享数据。
3. 有线程的安全问题，我们解决方式用的是同步机制的方式。
4. 考虑是否存在线程通信？这个题目中有条件的限制所以说是存在线程通信的。

代码如下：

---

/***
 * 同过使用线程wait方法解决这个线程之间通信
 * 创建了两个线程 消费者线程方法 和生产者线程方法 通过这个店员 来实现他们之间的调度
 * 当开启线程之后，通过这个店员来实现调度，调用生产方法，和消费的方法，在生产方法和消费方法中
 * 通过线程同步机制，wait()方法 notify()方法实现线程的通信
 */

class Clerk{
    //对于店员来讲即使生产者还是消费者 这个店员不仅仅是店员还是一个调度者
    //店员充当一个调度者
    private int productcount=0;//初始化产品的数量
    public synchronized void productor() {//生产者方法负责生产 这里这个同步的方法 这时候的同步锁使我们下边所实例化的Clerk的对象这个对象是唯一的
        //负责生产
        if (productcount<20){
            productcount++;//先加加避免有0和没有20
            System.out.println(Thread.currentThread().getName()+":"+"开始生产第"+productcount+"个产品");
        }else {
            notify();//唤醒线程
            try {
                wait();//等待20个产品生产完毕后进入阻塞等待这个阻塞遇到notigy唤醒唤醒之后才可以消费
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public synchronized void Constumetor() {//消费的一个方法负责消费 同上是一个同步的方法
        //负责消费
        if (productcount>0){

            System.out.println(Thread.currentThread().getName()+":"+"开始消费第"+productcount+"个产品");
            productcount--;
        }else {
            notify();
            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(getName()+":"+"开始生产");
        while (true){
            try {
                sleep(10);//休眠10时间段
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.productor();//有一个生产者 调用店员去调度一个生产的方法 有一个客户调用账户 通过账户去调用存钱的方法
        }
    }
}
class Constumer extends Thread{//消费者
    private Clerk clerk;
    public Constumer(Clerk clerk){
        this.clerk=clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":"+"开始消费");
        while (true){
            try {
                sleep(20);//休眠20时间段
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.Constumetor();//有一个生产者 通过店员这个对象去调用一个生产的方法 有一个客户调用账户 通过账户去调用存钱的方法
        }
    }
}


public class Producttest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();//店员的一个实例对象 这个实例化的对象是唯一的可以充当 同步监视器（锁）
        Producer p = new Producer(clerk);//有参构造的实例化对象 参数类型是Clerk
        p.setName("生产者");//设置线程名
        Constumer c1 = new Constumer(clerk);
        c1.setName("消费者1");
        Constumer c2 = new Constumer(clerk);
        c2.setName("消费者2");
        p.start();//开启线程
        c2.start();

    }

}

执行结果：

线程的生命周期

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

eg:  AB两个线程的通信 线程A执行 然后线程B执行.

代码如下：

class commection implements Runnable{
private int count=1;

    public void run() {
        while (true){
        synchronized (this) {
            notify();

                if (count<=100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+count);
                    count++;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
        }

    }
}

public class commectionTest {
    public static void main(String[] args) {
        commection t = new commection();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.setName("线程A");
        t2.setName("线程B");
        t1.start();
        t2.start();

    }

执行结果：

小白的学习后的理解，如有不对多多包涵！