生产者-消费者问题(进程同步问题)

最近在学线程,在加上操作系统也在学线程,于是乎有了这篇文章

问题描述:

一群生产者进程在生成产品,并将这些产品提供给消费者进程去消费. 他们之间有一个公共的缓冲区用来存放产品,当产品为空时消费者不能消费,当产品为满时生产者不能生产

CPP实现

• 利用mutex 互斥量 来对缓存区的操作进行加锁

#include<iostream>
#include<mutex>
#include<chrono>
#include<thread>
using namespace std;

int n=10;				// 缓存区大小
int in=0,out = 0;		// 生产指针,消费指针
int full = 0,empty=10;  // 空与满
int buffer[10];			// 缓存区
mutex mtx;				// 互斥量

/**
*	生产者函数
*/	 
void producer(){
	do{
		while(full==n);	
		this_thread::sleep_for(chrono::seconds(1));			
		mtx.lock();		
		buffer[in] = 1;	
		in = (in+1)%n;
		cout << "生产者生产:" << in << endl; 
		empty--;
		full++;
		mtx.unlock();
	}while(true);
}
/**
*	消费者函数
*/
void consumer(){
	do{
		while(empty==10);
		mtx.lock();
		buffer[out] = 0;
		out=(out+1)%n;
		cout <<"消费者消费:" << out << endl; 
		empty++;
		full--;
		mtx.unlock();
		this_thread::sleep_for(chrono::seconds(2));
	}while(true);
}
int main(){
	
	thread t1{producer};
	thread t2{consumer};
	
	t1.join();
	t2.join();
	return 0;
} 

Java实现

用Storage对象模拟缓存区,关键代码如下

/**
*	存储类
*/
public class Storage {
    private Product[] products = new Product[10];
    private int top = 0;

    public synchronized void push(Product product){
        while(top == products.length){
            try{
                System.out.println("producer wait");
                wait();									//缓冲区满,无法生产,则阻塞
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

        products[top++] = product;
        System.out.println(Thread.currentThread().getName()+" 生产了 "+product);
        System.out.println("producer notifyAll");
        notifyAll();									//生产出新的产品,唤醒消费者进程
    }

    public synchronized Product pop(){
        while (top==0){
            try{
                System.out.println("consumer wait");;
                wait();									//缓冲区空,无法消费,阻塞
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        --top;
        Product p = new Product(products[top].getId(),products[top].getName());
        products[top] = null;
        System.out.println(Thread.currentThread().getName()+ " 消费了 "+p);
        System.out.println("consumer notifyAll");
        notifyAll();									//消费了产品,唤醒生产者
        return p;
    }
}

public class Producer implements Runnable{
    private Storage storage;

    public Producer(Storage storage){
        this.storage = storage;
    }

    @Override
    public void run() {
        int i=0;
        Random r = new Random();
        while(i<10){
            i++;
            Product product = new Product(i,"电话"+r.nextInt(100));
            storage.push(product);
        }
    }
}

public class Consumer implements Runnable{
    private Storage storage;

    public Consumer(Storage storage){
        this.storage = storage;
    }

    @Override
    public void run() {
        int i=0;
        while (i<10){
            i++;
            storage.pop();
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}