进程模拟生产者-消费者问题

这里我只是简单实现了这个经典问题的思路与想打，并且书写的程序也是能正确的运行出合理的答案，希望今后还可以改进程序使之更加完善

思路描述：

1.生产者进程：产生一个数据，当要送入缓冲区的时候，要检查缓冲区是否已满，若未满，则可将数据送入缓冲区，并通知消费者进程，否则等待

2.对于消费者进程：当它去取数据的时候，要看缓冲区中是否有数据可以去取，若有则取走一个数据，并通知生产者进程，否则等待

3.缓冲区是一个临界资源，因此，诸进程对缓冲区的操作程序是一个共享临界区，所以这里还有一个互斥问题

public class question_test {

	public static void main(String[] args) {
		
		//主方法
		Mutex mtex = new Mutex();
		mtex.setFull(0); //设置缓存区最大存放10个产品
		mtex.setMutex(false); //缓存区默认状态为未使用
		
		//创建消费者进程
		Customer c1 = new Customer(mtex);
		Customer c2 = new Customer(mtex);
		Customer c3 = new Customer(mtex);
		Customer c4 = new Customer(mtex);
		Customer c5 = new Customer(mtex);
		Customer c6 = new Customer(mtex);
		Customer c7 = new Customer(mtex);
		
		//创建生产者进程
		Producer p1 = new Producer(mtex);
		Producer p2 = new Producer(mtex);
		Producer p3 = new Producer(mtex);
		Producer p4 = new Producer(mtex);
		Producer p5 = new Producer(mtex);
		Producer p6 = new Producer(mtex);
		Producer p7 = new Producer(mtex);
		
		//启动消费者，生产者进程
		p1.start();
		p2.start();
		p3.start();
		p4.start();
		p5.start();
		p6.start();
		p7.start();
		c1.start();
		c2.start();
		c3.start();
		c4.start();
		c5.start();
		c6.start();
		c7.start();
	}

}

class Mutex {
	//判断互斥变量，是否可以使用临界资源（缓冲区）
	private boolean mutex;
	private int full;

	public int getFull() {
		return full;
	}

	public void setFull(int full) {
		this.full = full;
	}

	public boolean isMutex() {
		return mutex;
	}

	public void setMutex(boolean mutex) {
		this.mutex = mutex;
	}
}

class Customer extends Thread{
	Customer(Mutex mtx){
		this.mtx = mtx;
	}
	public Mutex mtx;
	
	//申请缓冲区
	public void p_cus(){
			//判断缓冲区中是否有资源可以去取
			if(mtx.getFull()>0){
				//判断缓冲区是否被使用
				if(mtx.isMutex()){
					//这里没有写等待，若是加入等待可用sleep（）方法
					//我在这里直接是打印出相关消息
					System.out.println("生产者正在向缓冲区中放产品，消费者无法使用缓冲区！！！");
				}else{
					mtx.setMutex(true);
					mtx.setFull(mtx.getFull()-1);
					System.out.println("消费者消费1件产品，当前库存："+mtx.getFull());
				}
			}else{
				System.out.println("缓存区无产品！！！");
			}
		}	
	
	//释放缓冲区使用权
	public void v_cusmex(){
		mtx.setMutex(false);
	}
	
	//重写run方法，调用申请与释放缓冲区函数
	public void run(){
			p_cus();
			v_cusmex();
	}
	
}

class Producer extends Thread{
	Producer(Mutex mtx){
		this.mtx = mtx;
	}
	//访问缓存区互斥判断当为true表示正在访问缓存区。
	public Mutex mtx;
	
	//生产一个产品；
	public void p_pro(){
			//这里默认缓冲区最多存放30个资源，同消费者一样进行相应的判断
			if(mtx.getFull()<30&&mtx.getFull()>=0){
				if(mtx.isMutex()){
					//只是简单地输出相关状态信息，如果想让进城等待加入sleep函数
					System.out.println("消费者正在从缓冲区中取产品，生产者无法使用缓冲区！！！");
				}else{
					mtx.setMutex(true);
					mtx.setFull(mtx.getFull()+1);
					System.out.println("产品已经生产放入缓冲区，当前库存："+mtx.getFull());
				}
			}else{
				System.out.println("仓库已满！暂时不能生产！");
			}
	}
	
	public void v_promex(){
		mtx.setMutex(false);
	}
	
	//重写run方法，调用申请与释放缓冲区函数
	public void run(){
			p_pro();
			v_promex();
	}	
}

这就是模拟出来的效果，希望可以帮助到你理解这个经典的进程调度问题！