消费者与生产者的问题（java）--经典案列

淡淡的烟草味﹌ 2022-02-28 14:48 208阅读 0赞

消费者与生产者的问题是计算机中常见的问题，是在java多线程经典问题

# 1.java多线程实现 #

###  wait() / notify()方法 ###

wait() / nofity()方法是基类Object的两个方法：

*  wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。
 *  notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。

import java.util.LinkedList;
    
    public class produceAndCustomer {
    
    	//最大商品数
    	private final int MAX_LIST_SIZE = 100;
    	
    	//商品集合存放处，需要频繁的插入与删除，使用LinkedList。
    	private LinkedList<Object> itemList = new LinkedList<>();
    	
    	//生产者生产商品
    	//生产者在商品集合满时，不许生产
    	public void produce(String produceName) {
    		synchronized (itemList) {
    			while (itemList.size() == MAX_LIST_SIZE) {
    				System.out.println("厂库已满： 暂时不能执行生产任务!");
    				try {
    					//当商品集合长度等于最大长度，则生产者停止生产
    					itemList.wait();
    				} catch (InterruptedException e) {
    					System.out.println();
    					e.printStackTrace();
    				}
    			}
    			//生产未满足厂库总容量
    			//生产商品
    			itemList.add(new Object());
    			System.out.println("生产者生产了一个商品，厂库现容量为："+itemList.size());
    			//生产出商品，唤醒消费者消费
    			itemList.notifyAll();
    		}
    	}
    	
    	//消费者消费商品
    	//消费者在商品集合为空时，不许消费
    	public void customer(String customerName) {
    		
    		synchronized (itemList) {
    			while (itemList.size()==0){
    				System.out.println("厂库为空： 暂时不能执行消费任务!");
    				try {
    					//厂库为空时，消费者不能够消费，停止线程
    					itemList.wait();
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    			//厂库不为空，能够消费
    			itemList.removeFirst();
    			System.out.println("消费者消费了一个商品，厂库现容量为："+itemList.size());
    			//消费了商品，唤醒生产者生产
    			itemList.notifyAll();
    		}
    	}
    	
    	//属性的get和set操作
    	public LinkedList<Object> getItemList() {
    		return itemList;
    	}
    	public void setItemList(LinkedList<Object> itemList) {
    		this.itemList = itemList;
    	}
    	public int getMAX_LIST_SIZE() {
    		return MAX_LIST_SIZE;
    	}
    	
    }

测试方法：

public class Test {
    	//消费者与生产者的测试方法
    	public static void main(String[] args) {
    
    		produceAndCustomer produceAndCustomer = new produceAndCustomer();
    		//定义8个生产者,执行8次生产
    		for (int i = 0; i < 8; i++) {
    			int num = i;
    			//使用匿名内部类的方式去实现
    			new Thread(new Runnable() {
    				public void run() {
    					produceAndCustomer.produce(String.format("生产者%d", num));
    				}
    			}).start();
    		}
    
    		//定义4个消费者,执行4次消费
    		for(int i=1;i<4;i++)
            {
    			int num = i;
    			//使用匿名内部类的方式去实现
    			new Thread(new Runnable() {
    				public void run() {
    					produceAndCustomer.customer(String.format("生产者%d", num));
    				}
    			}).start();
            }
    	}
    
    }

3.执行结果

生产者生产了一个商品，厂库现容量为：1
    消费者消费了一个商品，厂库现容量为：0
    生产者生产了一个商品，厂库现容量为：1
    生产者生产了一个商品，厂库现容量为：2
    生产者生产了一个商品，厂库现容量为：3
    生产者生产了一个商品，厂库现容量为：4
    消费者消费了一个商品，厂库现容量为：3
    消费者消费了一个商品，厂库现容量为：2
    生产者生产了一个商品，厂库现容量为：3
    生产者生产了一个商品，厂库现容量为：4
    生产者生产了一个商品，厂库现容量为：5

还有另外一种锁的方式

*  await() / signal()方法

代码类似于上述方式，是wait()，和notify()方法的一种变形。小伙伴们可以自己尝试一下