生产者—消费者模式的两种同步实现

原创 2016年06月01日 19:45:09

简要问题描述

一组生产者进程和一组消费者进程共享一个初始为空、大小为n的缓冲区,只有缓冲区没满时,生产者才能把消息放入到缓冲区,否则必须等待;只有缓冲区不空时,消费者才能从中取出消息,否则必须等待。由于缓冲区是临界资源,它只允许一个生产者放入消息,或者一个消费者从中取出消息。


生产者—消费者模式是非常经典的进程同步问题,我目前具体的两个简单实现为临界区(CriticalSection)同步和互斥(Mutex)同步,具体两者之间有何区别,可以参考负责任的链接,hhh~


Version1:

#include<windows.h>
#include<iostream>
#include<process.h>
#include<stdlib.h>
#include<time.h> 
using namespace std; 

const unsigned short Size = 10; // 缓冲区长度 
unsigned short curValue = 0; // 当前产品数

bool g_continue = true;  // 控制程序结束 :true(运行);false(结束) 

CRITICAL_SECTION g_cs; //临界区  
HANDLE g_hFullSemaphore; //当缓冲区满时迫使生产者等待
HANDLE g_hEmptySemaphore; //当缓冲区空时迫使消费者等待
DWORD WINAPI Producer(LPVOID); //生产者线程
DWORD WINAPI Consumer(LPVOID); //消费者线程

int main() {

    InitializeCriticalSection(&g_cs);  // 初始化临界区 
    g_hFullSemaphore = CreateSemaphore(NULL,Size-1,Size-1,NULL);
    g_hEmptySemaphore = CreateSemaphore(NULL,0,Size-1,NULL);
    
    
    //创建生产者线程 
    srand( (unsigned)time( NULL ) );
    int t1 = rand()%(Size+1);
    for (int i = 0; i < t1; i++) {
        HANDLE producer = CreateThread(NULL,0,Producer,NULL,0,NULL);	
	}
	//创建消费者线程 
	srand( (unsigned)time( NULL ) );
	int t2 = rand()%(Size+1);
	for (int i = 0; i < t2; i++) {
		HANDLE consumer = CreateThread(NULL,0,Consumer,NULL,0,NULL);
	}
    
    while(g_continue){
        if(getchar()) g_continue = false;   //按回车后终止程序运行
    }
    return 0;
}

void Produce() {
	if (curValue == 10) return;
	cout << "生产之前产品数为:" << curValue << endl;
	curValue++;
	cout << "Produce Succeed" << endl;
	cout << "当前产品数为:" << curValue << endl;
	cout << endl; 
}

void Consume() {
	if (curValue == 0) return;
	cout << "消费之前产品数为:" << curValue << endl;
	curValue--;
	cout << "Consume Succeed" << endl;
	cout << "当前产品数为:" << curValue << endl;
	cout << endl; 
}

//生产者
DWORD WINAPI Producer(LPVOID lpPara) {
    while(g_continue){
        WaitForSingleObject(g_hFullSemaphore,INFINITE);
        EnterCriticalSection(&g_cs);
        Produce();
        Sleep(1000);
        LeaveCriticalSection(&g_cs);
        ReleaseSemaphore(g_hEmptySemaphore,1,NULL);
    }
    return 0;
}

//消费者
DWORD WINAPI Consumer(LPVOID lpPara) {
    while(g_continue){
        WaitForSingleObject(g_hEmptySemaphore,INFINITE);
        EnterCriticalSection(&g_cs);
        Consume();
        Sleep(1000);
        LeaveCriticalSection(&g_cs); 
        ReleaseSemaphore(g_hFullSemaphore,1,NULL);
    }
    return 0;
}


Version2:

#include<windows.h>
#include<iostream>
#include<stdlib.h>
#include<time.h> 
using namespace std; 

const unsigned short Size = 10; // 缓冲区长度 
unsigned short curValue = 0; // 当前产品数

bool g_continue = true;  // 控制程序结束:true(运行);false(结束) 

HANDLE g_hMutex; //用于线程间的互斥
HANDLE g_hFullSemaphore; //当缓冲区满时迫使生产者等待
HANDLE g_hEmptySemaphore; //当缓冲区空时迫使消费者等待
DWORD WINAPI Producer(LPVOID); //生产者线程
DWORD WINAPI Consumer(LPVOID); //消费者线程

int main() {
	//创建各个互斥信号
    g_hMutex = CreateMutex(NULL,FALSE,NULL);
    g_hFullSemaphore = CreateSemaphore(NULL,Size-1,Size-1,NULL);
    g_hEmptySemaphore = CreateSemaphore(NULL,0,Size-1,NULL);
    
    //创建生产者线程 
    srand( (unsigned)time( NULL ) );
    int t1 = rand()%(Size+1);
    for (int i = 0; i < t1; i++) {
        HANDLE producer = CreateThread(NULL,0,Producer,NULL,0,NULL);	
	}
	//创建消费者线程 
	srand( (unsigned)time( NULL ) );
	int t2 = rand()%(Size+1);
	for (int i = 0; i < t2; i++) {
		HANDLE consumer = CreateThread(NULL,0,Consumer,NULL,0,NULL);
	}
    
    while(g_continue){
        if(getchar()) g_continue = false;   //按回车后终止程序运行
    }
    return 0;
}

void Produce() {
	if (curValue == 10) return;
	cout << "生产之前产品数为:" << curValue << endl;
	curValue++;
	cout << "Produce Succeed" << endl;
	cout << "当前产品数为:" << curValue << endl;
	cout << endl; 
}

void Consume() {
	if (curValue == 0) return;
	cout << "消费之前产品数为:" << curValue << endl;
	curValue--;
	cout << "Consume Succeed" << endl;
	cout << "当前产品数为:" << curValue << endl;
	cout << endl; 
}

//生产者
DWORD WINAPI Producer(LPVOID lpPara) {
    while(g_continue){
        WaitForSingleObject(g_hFullSemaphore,INFINITE);
        WaitForSingleObject(g_hMutex,INFINITE);
        Produce();
        Sleep(1000);
        ReleaseMutex(g_hMutex);
        ReleaseSemaphore(g_hEmptySemaphore,1,NULL);
    }
    return 0;
}

//消费者
DWORD WINAPI Consumer(LPVOID lpPara) {
    while(g_continue){
        WaitForSingleObject(g_hEmptySemaphore,INFINITE);
        WaitForSingleObject(g_hMutex,INFINITE);
        Consume();
        Sleep(1000);
        ReleaseMutex(g_hMutex);
        ReleaseSemaphore(g_hFullSemaphore,1,NULL);
    }
    return 0;
}


版权声明:本文为博主原创文章,未经博主允许不得转载。

生产者/消费者模式(阻塞队列) 一个经典的并发模型

生产消费者模式也是关于线程阻塞的问题,生产消费者模式是通过观察者模式来实现的。之前在编写一个通讯软件的时候用到了这种模式,通过维护一个BlockingQueue来完成Socket的消息发送...
  • canot
  • canot
  • 2016年05月30日 22:57
  • 5126

一个生产者一个消费者的无锁队列,多个生产者多个消费者的无锁队列

一个生产者一个消费者的无锁队列:http://www.codeproject.com/Articles/43510/Lock-Free-Single-Producer-Single-Consumer-...

生产者-消费者问题

作为操作系统最精华的部分,生产者消费者问题无疑是经典问题中的经典问题。 今天终于有空能好好研究一下这类问题了,不对之处还望大家指正。 首先,讲解经典的生产者消费者问题。 问题描述:一组生产者进程...

编写一个多线程程序,模拟2个生产者生产产品,3个消费者消费产品。2个生产者不停的生产商品3个消费者不停的消费产品。

粗略代码: class Resource { private String name; private int count = 0; private boolean flag = true; ...

一个生产者多个消费者问题

问题描述:一个缓冲区具有多个消费者和一个生产者,生产者往缓冲区中顺序写数据,每个消费者首先访问最新被写缓冲,然后顺序访问。...

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

生产者/消费者模式之深入理解

★简介    在实际的软件开发过程中,经常会碰到如下场景:某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类、函数、线程、进程等)。产生数据的模块,就形象地称为生产者...

生产者/消费者模式

[0]:概述 今天打算来介绍一下“生产者/消费者模式”,这玩意儿在很多开发领域都能派上用场。由于该模式很重要,打算分几个帖子来介绍。今天这个帖子先来扫盲一把。如果你对这个模式已经比较了解,请跳过本扫...
  • Kaiwii
  • Kaiwii
  • 2011年09月08日 09:42
  • 53755

并发设计模式之生产者-消费者模式

点击查看原文: http://www.joyhwong.com/2016/11/19/并发设计模式之生产者-消费者模式/ 生产者-消费者模式是一个经典的多线程设计模式,它为多线程间的协作提供了良...
  • liuchuo
  • liuchuo
  • 2016年11月25日 14:10
  • 972

生产者/消费者问题的多种Java实现方式

生产者/消费者问题的多种Java实现方式
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:生产者—消费者模式的两种同步实现
举报原因:
原因补充:

(最多只允许输入30个字)