一.生产者消费者问题?
1.生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
2.解决办法:
要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常采用进程间通信的方法解决该问题，常用的方法有信号灯法等。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。该问题也能被推广到多个生产者和消费者的情形。
二.编码实现生产者消费者问题
1.先上结果图：我定义了三个生产者分别时张飞，赵云还有关羽，两个消费者分别时曹操还有刘备.
先上结果图是为了说明：多线程说白了就是对cpu资源的抢夺,谁抢到了就可以执行自己的方法.
2.生产者消费者实现步骤:
(1).因为生产者跟消费者共享一块区域,这里我将这块区域定义为“仓库”。
(2).仓库是有容量上限的,当数量达到上限后,生产者不允许继续生产产品.当前线程进入等待状态,等待其他线程唤醒。
(3).当仓库没有产品时，消费者不允许继续消费，当前线程进入等待状态,等待其他线程唤醒。
3.代码的实现：
(1).生产者跟消费者之间消费的是产品，所有先定义一个产品类:
public class Product {
//定义产品的唯一ID
int id;
//定义构造方法初始化产品id
public Product(int id) {
this.id=id;
// TODO Auto-generated constructor stub
}
}
(2).定义一个仓库用来存放产品.
public class Repertory {
//定义一个集合类用于存放产品.规定仓库的最大容量为10.
public LinkedList<Product> store=new LinkedList<Product>();
public LinkedList<Product> getStore() {
return store;
}
public void setStore(LinkedList<Product> store) {
this.store = store;
}
/* 生产者方法
* push()方法用于存放产品.
* 参数含义:第一个是产品对象
* 第二个是线程名称，用来显示是谁生产的产品.
* 使用synchronized关键字修饰方法的目的：
* 最多只能有一个线程同时访问该方法.
* 主要是为了防止多个线程访问该方法的时候，将参数数据进行的覆盖，从而发生出错.
*/
public synchronized void push(Product p,String threadName)
{
/* 仓库容量最大值为10,当容量等于10的时候进入等待状态.等待其他线程唤醒
* 唤醒后继续循环，等到仓库的存量小于10时，跳出循环继续向下执行准备生产产品.
*/
while(store.size()==10){
try {
//打印日志
System.out.println(threadName+"报告:仓库已满--->进入等待状态--->呼叫老大过来消费");
//因为仓库容量已满，无法继续生产，进入等待状态，等待其他线程唤醒.
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//唤醒所有等待线程
this.notifyAll();
//将产品添加到仓库中.
store.addLast(p);
//打印生产日志
System.out.println(threadName+"生产了:"+p.id+"号产品"+" "+"当前库存来:"+store.size());
try {
//为了方便观察结果,每次生产完后等待0.1秒.
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/* 消费者方法
* pop()方法用于存放产品.
* 参数含义:线程名称，用来显示是谁生产的产品.
* 使用synchronized关键字修饰方法的目的：
* 最多只能有一个线程同时访问该方法.
* 主要是为了防止多个线程访问该方法的时候，将参数数据进行的覆盖，从而发生出错.
*/
public synchronized void pop(String threadName){
/* 当仓库没有存货时,消费者需要进行等待.等待其他线程来唤醒
* 唤醒后继续循环，等到仓库的存量大于0时，跳出循环继续向下执行准备消费产品.
*/
while(store.size()==0)
{
try {
//打印日志
System.out.println(threadName+"下命令:仓库已空--->进入等待状态--->命令小弟赶快生产");
//因为仓库容量已空，无法继续消费，进入等待状态，等待其他线程唤醒.
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//唤醒所有等待线程
this.notifyAll();
//store.removeFirst()方法将产品从仓库中移出.
//打印日志
System.out.println(threadName+"消费了:"+store.removeFirst().id+"号产品"+" "+"当前库存来:"+store.size());
try {
//为了方便观察结果,每次生产完后等待1秒.
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
(3).定义生产者
public class Producer implements Runnable {
//定义一个静态变量来记录产品号数.确保每一个产品的唯一性.
public static Integer count=0;
//定义仓库
Repertory repertory=null;
//构造方法初始化repertory(仓库)
public Producer(Repertory repertory) {
this.repertory=repertory;
}
/* run()方法因为该方法中存在非原子性操作count++;
* 当多个线程同时访问时会发生count++的多次操作,导致出错
* 为该方法添加同步错做,确保每一次只能有一个生产者进入该模块。
* 这样就能保证count++这个操作的安全性.
*/
@Override
public void run() {
while (true) {
synchronized(Producer.class){
count++;
Product product=new Product(count);
repertory.push(product,Thread.currentThread().getName());
}
}
}
}
(4).定义一个消费者
public class Consumer implements Runnable {
//定义仓库
Repertory repertory=null;
//构造方法初始化repertory(仓库)
public Consumer(Repertory repertory) {
this.repertory=repertory;
}
//实现run()方法,并将当前的线程名称传入.
@Override
public void run() {
while(true){
repertory.pop(Thread.currentThread().getName());
}
}
}
(5).测试类
public class TestDemo {
public static void main(String[] args) {
//定义一个仓库,消费者和生产者都使用这一个仓库
Repertory repertory=new Repertory();
//定义三个生产者(p1,p2,p3)
Producer p1=new Producer(repertory);
Producer p2=new Producer(repertory);
Producer p3=new Producer(repertory);
//定义两个消费者(c1,c2)
Consumer c1=new Consumer(repertory);
Consumer c2=new Consumer(repertory);
//定义5个线程(t1,t2,t3,t4,t5)
Thread t1=new Thread(p1,"张飞");
Thread t2=new Thread(p2,"赵云");
Thread t3=new Thread(p3,"关羽");
Thread t4=new Thread(c1,"刘备");
Thread t5=new Thread(c2,"曹操");
//因为关羽跟赵云的生产积极性高,所以把他们的线程优先级调高一点
t2.setPriority(10);
t3.setPriority(10);
//启动线程
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
三.总结:
生产者消费者问题我也是弄了好几天才略有头绪,弄完了就把自己的认识贴了出来,欢迎各位指点