用多线程同步方法解决生产者消费者问题

用多线程同步方法解决生产者消费者问题
用多线程同步方法解决生产者消费者问题

武汉理工大学华夏学院课程设计报告书

课程名称:操作系统原理

题目:用多线程同步方法解决生产者-消费者问题系名:信息工程系

专业班级:软件1091班

姓名:千里锋行

学号: 10212809121

指导教师:赵传斌苏永红

2011年12月21日

课程设计任务书

学生姓名:千里锋行专业班级:软件1091

指导教师:苏永红工作单位:

设计题目:用多线程同步方法解决生产者-消费者问题

初始条件:

1.操作系统:Linux

2.程序设计语言:C语言

3.有界缓冲区内设有20个存储单元,其初值为0。放入/取出的数据项按增序设定为1-20这20个整型数。

要求完成的主要任务:

主要任务:

通过研究Linux的线程机制和信号量实现生产者消费者问题的并发控制。

有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1~20这20个整型数。

(1)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内

容、当前指针位置和生产者/消费者线程的标识符。

(2)生产者和消费者各有两个以上。

(3)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。

提示:

(1)有界缓冲区/连续存储区可用数组实现。

(2)编译命令可用:

gcc -lpthread -o 目标文件名源文件名

(3)多线程编程方法参见电子文档。

设计报告撰写格式要求:

1设计题目与要求 2 设计思想

3系统结构 4 数据结构的说明和模块的算法流程图

5 使用说明书(即用户手册):内容包含如何登录、退出、读、写等操作说明

6 运行结果和结果分析(其中包括实验的检查结果、程序的运行情况)

7 自我评价与总结

8 附录:程序清单,注意加注释(包括关键字、方法、变量等),在每个模块前加注释;时间安排

12月19日布置课程设计任务;分配题目后,查阅资料、准备程序;

12月 19 ~12月21 日上机调试程序、书写课程设计报告;

12月22 日提交课程设计报告及相关文档。

指导教师签字:2011年12月17日系主任签字: 2011年 12月 18日

一.设计题目与要求

1设计目的

通过研究Linux的线程机制和信号量实现生产者消费者问题(Producer-Consumer Problem)的并发控制。

2设计要求

1)为每个生产者/消费者产生一个线程,设计正确的同步算法

2)每个生产者/消费者对该存储区进行操作后,即时显示该存储区的全部内容、当前指针位置和生产者/消费者线程的自定义标识符。

3)生产者和消费者各有两个以上。

4)多个生产者/消费者之间须共享对存储区进行操作的函数代码。

二.设计思想

本次课设涉及到同步信号量和互斥信号量的应用,在这里我用线程的同步和互斥来实现。在同一个进程地址空间内执行的两个线程。生产者线程生产物品,然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品,然后释放缓冲区。当生产者线程生产物品时,如果没有空缓冲区可用,那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时,如果没有满的缓冲区,那么消费者线程将被阻塞,直到新的物品被生产出来。

在本问题中,共需要一个Mutex和两个Semaphore,其中Mutex是来用锁定临界区的,以解决对共享数据buffer的互斥访问问题(无论是对生成者还是对消费者);我们

共需要两个Semaphore,这是因为在本问题中共有两个稀缺资源.第一种是"非空"这种资源,是在消费者之间进行竞争的;第二种是"非满"这种资源,是在生产者之间进行竞争的.所以,一般来说,需要锁定临界区,就需要Mutex;有几种稀缺资源就需要几个Semaphore.

稀缺资源不一定是指被共享的资源,很多时候是指线程会被阻塞的条件(除了要进临界区被阻塞外).

在生产者消费者问题中,消费者会在缓冲区为空时被阻塞,所以"非空"是一种稀缺资源。需要设置一个信号量consumer_semaphore,初值设为0,生产者会在缓冲区为满时被阻塞,所以"非满"也是一种稀缺资源.需要设置一个信号量producer_semaphore,初值设为buffer的大小MAX_BUFFER。

三.系统结构

四.数据结构的说明和模块的算法流程图生产者方法:消费者方法:

五.使用说明书

1.宏的意义:

N:消费者或者生产者的数目

M:缓冲区的数目

2.程序的运行

a.打开linux的终端;

b.编译程序,输入命令

gcc –o dyb dyb.c –pthread ;

./dyb

3.显示结果

程序运行后不需要接受用户输入,直接显示运行结果。

六.运行结果和结果分析

[dj@softeem ~]$ ls

dyb.c 公共的模板视频图片文档下载音乐桌面[dj@softeem ~]$ gcc -o dyb dyb.c -pthread

[dj@softeem ~]$ ./dyb

producer1 in 0: 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

customer1 in 0: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 1: 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

customer2 in 1: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 2: 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

customer1 in 2: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 3: 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

customer2 in 3: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 4: 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

customer1 in 4: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 5: 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

customer2 in 5: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 6: 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0

customer1 in 6: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 7: 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

customer2 in 7: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 8: 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0

customer1 in 8: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 9: 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0

customer2 in 9: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 10: 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0

customer1 in 10: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 11: 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0

customer2 in 11: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 12: 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0

customer1 in 12: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 13: 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0

customer2 in 13: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 14: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0

customer1 in 14: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 15: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0

customer2 in 15: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 16: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0

customer1 in 16: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 17: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0

customer2 in 17: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer1 in 18: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0

customer1 in 18: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer2 in 19: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

customer2 in 19: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

对于此程序,有20个缓冲区,定义了两个生产者和两个消费者,生产者和消费者是模拟的现实中的生产与消费的关系,生产者生产产品时占用一个线程,消费者取一个产品时启用一个线程,生产产品和消费产品是利用锁来实现的。

但是最后还是有问题没能解决好,就是生产一个消费一个,缓冲区就没有利用好。

七.自我评价与总结

本次课程设计,听了邓君老师几天的讲解,见识到了他的年轻有为,也让自己对IT行业有了更深的向往。同时也加深了一些对多线程编程方法的理解,和使用信号量同步进/线程的技巧。

上课时看邓老师演示在linux下编写一个多人聊天的小程序,我在下面也跟住做。几次遇到了问题,老师都及时耐心的给我解决。最后我也跟着老师敲代码,虽然只是敲代码,不是自己的思想写出来的,但是万事开头难,我觉得只要我动手了,就成功了一半。在跟着老师做的过程中,我体会到了自己的不足,很多地方都不懂,但是我觉得在这个阶段对一些比较深的东西也不一定要处处都弄懂,有时候子要自己跟着做,会用,久而久之也会随着经验的加深而慢慢弄懂,这虽然是一种不求甚解的态度,但在初级编程中往往是很有用的。

本次课程设计的程序更具要求定义了20个缓冲区,基本上能顺利解决生产者消费者问题,但也存在很多不足之处。因为程序都是根据别人的来的,所以往往想加入自己的想法,比如随机函数解决随机的问题时遇到障碍,最后由于出现的错误太多,时间不够,所以只得放弃,只能在一些小的边边角角上稍加改动,试着去体会这个程序的思想。

七.附录

程序清单:

#include

#include

#include

#include

#include

#define N 2 // 消费者或者生产者的数目

#define M 20 // 缓冲数目

int in = 0; // 生产者放置产品的位置

int out = 0; // 消费者取产品的位置

int buff[M] = {0}; // 缓冲初始化为0,开始时没有产品

sem_t empty_sem; // 同步信号量,当满了时阻止生产者放产品sem_t full_sem; // 同步信号量,当没产品时阻止消费者消费pthread_mutex_t mutex; // 互斥信号量,一次只有一个线程访问缓冲int product_id = 0; //生产者id

int prochase_id = 0; //消费者id

/* 打印缓冲情况*/

void print()

{

int i;

for(i = 0; i < M; i++)

printf("%d ", buff[i]);

printf("\n");

}

/* 生产者方法*/

void *product()

{

int id = ++product_id;

while(1)

{

// 用sleep的数量可以调节生产和消费的速度,便于观察

sleep(1);

//sleep(1);

sem_wait(&empty_sem);

pthread_mutex_lock(&mutex);

in = in % M;

printf("producer%d in %d: ", id, in);

buff[in] = 1;

print();

++in;

pthread_mutex_unlock(&mutex);

sem_post(&full_sem);

}

}

/* 消费者方法*/

void *prochase()

{

int id = ++prochase_id;

while(1)

{

// 用sleep的数量可以调节生产和消费的速度,便于观察sleep(1);

//sleep(1);

sem_wait(&full_sem);

pthread_mutex_lock(&mutex);

out = out % M;

printf("customer%d in %d: ", id, out);

buff[out] = 0;

print();

++out;

pthread_mutex_unlock(&mutex);

sem_post(&empty_sem);

}

}

int main()

{

pthread_t id1[N];

pthread_t id2[N];

int i;

int ret[N];

// 初始化同步信号量

int ini1 = sem_init(&empty_sem, 0, M);

int ini2 = sem_init(&full_sem, 0, 0);

if(ini1 && ini2 != 0)

{

printf("sem init failed \n");

exit(1);

}

//初始化互斥信号量

int ini3 = pthread_mutex_init(&mutex, NULL);

if(ini3 != 0)

{

printf("mutex init failed \n");

exit(1);

}

// 创建N个生产者线程

for(i = 0; i < N; i++)

{

ret[i] = pthread_create(&id1[i], NULL, product, (void *)(&i));

if(ret[i] != 0)

{

printf("product%d creation failed \n", i);

exit(1);

}

}

//创建N个消费者线程

for(i = 0; i < N; i++)

{

ret[i] = pthread_create(&id2[i], NULL, prochase, NULL);

if(ret[i] != 0)

{

printf("prochase%d creation failed \n", i);

exit(1);

}

}

//销毁线程

for(i = 0; i < N; i++)

{

pthread_join(id1[i],NULL);

pthread_join(id2[i],NULL);

}

exit(0);

}

生产者与消费者问题(Java)

package Table; public class Message { public static int id; public String content; public String getContent() { return content; } public void setContent(String content) { this.content = content; } public int getId() { return id; } public void setId(int id) { Message.id = id; } } package Table; import java.util.ArrayList; import java.util.List; public class Queue { List queue = new ArrayList(); /** 队列中message对象的最大值,默认为10 */ int maxMessageNum = 10; public synchronized void produce(Message message) { /**synchronized为关键字,表示在任何一个线程要访问缓冲区时都会 检查有无其他线程访问此段内容,有的话则等待,无的话则直接访问**/ this.notifyAll(); while (queue.size() == maxMessageNum) { System.out.println(Thread.currentThread().getName() + "the desk is full, and the chef want to relax"); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace();

实验2-2windows2000 线程同步

实验2 并发与调度 2.2 Windows 2000线程同步 (实验估计时间:120分钟) 背景知识 实验目的 工具/准备工作 实验内容与步骤 背景知识 Windows 2000提供的常用对象可分成三类:核心应用服务、线程同步和线程间通讯。其中,开发人员可以使用线程同步对象来协调线程和进程的工作,以使其共享信息并执行任务。此类对象包括互锁数据、临界段、事件、互斥体和信号等。 多线程编程中关键的一步是保护所有的共享资源,工具主要有互锁函数、临界段和互斥体等;另一个实质性部分是协调线程使其完成应用程序的任务,为此,可利用内核中的事件对象和信号。 在进程内或进程间实现线程同步的最方便的方法是使用事件对象,这一组内核对象允许一个线程对其受信状态进行直接控制 (见表4-1) 。 而互斥体则是另一个可命名且安全的内核对象,其主要目的是引导对共享资源的访问。拥有单一访问资源的线程创建互斥体,所有想要访问该资源的线程应该在实际执行操作之前获得互斥体,而在访问结束时立即释放互斥体,以允许下一个等待线程获得互斥体,然后接着进行下去。 与事件对象类似,互斥体容易创建、打开、使用并清除。利用CreateMutex() API 可创建互斥体,创建时还可以指定一个初始的拥有权标志,通过使用这个标志,只有当线程完成了资源的所有的初始化工作时,才允许创建线程释放互斥体。

为了获得互斥体,首先,想要访问调用的线程可使用OpenMutex() API来获得指向对象的句柄;然后,线程将这个句柄提供给一个等待函数。当内核将互斥体对象发送给等待线程时,就表明该线程获得了互斥体的拥有权。当线程获得拥有权时,线程控制了对共享资源的访问——必须设法尽快地放弃互斥体。放弃共享资源时需要在该对象上调用ReleaseMute() API。然后系统负责将互斥体拥有权传递给下一个等待着的线程(由到达时间决定顺序) 。 实验目的 在本实验中,通过对事件和互斥体对象的了解,来加深对Windows 2000线程同步的理解。 1) 回顾系统进程、线程的有关概念,加深对Windows 2000线程的理解。 2) 了解事件和互斥体对象。 3) 通过分析实验程序,了解管理事件对象的API。 4) 了解在进程中如何使用事件对象。 5) 了解在进程中如何使用互斥体对象。 6) 了解父进程创建子进程的程序设计方法。 工具/准备工作 在开始本实验之前,请回顾教科书的相关内容。 您需要做以下准备: 1) 一台运行Windows 2000 Professional操作系统的计算机。 2) 计算机中需安装Visual C++ 6.0专业版或企业版。 实验内容与步骤 1. 事件对象 2. 互斥体对象 1. 事件对象 清单2-1程序展示了如何在进程间使用事件。父进程启动时,利用CreateEvent() API创建一个命名的、可共享的事件和子进程,然后等待子进程向事件发出信号并终止父进程。在创建时,子进程通过OpenEvent() API打开事件对象,调用SetEvent() API使其转化为已接受信号状态。两个进程在发出信号之后几乎立即终止。 步骤1:登录进入Windows 2000 Professional。 步骤2:在“开始”菜单中单击“程序”-“Microsoft Visual Studio 6.0”–“Microsoft Visual C++ 6.0”命令,进入Visual C++窗口。

进程同步机制与互斥-生产者消费者问题

学习中心: 专业: 年级:年春/秋季 学号: 学生: 题目:进程同步与互斥生产者-消费者问题 1.谈谈你对本课程学习过程中的心得体会与建议? 转眼间,学习了一个学期的计算机操作系统课程即将结束。在这个学期中,通过老师的悉心教导,让我深切地体会到了计算机操作系统的一些原理和具体操作过程。在学习操作系统之前,我只是很肤浅地认为操作系统只是单纯地讲一些关于计算机方面的操作应用,并不了解其中的具体操作过程 1.1设计思路 在这次设计中定义的多个缓冲区不是环形循环的,并且不需要按序访问。其中生产者可以把产品放到某一个空缓冲区中,消费者只能消费被指定生产者生产的产品。本设计在测试用例文件中指定了所有生产和消费的需求,并规定当共享缓冲区的数据满足了所有有关它的消费需求后,此共享才可以作为空闲空间允许新的生产者使用。

本设计在为生产者分配缓冲区时各生产者之间必须互斥,此后各个生产者的具体生产活动可以并发。而消费者之间只有在对同一个产品进行消费时才需要互斥,它们在消费过程结束时需要判断该消费者对象是否已经消费完毕并释放缓冲区的空间。 1.2程序流程图 1.3基本内容 在设计程序时主要有三个主体部分、三个辅助函数和一个数据结构。 其中主体部分为一个主函数main(),用于初始化缓冲区和各个同步对象,并完成线程信息的读入,最后根据该组的线程记录启动模拟线程,并等待所有线程的运 Y

行结束后退出程序; 生产者函数Produce()和消费者函数Consume(),生产者和消费者函数运行于线程中完成对缓冲区的读、写动作,根据此处生产消费的模型的特点,生产者和消费者之间通过使用同步对象实现了生产和消费的同步与互斥,是本实验的核心所在。 另外三个辅助性函数被生产者和消费者函数调用,是上述生产和消费函数中对缓冲区进行的一系列处理。 3)在实现本程序的消费生产模型时,具体的通过如下同步对象实现互斥: ①设一个互斥量h_mutex,以实现生产者在查询和保留缓冲区内的下一个位置时进行互斥。 ②每一个生产者用一个信号量与其消费者同步,通过设置h_Semaphore[MAX_THREAD_NUM]信号量 ③数组实现,该组信号量用于相应的产品已产生。同时用一个表示空缓冲区

生产者消费者问题模拟实现z

生产者消费者问题模拟实现(z)

————————————————————————————————作者: ————————————————————————————————日期:

生产者-消费者实验 1.1实验目的和要求 1.1.1实验目的 操作系统的基本控制和管理控制都围绕着进程展开,其中的复杂性是由于支持并发和并发机制而引起的。自从操作系统中引入并发程序设计后,程序的执行不再是顺序的,一个程序未执行完而另一个程序便已开始执行,程序外部的顺序特性消失,程序与计算不再一一对应。并发进程可能是无关的,也可能是交互的。然而,交互的进程共享某些变量,一个进程的执行可能会影响其他进程的执行结果,交互的并发进程之间具有制约关系、同步关系。其中典型模型便是生产者-消费者模型。 本实验通过编写和调试生产者-消费者模拟程序,进一步认识进程并发执行的实质,加深对进程竞争关系,协作关系的理解,掌握使用信号量机制与P、V操作来实现进程的同步与互斥。 1.1.2实验要求 1.用高级语言编写一个程序,模拟多个生产者进程和多个消费者进程并发执行,并采用信号量机制与P、V操作实现进程间同步与互斥。 2.撰写实验报告,报告应包含以下内容: (1)实验目的; (2)实验内容; (3)设计思路; (4)程序流程图; (5)程序中主要数据结构和函数说明; (6)带注释的源程序代码; (7)程序运行结果及分析; (8)实验收获与体会。 1.2预备知识 1.2.1生产者—消费者问题 生产者—消费者问题表述如下:如图3.1所示,有n个生产者和m个消费者,连接在具

有k个单位缓冲区的有界环状缓冲上,故又称有界缓冲问题。生产者不断生成产品,只要缓冲区未满,生产者进程pi所生产的产品就可投入缓冲区;类似的,只要缓冲区非空,消费者进程cj就可以从缓冲区取走并消耗产品。 图 3.1生产者—消费者问题示意图 著名的生产者—消费者问题(producer-consumer problem)是计算机操作系统中并发进程内在关系的一种抽象,是典型的进程同步问题。在操作系统中,生产者进程可以是计算进程、发送进程,而消费者进程可以是打印进程、接收进程等,解决好生产者—消费者问题就解决了一类并发进程的同步问题。 操作系统实现进程同步的机制称为同步机制,它通常由同步原语组成。不同的同步机制采用不同的同步方法,迄今已设计出多种同步机制,本实验采用最常用的同步机制:信号量及PV操作。 1.2.2信号量与PV操作 1965年,荷兰计算机科学家E.W.Dijkstra提出新的同步工具——信号量和PV操作,他将交通管制中多种颜色的信号灯管理方法引入操作系统,让多个进程通过特殊变量展开交互。一个进程在某一关键点上被迫停止直至接收到对应的特殊变量值,通过这一措施任何复杂的进程交互要求均可得到满足,这种特殊变量就是信号量(semaphore)。为了通过信号量传送信号,进程可利用P和V两个特殊操作来发送和接收信号,如果协作进程的相应信号仍未到达,则进程被挂起直至信号到达为止。 在操作系统中用信号量表示物理资源的实体,它是一个与队列有关的整型变量。具体实现时,信号量是一种变量类型,用一个记录型数据结构表示,有两个分量:一个是信号量的值,另一个是信号量队列的指针。信号量在操作系统中主要用于封锁临界区、进程同步及维护资源计数。除了赋初值之外,信号量仅能由同步原语PV对其操作,不存在其他方法可以检查或操作信号量,PV操作的不可分割性确保执行的原子性及信号量值的完整性。利用信号量和PV操作即可解决并发进程竞争问题,又可解决并发进程协作问题。 信号量按其用途可分为两种:公用信号量,联系一组并发进程,相关进程均可在此信号量上执行PV操作,用于实现进程互斥;私有信号量,联系一组并发进程,仅允许此信号量所拥有的进程执行P操作,而其他相关进程可在其上执行V操作,初值往往为0或正整数,多用于并发进程同步。

生产者与消费者

重庆交通大学 《计算机操作系统》课程设计报告 班级:计软专业 2013 级 2 班 姓名: 学号: 课程设计题目:生产者/消费者与FCFS 所属课程:计算机操作系统 实验室(中心):语音大楼801 指导教师:刘洋 完成时间: 2015 年 12 月 5 日 信息科学与工程学院课程设计成绩单

课程名称:计算机操作系统指导教师:刘洋

重庆交通学院信息科学与工程学院课程设计任务书

生产者/消费者与FCFS 一、内容提要 操作系统是计算机的核心软件,是计算机专业学生的专业必修课。进程同步问题是计算机操作系统中的重点内容,而生产者-消费者问题是进程同步问题中的经典,它是计算机中相互合作进程关系的一种抽象,该问题具有很大的代表性和使用价值。 在计算机系统中,很多问题都可以归结为生产者与消费者问题,提别是在通讯和控制系统中。因此,对该类问题的研究是非常必要的。一般而言,我们把提供给某种资源的进程(线程)称之为生产者,二吧消耗资源的进程(线程)称之为消费者。在大多数情况下,生产者和消费者的数目都是多于一个的。下面以多个进程(线程)共享一有界缓冲池为例来说明。 如图,左端箭头表示生产者,右端箭头表示消费者,设P 1、P 2 、…、P K 是k 个想缓冲池装入数据的进程(线程)(生产者)C 1、C 2 、…、C m 是m个冲缓冲池 中取出数据进行处理的进程(线程)(消费者),假设对任何P i 每次向缓冲区 中申请一空白缓冲区,并把数据装入其中;而对于常见的情况是任何C i 每次都从缓冲池中取出一满缓冲区的内容,并进行相应的处理,并把缓冲区清空。而每次生产者装入数据和消费者取出数据都是相同的(这是最常见的情况)。针对以上进程(线程)通信,如不对生产者进程(线程)和消费者(线程)的操作进行限制,则可能破坏数据的完整性。一种情况是一个生产者进程(线程)正在装入数据到缓冲区时,另外的生产者进程(线程)可能同时把数据写入相同区域,造成数据破坏,另一种情况是一个生产者进程(线程)正在装入数据到缓冲区时,另外的消费者进程(线程)可能读入该区域数据,由于数据未写完,从而造成消

生产者消费者问题设计与实现

操作系统课程设计任务书

目录

1.选题背景 生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类:(1)采用某种机制保护生产者和消费者之间的同步;(2)在生产者和消费者之间建立一个管道。第一种方式有较高的效率,并且易于实现,代码的可控制性较好,属于常用的模式。第二种管道缓冲区不易控制,被传输数据对象不易于封装等,实用性不强。因此本文只介绍同步机制实现的生产者/消费者问题。 同步问题核心在于:如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制,保证资源在任意时刻至多被一个线程访问。Java语言在多线程编程上实现了完全对象化,提供了对同步机制的良好支持。在Java中一共有四种方法支持同步,其中前三个是同步方法,一个是管道方法。 2.设计思路 .生产者—消费者问题是一种同步问题的抽象描述。 计算机系统中的每个进程都可以消费或生产某类资源。当系统中某一进程使用某一资源时,可以看作是消耗,且该进程称为消费者。 而当某个进程释放资源时,则它就相当一个生产者 3.过程论述 首先,生产者和消费者可能同时进入缓冲区,甚至可能同时读/写一个存储单元,将导致执行结果不确定。这显然是不允许的。所以,必须使生产者和消费者互斥进入缓冲区。即某时刻只允许一个实体(生产者或消费者)访问缓冲区,生产者互斥消费者和其他任何生产者。 其次,生产者不能向满的缓冲区写数据,消费者也不能在空缓冲区中取数据,即生产者与消费者必须同步。当生产者产生出数据,需要将其存入缓冲区之前,首先检查缓冲区中是否有“空”存储单元,若缓冲区存储单元全部用完,则生产者必须阻塞等待,直到消费者取走一个存储单元的数据,唤醒它。若缓冲区内有“空”存储单元,生产者需要判断此时是否有别的生产者或消费者正在使用缓冲区,若是有,则阻塞等待,否则,获得缓冲区的使用权,将数据存入缓冲区,释放缓冲区的使用权。消费者取数据之前,首先检查缓冲区中是否存在装有数据的存储单元,若缓冲区为“空”,则阻塞等待,否则,判断缓冲区是否正在被使用,

实验1:生产者消费者问题

福建农林大学金山学院实验报告 系(教研室):专业:计算机科学与技术年级: 实验课程:生产者与消费者实验姓名:学号: 实验室号:1#608 计算机号:实验时间:指导教师签字:成绩: 实验1:生产者消费者问题 一、实验目的 生产者消费者问题是操作系统中经典的同步和互斥问题。通过实验,要求学生掌握两者之间的同步信号量和互斥信号量的使用,更深刻了解临界资源、同步和互斥的概念。 二、实验要求 1.一组生产者通过一个具有N个缓冲区的缓冲池循环不断地向一组消费者提供产 品。 2.建一个队列, 队列的长度由n记录, 定义两个指针, 分别指向队列的头和尾消 费者从头指针读取数据,每读取一个数据把n--,生产者把数据写入尾指针, 每写入一个数据就n++,当n=N的时候生产者暂停写入数据。 3.注意:缓冲池队列,用互斥锁保护。 三、实验内容和原理 1.分别画出生产者和消费者的流程图

2.针对生产者和消费者问题,可以分为哪几种情况,使用了哪些原语?分别代表 什么意思?过程如何?阐述哪些进程之间存在同步,哪些进程之间存在互斥。 3.缓冲区是否为临界资源?是否可以循环使用?通过什么来实现?举例说明(可 画图) 四、实验环境 1. 硬件:PC机; 2. 软件:Windows操作系统、。 五、算法描述及实验步骤 #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]; DWORD producerID[CONSUMERS_COUNT]; DWORD consumerID[THREADS_COUNT]; for (int i=0;i

4:一个经典的多线程同步问题汇总

一个经典的多线程同步问题 程序描述: 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。 要求: 1.子线程输出的线程序号不能重复。 2.全局变量的输出必须递增。 下面画了个简单的示意图: 分析下这个问题的考察点,主要考察点有二个: 1.主线程创建子线程并传入一个指向变量地址的指针作参数,由于线程启动须要花费一定的时间,所以在子线程根据这个指针访问并保存数据前,主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。 2.子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架,可以在此代码基础上进行修改和验证。 //经典线程同步互斥问题 #include #include #include long g_nNum; //全局资源 unsigned int__stdcall Fun(void *pPM); //线程函数 const int THREAD_NUM = 10; //子线程个数 int main() { g_nNum = 0;

HANDLE handle[THREAD_NUM]; int i = 0; while (i < THREAD_NUM) { handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i++;//等子线程接收到参数时主线程可能改变了这个i的值} //保证子线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; } unsigned int__stdcall Fun(void *pPM) { //由于创建线程是要一定的开销的,所以新线程并不能第一时间执行到这来int nThreadNum = *(int *)pPM; //子线程获取参数 Sleep(50);//some work should to do g_nNum++; //处理全局资源 Sleep(0);//some work should to do printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum); return 0; } 运行结果:

生产者消费者问题模拟实现(z)

生产者-消费者实验 1.1实验目的和要求 1.1.1实验目的 操作系统的基本控制和管理控制都围绕着进程展开,其中的复杂性是由于支持并发和并发机制而引起的。自从操作系统中引入并发程序设计后,程序的执行不再是顺序的,一个程序未执行完而另一个程序便已开始执行,程序外部的顺序特性消失,程序与计算不再一一对应。并发进程可能是无关的,也可能是交互的。然而,交互的进程共享某些变量,一个进程的执行可能会影响其他进程的执行结果,交互的并发进程之间具有制约关系、同步关系。其中典型模型便是生产者-消费者模型。 本实验通过编写和调试生产者-消费者模拟程序,进一步认识进程并发执行的实质,加深对进程竞争关系,协作关系的理解,掌握使用信号量机制与P、V操作来实现进程的同步与互斥。 1.1.2实验要求 1.用高级语言编写一个程序,模拟多个生产者进程和多个消费者进程并发执行,并采用信号量机制与P、V操作实现进程间同步与互斥。 2.撰写实验报告,报告应包含以下内容: (1)实验目的; (2)实验内容; (3)设计思路; (4)程序流程图; (5)程序中主要数据结构和函数说明; (6)带注释的源程序代码; (7)程序运行结果及分析; (8)实验收获与体会。 1.2预备知识 1.2.1生产者—消费者问题 生产者—消费者问题表述如下:如图3.1所示,有n个生产者和m个消费者,连接在具

有k个单位缓冲区的有界环状缓冲上,故又称有界缓冲问题。生产者不断生成产品,只要缓冲区未满,生产者进程pi所生产的产品就可投入缓冲区;类似的,只要缓冲区非空,消费者进程cj就可以从缓冲区取走并消耗产品。 图 3.1 生产者—消费者问题示意图 著名的生产者—消费者问题(producer-consumer problem)是计算机操作系统中并发进程内在关系的一种抽象,是典型的进程同步问题。在操作系统中,生产者进程可以是计算进程、发送进程,而消费者进程可以是打印进程、接收进程等,解决好生产者—消费者问题就解决了一类并发进程的同步问题。 操作系统实现进程同步的机制称为同步机制,它通常由同步原语组成。不同的同步机制采用不同的同步方法,迄今已设计出多种同步机制,本实验采用最常用的同步机制:信号量及PV操作。 1.2.2信号量与PV操作 1965年,荷兰计算机科学家E.W.Dijkstra提出新的同步工具——信号量和PV操作,他将交通管制中多种颜色的信号灯管理方法引入操作系统,让多个进程通过特殊变量展开交互。一个进程在某一关键点上被迫停止直至接收到对应的特殊变量值,通过这一措施任何复杂的进程交互要求均可得到满足,这种特殊变量就是信号量(semaphore)。为了通过信号量传送信号,进程可利用P和V两个特殊操作来发送和接收信号,如果协作进程的相应信号仍未到达,则进程被挂起直至信号到达为止。 在操作系统中用信号量表示物理资源的实体,它是一个与队列有关的整型变量。具体实现时,信号量是一种变量类型,用一个记录型数据结构表示,有两个分量:一个是信号量的值,另一个是信号量队列的指针。信号量在操作系统中主要用于封锁临界区、进程同步及维护资源计数。除了赋初值之外,信号量仅能由同步原语PV对其操作,不存在其他方法可以检查或操作信号量,PV操作的不可分割性确保执行的原子性及信号量值的完整性。利用信号量和PV操作即可解决并发进程竞争问题,又可解决并发进程协作问题。 信号量按其用途可分为两种:公用信号量,联系一组并发进程,相关进程均可在此信号量上执行PV操作,用于实现进程互斥;私有信号量,联系一组并发进程,仅允许此信号量所拥有的进程执行P操作,而其他相关进程可在其上执行V操作,初值往往为0或正整数,多用于并发进程同步。

多线程同步操作多个窗口

多线程同步操作多个窗口 RunApp "notepad.exe" RunApp "notepad.exe" RunApp "notepad.exe" Delay 2000 Dimenv temp_Hwnd temp_Hwnd = 0 Dim str, arr, i str = Plugin.Window.Search("无标题- 记事本") arr = Split(str, "|") For i = 0 To UBound(arr) - 1 temp_Hwnd = Plugin.Window.FindEx(arr(i), 0, "Edit", 0) BeginThread WriteString While temp_Hwnd <> 0'判断多线程已经启动完毕,继续循环下一个。 Delay 500 Wend Next EndScript Function WriteString() Dim str, Hwnd Hwnd = temp_Hwnd temp_Hwnd = 0 Do str = WaitKey If Hwnd <> Plugin.Window.GetKeyFocusWnd Then Call Plugin.Bkgnd.KeyPress(Hwnd, str) End If Loop End Function 多线程多开窗口同步执行与子线程间的数值如何传递: 1.Dimenv IsThread, i 2.Dim arr_Thread() 3.For i = 0 To 2 4. IsThread = False'未启动线程 5. Redim Preserve arr_Thread(i) 6. arr_Thread(i) = BeginThread(EnterThread) 7. While IsThread = False'未启动成功,等待中 8. Delay 500 9. Wend 10. '跳出循环说明 IsThread = True,已经执行到了,循环继续启动下一个 11.Next

用多线程同步方法解决生产者-消费者问题(操作系统课设)

. 题目用多线程同步方法解决生产者-消费 者问题(Producer-Consumer Problem) 学院计算机科学与技术学院 专业软件工程 班级 姓名 指导教师 年月日

目录 目录 (1) 课程设计任务书 (2) 正文 (2) 1.设计目的与要求 (2) 1.1设计目的 (2) 1.2设计要求 (2) 2.设计思想及系统平台 (2) 2.1设计思想 (2) 2.2系统平台及使用语言 (2) 3.详细算法描述 (3) 4.源程序清单 (5) 5.运行结果与运行情况 (10) 6.调试过程 (15) 7.总结 (15) 本科生课程设计成绩评定表 (16)

课程设计任务书 学生姓名:专业班级: 指导教师:工作单位:计算机科学与技术学院 题目: 用多线程同步方法解决生产者-消费者问题 (Producer-Consumer Problem) 初始条件: 1.操作系统:Linux 2.程序设计语言:C语言 3.有界缓冲区内设有20个存储单元,其初值为0。放入/取出的数据项按增序设定为1-20这20个整型数。 要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要 求) 1.技术要求: 1)为每个生产者/消费者产生一个线程,设计正确的同步算法 2)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的当前全部内容、当前指针位置和生产者/消费者线程的自定义标识符。 3)生产者和消费者各有两个以上。 4)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2.设计说明书内容要求: 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3)数据结构与模块说明(功能与流程图) 4)给出用户名、源程序名、目标程序名和源程序及其运行结果。(要注明存储各个程序及其运行结果的主机IP地址和目录。) 5)运行结果与运行情况 (提示: (1)有界缓冲区可用数组实现。 (2)编译命令可用:cc -lpthread -o 目标文件名源文件名 (3)多线程编程方法参见附件。) 3. 调试报告: 1)调试记录 2)自我评析和总结 上机时间安排: 18周一~ 五 08:0 - 12:00 指导教师签名:年月日

操作系统生产者与消费者问题实验报告

《操作系统》实验报告 生产者和消费者的问题 一、实验目的 1.掌握基本的同步与互斥的算法,理解基本的生产者与消费者的模型。 2.学习使用Windows 2000/XP中基本的同步对象,掌握相关的API的使用方法。 3.了解Windows 2000/XP中多线程的并发执行机制,线程间的同步和互斥。 二、实验的内容及其要求 1.实验内容 以生产者/消费者模型为根据,在Windows 2000环境下创建一个控制台进程,在改进程中创建n个线程模拟生产者和消费者,实现进程(线程)的同步与互斥。 2.实验要求 ①学习并理解生产者/消费者模型及其同步/互斥规则 ②学习了解Windows同步对象及其特性 ③熟悉实验环境,掌握相关API的使用方法 ④设计程序,实现生产者/消费者进程(线程)的同步与互斥 ⑤提交实验报告 三、实验的时间安排 1.实验前,先到图书馆或上网百度了解有关生产者/消费者模型的相关知识,建立生产者/消费者模型的基本概念。 2.利用13周、15周、17周的上机时间编写和调试程序代码。 3.利用其他课余时间来分析实验的最终结果并完成相关的实验报告。 四、实验的环境 1.硬件条件:普通计算机一台 2.软件条件:①操作系统:Windows 2000/XP ②开发语言:VC++ 本实验是在Windows 2000+VC6.0环境下实现的,利用Windows SDK提供的系统接口(API)完成程序的功能。实验在Windows下安装VC后进行,因为VC是一个集成开发环境,其中包含了Windows SDK所有工具和定义,所以安装了VC后就不用特意安装SDK了。实验中所用的API(应用程序接口),是操作系统提供的用来进行应用程序设计的系统功能接口。要使用这些API,需要包含对这些函数进行说明的SDK 头文件,最常见的就是windows.h。一些特殊的API调用还需要包含其他的头文件。 五、正文 1.程序结构图:

四种进程或线程同步互斥的控制方法

四种进程或线程同步互斥的控制方法 1、临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。 2、互斥量:为协调共同对一个共享资源的单独访问而设计的。 3、信号量:为控制一个具有有限数量用户资源而设计。 4、事件:用来通知线程有一些事件已发生,从而启动后继任务的开始。 一临界区 临界区的使用在线程同步中应该算是比较简单,说它简单还是说它同后面讲到的其它方法相比更容易理解。举个简单的例子:比如说有一个全局变量(公共资源)两个线程都会对它进行写操作和读操作,如果我们在这里不加以控制,会产生意想不到的结果。假设线程A 正在把全局变量加1然后打印在屏幕上,但是这时切换到线程B,线程B又把全局变量加1然后又切换到线程A,这时候线程A打印的结果就不是程序想要的结果,也就产生了错误。解决的办法就是设置一个区域,让线程A在操纵全局变量的时候进行加锁,线程B如果想操纵这个全局变量就要等待线程A释放这个锁,这个也就是临界区的概念。 二互斥体 windows api中提供了一个互斥体,功能上要比临界区强大。也许你要问,这个东东和临界区有什么区别,为什么强大?它们有以下几点不一致: 1.critical section是局部对象,而mutex是核心对象。因此像waitforsingleobject是不可以等待临界区的。 2.critical section是快速高效的,而mutex同其相比要慢很多 3.critical section使用围是单一进程中的各个线程,而mutex由于可以有一个名字,因此它是可以应用于不同的进程,当然也可以应用于同一个进程中的不同线程。 4.critical section 无法检测到是否被某一个线程释放,而mutex在某一个线程结束之后会产生一个abandoned的信息。同时mutex只能被拥有它的线程释放。下面举两个应用mutex 的例子,一个是程序只能运行一个实例,也就是说同一个程序如果已经运行了,就不能再运行了;另一个是关于非常经典的哲学家吃饭问题的例子。 三事件 事件对象的特点是它可以应用在重叠I/O(overlapped I/0)上,比如说socket编程中有两种模型,一种是重叠I/0,一种是完成端口都是可以使用事件同步。它也是核心对象,因此可以被waitforsingleobje这些函数等待;事件可以有名字,因此可以被其他进程开启。 四信号量 semaphore的概念理解起来可能要比mutex还难,我先简单说一下创建信号量的函数,因为我在开始使用的时候没有很快弄清楚,可能现在还有理解不对的地方,如果有错误还是请大侠多多指教。 CreateSemaphore( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // SD LONG lInitialCount, // initial count LONG lMaximumCount, // maximum count LPCTSTR lpName // object name )

操作系统实验报告生产者消费者问题

操作系统课程设计 一.实验目标 完成N个生产者和M个消费者线程之间的并发控制,N、M不低于30,数据发送和接收缓冲区尺寸不小于20个(每个产品占据一个)。 其中生产者线程1、3、5、7、9生产的产品供所有奇数编号的消费者线程消费,只有所有奇数编号的消费者线程都消费后,该产品才能从缓冲区中撤销。 其中生产者线程2、4、6、8、10生产的产品所有偶数编号的消费者线程都可消费,任一偶数编号消费者线程消费该消息后,该产品都可从缓冲区中撤销。 其中11-20号生产者线程生产的产品仅供对应编号的消费者线程消费。 其他编号生产者线程生产的产品可由任意的消费者线程消费。 每个生产线程生产30个消息后结束运行。如果一个消费者线程没有对应的生产者线程在运行后,也结束运行。所有生产者都停止生产后,如果消费者线程已经

没有可供消费的产品,则也退出运行。 二.实验原理 2.1原理 生产者与消费者线程采用posix互斥锁机制进行互斥进入各自的代码段,只有采用互斥锁临界区代码段才可以不被打扰的执行;同步机制采用的是posix条件变量pthread_cond_wait和pthraed_cond_signal进行同步的。 线程间的通信采用的是共享内存机制。(注:所有的共享内存块是在进程里建立的,线程只需链接上各自的共享内存块即可,每一块共享内存的大小是100). 在这里共享内存设置成一个100的数组。 具体实施:(1)为1.3.5.7.9建立一个共享内存1号,1.3.5.7.9生产者线程生产的产品都放入这块共享内存缓冲区,所有奇数的消费者线程要消费的话,只需在消费者线程中链接上这块共享内存,就可以直接消费1.3.5.7.9生产者线程生产的产品。 (2)为2.4.6.8.10建立一块共享内存2号。2.4.6.8.10生产的产品都放入2号共享内存缓冲区,所有的偶数的消费者线程只要链接上2号缓冲区,就可以消费2.4.6.8.10生产的产品。当偶数消费者线程消费产品后,产品即可从缓冲区撤销,方法是在消费线程里将消费的产品在共享内存数组里置0。 (3)为11--20的每一对生产者消费者线程建立一块共享内存,编号11--20. 11--20号的消费者线程能链接各自的共享内存缓冲区或奇数或偶数共享内存缓冲区,即11--20号的生产者生产的产品只能被对应的消费者消费而11-20的奇数消费者可以消费缓冲区1的产品,偶数消费者可消费缓冲区2的产品。 (4)为21--30号的生产者消费者线程只建立一块共享内存21号,21--30号生产者生产的产品都放入21号缓冲区,所有的消费者线程只要链接上21号共享内存,就可以消费21--30号生产者生产的产品。 用于控制线程是否结束的方法是:设置一个全局变量t,在生产者线程里进行t++,在生产者线程里当t达到10时(注:为了很好的测试程序,本应该在生产者生产30个产品时菜结束线程,这里设置成了10),就break跳出while()循环,这样线程自然就终止。同样在消费者线程里,当t达到10时,这里不用t++,就跳出while()循环,消费者线程自然就终止。这样设计满足了,当生产者生产30个产品时就终止生产者线程,生产者线程终止消费者线程也得终止的要求。 生产者从文件so.txt读取数据进行生产,这个文件里的数据是一连串的字符从a--z的组合,没有空格或其他字符。文件内容的格式没有特殊要求。

1实验1:生产者消费者问题

1实验1:生产者消费者问 题 -标准化文件发布号:(9556-EUATWK-MWUB-WUNN-INNUL-DDQTY-KII

福建农林大学金山学院实验报告 系(教研室):专业:计算机科学与技术年级: 实验课程:生产者与消费者实验姓名:学号: 实验室号:1#608 计算机号:实验时间:指导教师签字:成绩: 实验1:生产者消费者问题 一、实验目的 生产者消费者问题是操作系统中经典的同步和互斥问题。通过实验,要求学生掌握两者之间的同步信号量和互斥信号量的使用,更深刻了解临界资源、同步和互斥的概念。 二、实验要求 1.一组生产者通过一个具有N个缓冲区的缓冲池循环不断地向一组消费者提供 产品。 2.建一个队列, 队列的长度由n记录, 定义两个指针, 分别指向队列的头和尾消费 者从头指针读取数据,每读取一个数据把n--,生产者把数据写入尾指针, 每写 入一个数据就n++,当n=N的时候生产者暂停写入数据。 3.注意:缓冲池队列,用互斥锁保护。 三、实验内容和原理 1.分别画出生产者和消费者的流程图

2.针对生产者和消费者问题,可以分为哪几种情况,使用了哪些原语分别代表什 么意思过程如何阐述哪些进程之间存在同步,哪些进程之间存在互斥。 3.缓冲区是否为临界资源是否可以循环使用通过什么来实现举例说明(可画图) 四、实验环境 1. 硬件:PC机; 2. 软件:Windows操作系统、。 五、算法描述及实验步骤 #include <> #include const unsigned short SIZE_OF_BUFFER = 10; unsigned short ProductID = 0; unsigned short ConsumeID = 0; unsigned short in = 0;

Windows下多线程同步机制

多线程同步机制 Critical section(临界区)用来实现“排他性占有”。适用范围是单一进程的各线程之间。它是: ·一个局部性对象,不是一个核心对象。 ·快速而有效率。 ·不能够同时有一个以上的critical section被等待。 ·无法侦测是否已被某个线程放弃。 Mutex Mutex是一个核心对象,可以在不同的线程之间实现“排他性占有”,甚至几十那些现成分属不同进程。它是: ·一个核心对象。 ·如果拥有mutex的那个线程结束,则会产生一个“abandoned”错误信息。 ·可以使用Wait…()等待一个mutex。 ·可以具名,因此可以被其他进程开启。 ·只能被拥有它的那个线程释放(released)。 Semaphore Semaphore被用来追踪有限的资源。它是: ·一个核心对象。 ·没有拥有者。 ·可以具名,因此可以被其他进程开启。 ·可以被任何一个线程释放(released)。 Ev ent Object Ev ent object通常使用于overlapped I/O,或用来设计某些自定义的同步对象。它是: ·一个核心对象。 ·完全在程序掌控之下。 ·适用于设计新的同步对象。 · “要求苏醒”的请求并不会被储存起来,可能会遗失掉。 ·可以具名,因此可以被其他进程开启。 Interlocked Variable 如果Interlocked…()函数被使用于所谓的spin-lock,那么他们只是一种同步机制。所谓spin-lock是一种busy loop,被预期在极短时间内执行,所以有最小的额外负担(overhead)。系统核心偶尔会使用他们。除此之外,interlocked variables主要用于引用技术。他们:·允许对4字节的数值有些基本的同步操作,不需动用到critical section或mutex之类。 ·在SMP(Symmetric Multi-Processors)操作系统中亦可有效运作。 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

相关文档
最新文档