生产者消费者实验报告.答案

南昌大学实验报告

学生姓名：倪焕学号：8000114018 专业班级：软件工程141班

实验类型：■验证□综合□设计□创新实验日期：2016.5.24 实验成绩：

一、实验项目名称

哲学家就餐问题

二、实验目的

利用PV操作解决生产者消费者问题

三、软硬件环境

软件：Visual Studio2010

硬件：PC机一台

四、实验内容结果

一、实现代码 3个生产者1个消费者，生产者会等待消费者

#include

#include

const unsigned short SIZE_OF_BUFFER = 10; //缓冲区长度

unsigned short ProductID = 0; //产品号

unsigned short ConsumeID = 0; //将被消耗的产品号

unsigned short in = 0; //产品进缓冲区时的缓冲区下标

unsigned short out = 0; //产品出缓冲区时的缓冲区下标

int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列

bool g_continue = true; //控制程序结束

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_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL); g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);

//调整下面的数值，可以发现，当生产者个数多于消费者个数时，

//生产速度快，生产者经常等待消费者；反之，消费者经常等待

const unsigned short PRODUCERS_COUNT = 3; //生产者的个数

const unsigned short CONSUMERS_COUNT = 1; //消费者的个数

//总的线程数

const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;

HANDLE hThreads[PRODUCERS_COUNT]; //各线程的handle

DWORD producerID[CONSUMERS_COUNT]; //生产者线程的标识符

DWORD consumerID[THREADS_COUNT]; //消费者线程的标识符

//创建生产者线程

for (int i=0;i

hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);

if (hThreads[i]==NULL) return -1;

}

//创建消费者线程

for (int i=0;i

hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]); if (hThreads[i]==NULL) return -1;

}

while(g_continue){

if(getchar()){ //按回车后终止程序运行

g_continue = false;

}

}

return 0;

}

//生产一个产品。简单模拟了一下，仅输出新产品的ID号

void Produce()

{

std::cerr << "Producing " << ++ProductID << " ... ";

std::cerr << "Succeed" << std::endl;

}

//把新生产的产品放入缓冲区

void Append()

{

std::cerr << "Appending a product ... ";

g_buffer[in] = ProductID;

in = (in+1)%SIZE_OF_BUFFER;

std::cerr << "Succeed" << std::endl;

//输出缓冲区当前的状态

for (int i=0;i

std::cout << i <<": " << g_buffer[i];

if (i==in) std::cout << " <-- 生产";

if (i==out) std::cout << " <-- 消费";

std::cout << std::endl;

}

}

//从缓冲区中取出一个产品

void Take()

{

std::cerr << "Taking a product ... ";

ConsumeID = g_buffer[out];

out = (out+1)%SIZE_OF_BUFFER;

std::cerr << "Succeed" << std::endl;

//输出缓冲区当前的状态

for (int i=0;i

std::cout << i <<": " << g_buffer[i];

if (i==in) std::cout << " <-- 生产";

if (i==out) std::cout << " <-- 消费";

std::cout << std::endl;

}

}

//消耗一个产品

void Consume()

{

std::cerr << "Consuming " << ConsumeID << " ... "; std::cerr << "Succeed" << std::endl;

}

//生产者

DWORD WINAPI Producer(LPVOID lpPara)

{

while(g_continue){

WaitForSingleObject(g_hFullSemaphore,INFINITE); WaitForSingleObject(g_hMutex,INFINITE);

Produce();

Append();

Sleep(1500);

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);

Take();

Consume();

Sleep(1500);

ReleaseMutex(g_hMutex);

ReleaseSemaphore(g_hFullSemaphore,1,NULL);

}

return 0;

}

二、实现代码一个生产者一个消费者

/* 用信号量解决生产者－消费者问题 */

#include

#define N 10

typedef int semaphore; /* 信号量是一种特殊的整型变量 */

semaphore mutex=1; /* 互斥访问 */

semaphore empty=N; /* 记录缓冲区中空的槽数 */

semaphore full=0; /* 记录缓冲区中满的槽数*/

semaphore buf[N]; /* 有N个槽数的缓冲区buf[N]，并实现循环缓冲队列 */ semaphore front=0, rear=0;

void p(semaphore *x) /* p操作 */

{

*x=(*x)-1;

}

void v(semaphore *y) /* v操作 */

{

*y=(*y)+1;

}

void produce_item(int *item_ptr)

{

/*printf("produce an item\n");*/

*item_ptr='m'; /* 'm' is "man满" */

}

void enter_item(int x)

{

front=(front+1)%N;

buf[front]=x;

printf("enter_item %c to buf[%d]\n", buf[front], front);

}

void remove_item(int *yy)

{

rear=(rear+1)%N;

printf("remove_item %c from buf[%d]", buf[rear], rear);

*yy=buf[rear];

buf[rear]='k'; /* 'k' is "kong空" */

printf(" so the buf[%d] changed to empty--%c\n", rear, buf[rear]); }

void consume_item(int y)

{

printf("cosume the item :the screem print %c\n", y);

}

void producer(void);

void consumer(void);

/* 生产者 */

void producer(void)

{

int item;

while(1){

produce_item(&item);

p(&empty); /* 递减空槽数 */

p(&mutex); /* 进入临界区 */

enter_item(item); /* 将一个新的数据项放入缓冲区 */

v(&mutex); /* 离开临界区 */

v(&full); /* 递增满槽数 */

if(full==N) /* 若缓冲区满的话，唤醒消费者进程 */

consumer();

}

}

/* 消费者 */

void consumer(void)

{

int get_item;

while(1){

p(&full); /* 递减满槽数 */

p(&mutex); /* 进入临界区 */

remove_item(&get_item); /* 从缓冲区中取走一个数据项 */

v(&mutex); /* 离开临界区 */

v(&empty); /* 递增空槽数 */

consume_item(get_item); /* 对数据项进行操作（消费）*/

if(empty==N) /* 若缓冲区全空的话，唤生产者进程 */

producer();

}

}

/* 调用生产者－消费者进程实现进程间同步 */ int main()

{

producer();

return 0;

}

五、实验体会

通过本次实验，对于生产者和消费者问题有了更加明确的理解，生产者和消费者共享一个商品缓存，互相唤醒，通过缓存区的满空来进行状态的判定，他们通过PV操作，进行交互同步工作。通过创建不断创建新的线程，来展现两者的问题。