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

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

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

题目

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

者问题(Producer-Consume r Problem)

学院

物理学与电子信息工程学院

专业电子信息工程班级08电信本一班姓名

指导教师

2010 年12 月日

目录

目录 0

课程设计任务书 (1)

正文 (3)

1.设计目的与要求 (3)

1.1设计目的 (3)

1.2设计要求 (3)

2.设计思想及系统平台 (3)

2.1设计思想 (3)

2.2系统平台及使用语言 (3)

3.详细算法描述 (4)

4.源程序清单 (7)

5.运行结果与运行情况 (12)

6.调试过程 (16)

7.总结 (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)自我评析和总结

正文

1.设计目的与要求

1.1设计目的

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

1.2设计要求

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

2)每个生产者/消费者对该存储区进行操作后,即时显示该存储区的全部内容、

前指针位置和生产者/消费者线程的自定义标识符。

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

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

2.设计思想及系统平台

2.1设计思想

在本问题中,共需要一个Mutex和两个Semaphore.

其中,Mutex是用来锁定临界区的,以解决对共享数据buffer的互斥访问问题(无论

是对生成者还是对消费者);

我们共需要两个Semaphore,这是因为在本问题中共有两个稀缺资源.

第一种是"非空"这种资源,是在消费者之间进行竞争的.

第二种是"非满"这种资源,是在生产者之间进行竞争的.

所以,一般来说,需要锁定临界区,就需要Mutex;有几种稀缺资源就需要几个

Semaphore.

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

在生产者消费者问题中,消费者会在缓冲区为空时被阻塞,所以"非空"是一种稀缺资源;

需要设置一个信号量consumer_semaphore,初值设为0;

生产者会在缓冲区为满时被阻塞,所以"非满"也是一种稀缺资源.

需要设置一个信号量producer_semaphore,初值设为buffer的大小MAX_BUFFER

2.2系统平台及使用语言

本课程设计在Linux操作系统下,使用C语言完成。用到的工具主要有GCC 编译器和VI编辑器。

3.详细算法描述

共享数据:

Semaphore buffer_mutex=1;

Semaphore producer_semaphore=MAX_BUFFER;

Semaphore consumer_semaphore=0;

int buffer[MAX_BUFFER];

Producer线程的处理函数:

while(1){

Wait(producer_semaphore);

Wait(buffer_mutex);

Buffer[pn]=product;

pn=(pn+1)%MAX_BUFFER;

Signal(consumer_semaphore);

Signal(buffer_mutex);

Sleep();

}

producer线程的处理函数流程图如下:

consumer线程的处理函数:

while(1){

Wait(consumer_semaphore);

Wait(buffer_mutex);

Consume=buffer[cn];

cn=(cn+1)%MAX_BUFFER;

Signal(producer_semaphore);

Signal(buffer_mutex);

Sleep();

}

consumer线程的处理函数流程图如下:

4.源程序清单

用户名:rj070126(IP:192.168.2.254)

源程序名:/home/rj070126/pc.c

目标程序名:/home/rj070126/pc

运行结果:/home/rj070126/output.txt

源程序清单如下:

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

//生产者的个数

#define NUM_THREADS_P 5

//消费者的个数

#define NUM_THREADS_C 5

//缓冲区的大小

#define MAX_BUFFER 20

//运行的时间

#define RUN_TIME 20

//缓冲区的数组

int buffer[MAX_BUFFER];

int produce_pointer=0,consume_pointer=0;

sem_t producer_semaphore,consumer_semaphore,buffer_mutex;

pthread_t threads_p[NUM_THREADS_P]; /*producer*/

pthread_t threads_c[NUM_THREADS_C]; /*consumer*/

FILE* fd;

void *producer_thread(void *tid);

void *consumer_thread(void *tid);

void showbuf();

void handler(){

int i;

for(i=0;i

//送终止信号给thread线程,如果成功则返回0,否则为非0值。发送成功并不意味着thread //会终止。

pthread_cancel(threads_p[i]);

for(i=0;i

pthread_cancel(threads_c[i]);

}

int main(){

int i;

signal(SIGALRM,handler);

fd=fopen("output.txt","w"); /*open a file to save the result*/

sem_init(&producer_semaphore,0,MAX_BUFFER); /*set the value of semaphores*/

sem_init(&consumer_semaphore,0,0);

sem_init(&buffer_mutex,0,1);

for(i=0;i

buffer[i]=0; /*initiate the buffer*/

/*create the threads*/

for(i=0;i

pthread_create(&threads_p[i],NULL,(void*)producer_thread,(void*)(i+1));

for(i=0;i

pthread_create(&threads_c[i],NULL,(void*)consumer_thread,(void *)(i+1));

alarm(RUN_TIME); /*set time to run*/

/*wait the threads to exit*/

for(i=0;i

pthread_join(threads_p[i],NULL);

for(i=0;i

pthread_join(threads_c[i],NULL);

/*destroy the semaphores*/

sem_destroy(&producer_semaphore);

sem_destroy(&consumer_semaphore);

sem_destroy(&buffer_mutex);

fclose(fd);

return 0;

}

void *producer_thread(void *tid){

/*the thread can be canceled by other thread*/

pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);

while(1){

sem_wait(&producer_semaphore);

srand((int)time(NULL)*(int)tid);

sleep(rand()%2+1); /*one or two seconds to produce*/

while((produce_pointer+1)%20==consume_pointer);

sem_wait(&buffer_mutex);

buffer[produce_pointer]=rand()%20+1;

produce_pointer=(produce_pointer+1)%20;

if(produce_pointer==0){ /*if buffer was filled to the 19th*/

printf("producer:%d pointer_p:%2d produced:%2d\n",(int)tid,19,buffer[19]);

fprintf(fd,"producer:%d pointer_p:%2d produced:%2d\n",(int)tid,19,buffer[19]);

}

else{

printf("producer:%d pointer_p:%2d produced:%2d\n",(int)tid,produce_pointer-1,buffer[produce_pointer-1]);

fprintf(fd,"producer:%d pointer_p:%2d produced:%2d\n",(int)tid,produce_pointer-1,buffer[produce_pointer-1]);

}

showbuf();

sem_post(&buffer_mutex);

sem_post(&consumer_semaphore); /*inform the consumer the buffer is not empty*/

srand((int)time(NULL)*(int)tid);

sleep(rand()%5+1); /*wait a few seconds ,then continue producing*/ }

return ((void*)0);

}

void *consumer_thread(void *tid){

/*the thread can be canceled by other thread*/

pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);

while(1){

//信号等待

sem_wait(&consumer_semaphore);

//获取种子

srand((int)time(NULL)*(int)tid);

//休眠一到两秒

sleep(rand()%2+1); /*one or two seconds to consume*/

sem_wait(&buffer_mutex);

printf("consumer:%d pointer_c:%2d consumed:%2d\n",(int)tid,consume_pointer,buffer[consume_pointer]);

fprintf(fd,"consumer:%d pointer_c:%2d consumed:%2d\n",(int)tid,consume_pointer,buffer[consume_pointer]);

buffer[consume_pointer]=0;

consume_pointer=(consume_pointer+1)%20;

showbuf();

sem_post(&buffer_mutex);

sem_post(&producer_semaphore);

srand((int)time(NULL)*(int)tid);

sleep(rand()%5+1); /*wait a few seconds ,then continue consuming*/ }

return ((void*)0);

}

/*show the content of buffer*/

void showbuf(){

int i;

printf("buffer:");

fprintf(fd,"buffer:");

for(i=0;i

printf("%2d ",buffer[i]);

fprintf(fd,"%2d ",buffer[i]);

}

printf("\n\n");

fprintf(fd,"\n\n");

}

5.运行结果与运行情况

程序运行结果如下:

producer:1 pointer_p: 0 produced:20

buffer:20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:3 pointer_p: 1 produced:13

buffer:20 13 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:2 pointer_p: 2 produced: 6

buffer:20 13 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:4 pointer_p: 3 produced:14

buffer:20 13 6 14 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:5 pointer_p: 4 produced:20

buffer:20 13 6 14 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

consumer:2 pointer_c: 0 consumed:20

buffer: 0 13 6 14 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:1 pointer_p: 5 produced:20

buffer: 0 13 6 14 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0

consumer:1 pointer_c: 1 consumed:13

buffer: 0 0 6 14 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0

consumer:3 pointer_c: 2 consumed: 6

buffer: 0 0 0 14 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0 consumer:4 pointer_c: 3 consumed:14

buffer: 0 0 0 0 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0

consumer:5 pointer_c: 4 consumed:20

buffer: 0 0 0 0 0 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:3 pointer_p: 6 produced: 1

buffer: 0 0 0 0 0 20 1 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:2 pointer_p: 7 produced:14

buffer: 0 0 0 0 0 20 1 14 0 0 0 0 0 0 0 0 0 0 0 0

consumer:3 pointer_c: 5 consumed:20

buffer: 0 0 0 0 0 0 1 14 0 0 0 0 0 0 0 0 0 0 0 0

producer:4 pointer_p: 8 produced: 6

buffer: 0 0 0 0 0 0 1 14 6 0 0 0 0 0 0 0 0 0 0 0

consumer:5 pointer_c: 6 consumed: 1

buffer: 0 0 0 0 0 0 0 14 6 0 0 0 0 0 0 0 0 0 0 0

producer:5 pointer_p: 9 produced: 8

buffer: 0 0 0 0 0 0 0 14 6 8 0 0 0 0 0 0 0 0 0 0

consumer:2 pointer_c: 7 consumed:14

buffer: 0 0 0 0 0 0 0 0 6 8 0 0 0 0 0 0 0 0 0 0

consumer:5 pointer_c: 8 consumed: 6

buffer: 0 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0 0 0 0

producer:1 pointer_p:10 produced:18

buffer: 0 0 0 0 0 0 0 0 0 8 18 0 0 0 0 0 0 0 0 0

consumer:1 pointer_c: 9 consumed: 8

buffer: 0 0 0 0 0 0 0 0 0 0 18 0 0 0 0 0 0 0 0 0

producer:2 pointer_p:11 produced:10

buffer: 0 0 0 0 0 0 0 0 0 0 18 10 0 0 0 0 0 0 0 0

producer:4 pointer_p:12 produced:10

buffer: 0 0 0 0 0 0 0 0 0 0 18 10 10 0 0 0 0 0 0 0

consumer:4 pointer_c:10 consumed:18

buffer: 0 0 0 0 0 0 0 0 0 0 0 10 10 0 0 0 0 0 0 0

producer:3 pointer_p:13 produced: 3

buffer: 0 0 0 0 0 0 0 0 0 0 0 10 10 3 0 0 0 0 0 0

consumer:3 pointer_c:11 consumed:10

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 10 3 0 0 0 0 0 0

consumer:2 pointer_c:12 consumed:10

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0

producer:1 pointer_p:14 produced: 6

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 3 6 0 0 0 0 0

consumer:1 pointer_c:13 consumed: 3

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 0 0 0 0 0

producer:2 pointer_p:15 produced:18

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 18 0 0 0 0

consumer:5 pointer_c:14 consumed: 6

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 18 0 0 0 0

producer:1 pointer_p:16 produced: 6

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 18 6 0 0 0

producer:3 pointer_p:17 produced:19

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 18 6 19 0 0

consumer:1 pointer_c:15 consumed:18

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 19 0 0

producer:5 pointer_p:18 produced: 7

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 19 7 0

consumer:3 pointer_c:16 consumed: 6

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 19 7 0

producer:4 pointer_p:19 produced:14

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 19 7 14

consumer:5 pointer_c:17 consumed:19

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 14

consumer:4 pointer_c:18 consumed: 7

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14

producer:1 pointer_p: 0 produced: 4

buffer: 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14

consumer:2 pointer_c:19 consumed:14

buffer: 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

consumer:1 pointer_c: 0 consumed: 4

buffer: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:2 pointer_p: 1 produced:15

buffer: 0 15 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:3 pointer_p: 2 produced:13

buffer: 0 15 13 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

producer:2 pointer_p: 3 produced: 3

buffer: 0 15 13 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

说明:

“producer:2”是指自定义标号为2的producer,“pointer_p:3”是指该producer 的指针,“produced:3”是指该producer在buffer[3]里写入3,“buffer: 0 15 13 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ”是指该producer进行写操作后存储区的内容。

6.调试过程

通过这次课程设计,不但加深了对操作系统这们课程的认识,而且还了解了操作系统中使用信号量解决生产者—消费者问题算法的实现。比如:用信号量解决生产者—消费者问题时,可以通过一个有界缓冲区(用数组来实现,类似循环队列)把生产者和消费者联系起来。假定生产者和消费者的优先级是相同的,只要缓冲区未满,生产者就可以生产产品并将产品送入缓冲区。类似地,只要缓冲区未空,消费者就可以从缓冲区中去走产品并消费它。为了解决生产者/消费者问题,应该设置两个资源信号量,其中一个表示空缓冲区的数目,用producer_semaphore 表示,其初始值为有界缓冲区的大小SIZE_OF_BUFFER;另一个表示缓冲区中产品的数目,用consumer_semaphore表示,其初始值为0。另外,由于有界缓冲区是一个临界资源,必须互斥使用,所以还需要再设置一个互斥信号量buffer_mutex,起初值为1。在生产者/消费者问题中,信号量实现两种功能。首先,它是生产产品和消费产品的计数器,计数器的初始值是可利用的资源数目(有界缓冲区的长度)。其次,它是确保产品的生产者和消费者之间动作同步的同步器。生产者要生产一个产品时,首先对资源信号量producer_semaphore和互斥信号量buffer_mutex进行wait操作,申请资源。如果可以通过的话,就生产一个产品,并把产品送入缓冲区。然后对互斥信号量buffer_mutex和资源信号量consumer_semaphore进行signal操作,释放资源。消费者要消费一个产品时,首先对资源信号量consumer_semaphore和互斥信号量buffer_mutex进行wait 操作,申请资源。如果可以通过的话,就从缓冲区取出一个产品并消费掉。然后对互斥信号量buffer_mutex和资源信号量producer_semaphore进行signal操作,释放资源。

实验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

操作系统OS报告读者与写者问题(进程同步问题)

目录 一、课程设计目的及要求 (1) 二、相关知识 (1) 三、题目分析 (2) 四、概要设计 (4) 五、代码及流程 (5) 六、运行结果 (11) 七、设计心得 (12) 八、参考文献 (12)

一、课程设计目的及要求 读者与写者问题(进程同步问题) 用n 个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求,进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者-写者问题。 读者-写者问题的读写操作限制: 1)写-写互斥; 2)读-写互斥; 3)读-读允许; 写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。 二、相关知识 Windows API: 在本实验中涉及的API 有: 1线程控制: CreateThread 完成线程创建,在调用进程的地址空间上创建一个线程,以执行指定的函数;它的返回值为所创建线程的句柄。 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD DWORD dwStackSize, // initial stack size LPTHREAD_START_ROUTINE lpStartAddress, // thread function LPVOID lpParameter, // thread argument DWORD dwCreationFlags, // creation option LPDWORD lpThreadId // thread identifier ); 2 ExitThread 用于结束当前线程。 VOID ExitThread( DWORD dwExitCode // exit code for this thread ); 3Sleep 可在指定的时间内挂起当前线程。 VOID Sleep( DWORD dwMilliseconds // sleep time ); 4信号量控制: WaitForSingleObject可在指定的时间内等待指定对象为可用状态; DWORD WaitForSingleObject( HANDLE hHandle, // handle to object DWORD dwMilliseconds // time-out interval );

实验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]信号量 ③数组实现,该组信号量用于相应的产品已产生。同时用一个表示空缓冲区

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

操作系统课程设计 一.实验目标 完成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的组合,没有空格或其他字符。文件内容的格式没有特殊要求。

操作系统 实验 五 线程间的互斥与同步

实验五线程间的互斥与同步 实验学时:2学时 实验类型:验证、设计型 一、实验目的 理解POSIX线程(Pthread)互斥锁和POSIX信号量机制,学习它们的使用方法;编写程序,实现多个POSIX线程的同步控制。 二,实验内容 创建4个POSIX线程。其中2个线程(A和B)分别从2个数据文件(data1.txt和data2.txt)读取10个整数. 线程A和B把从文件中读取的逐一整数放入一个缓冲池. 缓冲池由n个缓冲区构成(n=5,并可以方便地调整为其他值),每个缓冲区可以存放一个整数。另外2个线程,C和D,各从缓冲池读取10数据。线程C、D每读出2个数据,分别求出它们的和或乘积,并打印输出。 提示:在创建4个线程当中,A和B是生产者,负责从文件读取数据到公共的缓冲区,C和D是消费者,从缓冲区读取数据然后作不同的计算(加和乘运算)。使用互斥锁和信号量控制这些线程的同步。不限制线程C和D从缓冲区得到的数据来自哪个文件。 在开始设计和实现之前,务必认真阅读课本6.8.4节和第6章后面的编程项目——生产者-消费者问题。

三,实验要求 按照要求编写程序,放在相应的目录中,编译成功后执行,并按照要求分析执行结果,并写出实验报告。 四,实验设计 1,功能设计 根据实验要求,主程序需要创建四个线程,两个线程负责从文件读取数据到缓冲区,两个线程负责将缓冲区的数据做数学运算。由于同一个进程中的各个线程共享资源,可以用一个二维数组的全局变量作为公共缓冲区,同时还需要一个整形全局变量size用来做数组的索引。读线程的运行函数打开不同的文件并从中读取数据到二维数组中,每次写入数组后size加一。运算线程从二维数组中读数并做运算,每次读数之前size减一。本题的关键在于如何使用信号量保证进程的同步与互斥。在运算线程从缓冲区读取之前缓冲区里必须有数,即任意时刻运算操作的执行次数必须小于等于读取操作的执行次数。同时应该保证两个读线程和两个运算线程两两互斥。由于以上分析,使用了四个信号量sem1,sem2,sem3和sem4。sem1保证线程1和线程2互斥,sem2保证线程3和线程4互斥,sem3保证线程3和线程4互斥,sem4保证线程4和线程1互斥。即这四个信号量使四个线程循环进行,从而保证了运行结果的正确性。 源代码及注释: #include #include #include #define NUM 200

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

操作系统课程设计任务书

目录

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

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

操作系统课程设计 用多进程同步方法解决生产者-消费者问题 系别:计科系 专业: 计算机科学与技术 班级:04 级 4 班 学号:0410******* 姓名:苏德洪 时间:2006-7-7—2006-7-14

目录 一、题目: (3) 二、设计目的: (3) 三、总体设计思想概述: (3) 四、说明: (3) 五、设计要求: (3) 六、设计方案: (3) 七、流程图: (5) 八、运行结果 (7) 九、源程序 (11) 十、总结 (18) 十一、参考文献 (20)

一、题目: 用多进程同步方法解决生产者-消费者问题。 二、设计目的: 通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制。 三、总体设计思想概述: 1、生产者—消费者问题是一种同步问题的抽象描述。 2、计算机系统中的每个进程都可以消费或生产某类资源。当系统中某一进程使用某一 资源时,可以看作是消耗,且该进程称为消费者。 3、而当某个进程释放资源时,则它就相当一个生产者。 四、说明: 有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1-20这20个整型数。 五、设计要求: 1、每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前 指针位置和生产者/消费者线程的标识符。 2、生产者和消费者各有两个以上。 3、多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码。 六、设计方案: 通过一个有界缓冲区(用数组来实现,类似循环队列)把生产者和消费者联系起来。假定生产者和消费者的优先级是相同的,只要缓冲区未满,生产者就可以生产产品并将产品送入缓冲区。类似地,只要缓冲区未空,消费者就可以从缓冲区中去走产品并消费它。 应该禁止生产者向满的缓冲区送入产品,同时也应该禁止消费者从空的缓冲区中取出产品,这一机制有生产者线程和消费者线程之间的互斥关系来实现。 为解决生产者/消费者问题,应该设置两个资源信号量,其中一个表示空缓冲区的数目,用g_hFullSemaphore表示,其初始值为有界缓冲区的大小SIZE_OF_BUFFER;另一个表示缓冲区中产品的数目,用g_hEmptySemaphore表示,其初始值为0。另外,由于有界缓冲区是一个临界资源,必须互斥使用,所以还需要再设置一个互斥信号量g_hMutex,起初值为1。

生产者和消费者问题

班级姓名:学号:成绩: 实验名称: 生产者和消费者问题 1.实验目的: “生产者消费者”问题是一个著名的同时性编程问题的集合。通过编写经典的“生产者消费者”问题的实验,读者可以进一步熟悉Linux 中多线程编程,并且掌握用信号量处理线程间的同步互斥问题。 2.实验内容: “生产者消费者”问题描述如下。 有一个有限缓冲区和两个线程:生产者和消费者。他们分别把产品放入缓冲区和从缓冲区中拿走产品。当一个生产者在缓冲区满时必须等待,当一个消费者在缓冲区空时也必须等待。它们之间的关系如下图所示: 这里要求用有名管道来模拟有限缓冲区,用信号量来解决生产者消费者问题中的同步和互斥问题。 3.实验方法: (1)使用信号量解决 (2)思考使用条件变量解决 4.实验过程 (1)信号量的考虑 这里使用3个信号量,其中两个信号量avail和full分别用于解决生产者和消费者线程之间的同步问题,mutex是用于这两个线程之间的互斥问题。其中avail初始化为N(有界缓冲区的空单元数),mutex 初始化为1,full初始化为0。

/**/ #include <> #include <> #include <> #include <> #include <> #include #include <> #include <> #define FIFO "myfifo" #define N 5 int lock_var; time_t end_time; char buf_r[100]; sem_t mutex,full,avail; int fd; void pthread1(void *arg); void pthread2(void *arg); int main(int argc, char *argv[]) { pthread_t id1,id2; pthread_t mon_th_id; int ret; end_time = time(NULL)+30; /*创建有名管道*/ if((mkfifo(FIFO,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST)) printf("cannot create fifoserver\n");

南昌大学操作系统线程进程同步实验报告

南昌大学实验报告 ---(1)进程/线程同步 学生姓名:学号:专业班级:网络工程131班 实验类型:■验证□综合□设计□创新实验日期:实验成绩: 一、实验目的 本实验讨论临界区问题及其解决方案。首先创建两个共享数据资源的并发线程。在没有同步控制机制的情况下,我们将看到某些异常现象。针对观察到的现象,本实验采用Windows 的信号量机制解决临界区互斥访问。 二、实验内容 2.1 进程/线程并发执行 Windows操作系统支持抢先式调度,这意味着一线程运行一段时间后,操作系统会暂停其运行并启动另一线程。也就是说,进程内的所有线程会以不可预知的步调并发执行。为了制造混乱,我们首先创建两个线程t1和t2。父线程(主线程)定义两个全局变量,比如accnt1和accnt2。每个变量表示一个银行账户,其值表示该账户的存款余额,初始值为0。线程模拟在两个账户之间进行转账的交易。也即,每个线程首先读取两个账户的余额,然后产生一个随机数r,在其中一个账户上减去该数,在另一个账户上加上该数。线程操作的代码框架如下: counter=0; do { tmp1 = accnt1 ; tmp2 = accnt2 ; r = rand ( ) ; accnt1 = tmp1 + r ; accnt2 = tmp2 ? r ; counter++; } while ( accnt1 + accnt2 == 0 ) ; print ( counter ) ; 两个线程执行相同的代码。只要它们的执行过程不相互交叉,那么两个账户的余额之和将永远是0。但如果发生了交叉,那么某线程就有可能读到新的accnt1值和老的accnt2值,从而导致账户余额数据发生混乱。线程一旦检测到混乱的发生,便终止循环并打印交易的次数(counter)。 请编写出完整的程序代码并运行,然后观察产生混乱需要的时间长短。因为这是我们编写的第一个程序,因此这里我给出了完整的代码,请参考。有能力的同学在参考下面的代码之前,请先自己尝试一下。 #include "stdafx.h" #include

多线程同步操作多个窗口

多线程同步操作多个窗口 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

生产者和消费者问题

课程设计 题目生产者和消费者问题学院计算机科学与技术 专业 班级 姓名 指导教师吴利军 2013 年 1 月16 日

课程设计任务书 学生姓名: 指导教师:吴利军工作单位:计算机科学与技术学院题目: 进程同步模拟设计——生产者和消费者问题 初始条件: 1.预备内容:阅读操作系统的进程管理章节内容,对进程的同步和互斥,以及信号量机制度有深入的理解。 2.实践准备:掌握一种计算机高级语言的使用。 要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写 等具体要求) 1.模拟用信号量机制实现生产者和消费者问题。 2.设计报告内容应说明: ⑴需求分析; ⑵功能设计(数据结构及模块说明); ⑶开发平台及源程序的主要部分; ⑷测试用例,运行结果与运行情况分析; ⑸自我评价与总结: i)你认为你完成的设计哪些地方做得比较好或比较出色; ii)什么地方做得不太好,以后如何改正; iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训); iv)完成本题是否有其他方法(如果有,简要说明该方法); 时间安排: 设计安排一周:周1、周2:完成程序分析及设计。 周2、周3:完成程序调试及测试。 周4、周5:验收、撰写课程设计报告。 (注意事项:严禁抄袭,一旦发现,一律按0分记) 指导教师签名:年月日 系主任(或责任教师)签名:年月日

生产者-消费者问题(the producer-consumer problem) 1.需求分析 1.1问题描述: 一组生产者向一组消费者提供消息,它们共享一个有界缓冲区n,生产者向其中投放消息,消费者从中取得消息。 1.2规则: ?对于生产者进程:产生一个数据,当要送入缓冲区时,要检查缓冲区是否已满,若 未满,则可将数据送入缓冲区,并通知消费者进程;否则,等待; ?对于消费者进程:当它去取数据时,要看缓冲区中是否有数据可取,若有则取走一 个数据,并通知生产者进程,否则,等待。 ?缓冲区是个临界资源,因此,诸进程对缓冲区的操作程序是一个共享临界区,所以, 还有个互斥的问题。 1.3信号灯设置: 两个同步信号灯-- empty :表示空缓冲区的数目,初值为有界缓冲区的大小n; full :表示满缓冲区(即信息)的数目,其初值为0; 一个互斥信号灯-- mutex:互斥信号灯,初值为1。 1.4同步描述: 1.5程序描述: main( ) { int full=0;/* 满缓冲区的数目 */ int empty=n;/* 空缓冲区的数目 */ int mutex=1;/* 对有界缓冲区进行操作的互斥信号灯*/ cobegin p1 ( );p2( );

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

. 题目用多线程同步方法解决生产者-消费 者问题(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 指导教师签名:年月日

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; } 运行结果:

操作系统第二章进程和线程复习题

第二章练习题 一、单项选择题 1.某进程在运行过程中需要等待从磁盘上读入数据,此时该进程的状态将( C )。 A. 从就绪变为运行; B.从运行变为就绪; C.从运行变为阻塞; D.从阻塞变为就绪2.进程控制块是描述进程状态和特性的数据结构,一个进程( D )。 A.可以有多个进程控制块; B.可以和其他进程共用一个进程控制块; C.可以没有进程控制块; D.只能有惟一的进程控制块。 3.临界区是指并发进程中访问共享变量的(D)段。 A、管理信息 B、信息存储 C、数据 D、 程序 4. 当__ B__时,进程从执行状态转变为就绪状态。 A. 进程被调度程序选中 B. 时间片到 C. 等待某一事件 D. 等待的事件发生 5. 信箱通信是一种( B )通信方式。 A. 直接通信 B. 高级通信

C. 低级通信 D. 信号量 6. 原语是(B)。 A、一条机器指令 B、若干条机器指令组成 C、一条特定指令 D、中途能打断的指令 7. 进程和程序的一个本质区别是(A)。 A.前者为动态的,后者为静态的; B.前者存储在内存,后者存储在外存; C.前者在一个文件中,后者在多个文件中; D.前者分时使用CPU,后者独占CPU。 8. 任何两个并发进程之间存在着(D)的关系。 A.各自完全独立B.拥有共享变量 C.必须互斥D.可能相互制约 9. 进程从运行态变为等待态可能由于(B )。 A.执行了V操作 B.执行了P 操作 C.时间片用完 D.有高优先级进程就绪 10. 用PV操作管理互斥使用的资源时,信号量的初值应定义为(B)。 A.任意整数 B.1 C.0 D.-1

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

《操作系统》实验报告 生产者和消费者的问题 一、实验目的 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、设计一个环形缓冲区,大小为10,生产者依次向其中写入1到20,每个缓冲区中存放一个数字,消费者从中依次读取数字。 2、相应的信号量; 3、生产者和消费者可按如下两种方式之一设计; (1)设计成两个进程; (2)设计成一个进程内的两个线程。 4、根据实验结果理解信号量的工作原理,进程或线程的同步\互斥关系。 实验步骤及分析: 一.管道 (一)管道定义 所谓管道,是指能够连接一个写进程和一个读进程的、并允许它们以生产者—消费者方式进行通信的一个共享文件,又称为pipe文件。由写进程从管道的写入端(句柄1)将数据写入管道,而读进程则从管道的读出端(句柄0)读出数据。(二)所涉及的系统调用 1、pipe( ) 建立一无名管道。 系统调用格式 pipe(filedes) 参数定义 int pipe(filedes); int filedes[2]; 其中,filedes[1]是写入端,filedes[0]是读出端。 该函数使用头文件如下: #include #inlcude #include 2、read( ) : 系统调用格式 read(fd,buf,nbyte) 功能:从fd所指示的文件中读出nbyte个字节的数据,并将它们送至由指针buf 所指示的缓冲区中。如该文件被加锁,等待,直到锁打开为止。 参数定义:

int read(fd,buf,nbyte); int fd; char *buf; unsigned nbyte; 3、write( ) 系统调用格式 read(fd,buf,nbyte) 功能:把nbyte 个字节的数据,从buf所指向的缓冲区写到由fd所指向的文件中。如文件加锁,暂停写入,直至开锁。 参数定义同read( )。 (三)参考程序 #include #include #include int pid1,pid2; main( ) { int fd[2]; char outpipe[100],inpipe[100]; pipe(fd); /*创建一个管道*/ while ((pid1=fork( ))==-1); if(pid1==0) { lockf(fd[1],1,0); /*把串放入数组outpipe中*/ sprintf(outpipe,child 1 is using pipe!); /* 向管道写长为50字节的串*/ write(fd[1],outpipe,50); sleep(5); /*自我阻塞5秒*/ lockf(fd[1],0,0); exit(0); } else { while((pid2=fork( ))==-1); if(pid2==0) { lockf(fd[1],1,0); /*互斥*/ sprintf(outpipe,child 2 is using pipe!); write(fd[1],outpipe,50); sleep(5); lockf(fd[1],0,0);

相关文档
最新文档