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

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

.

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

者问题(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.设计目的与要求

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 the number of producer*/ #define NUM_THREADS_C 5 /*define the number of consumer*/ #define MAX_BUFFER 20 /*define the number of buffer*/ #define RUN_TIME 20 /*define the run time*/

int buffer[MAX_BUFFER]; /*difine the 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;

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

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操作,释放资源。

7.总结

通过本次课程设计,我巩固了使用多线程编程的方法,和使用信号量同步进/线程的技巧。本次课程设计的程序的运行结果跟预期的一致,说明该程序能顺利解决生产者消费者问题,实现了本次课程设计的目的。

另外,使我体会最深的是:任何一门知识的掌握,仅靠学习理论知识是远远不够的,要与实际动手操作相结合才能达到功效。短短的课程设计就要结束了,不但对专业知识有了更深的理解,更使自己认识到实践的重要性,理论、实践相结合才能达到很好的学习效果,特别是程序语言的学习。

单纯的课本内容,并不能满足学生的需要,通过补充,达到内容的完善

教育之通病是教用脑的人不用手,不教用手的人用脑,所以一无所能。教育革命的对策是手脑联盟,结果是手与脑的力量都可以大到不可思议。

《操作系统》练习题及参考答案

《操作系统》练习题及参考答案 一、单项选择题(每小题1分,共15分) 1.操作系统是一种() A.系统软件 B.系统硬件 C.应用软件 D.支援软件 2.MS—DOS的存贮管理采用了() A.段式存贮管理 B.段页式存贮管理 C.单用户连续存贮管理 D.固定式分区存贮管理 3.用户程序在目态下使用特权指令将引起的中断是属于() A.硬件故障中断 B.程序中断 C.外部中断 D.访管中断 4.MS—DOS中用于软盘整盘复制的命令是() https://www.360docs.net/doc/1a14985484.html,P B.DISKCOPY C.SYS D.BACKUP 5.位示图方法可用于() A.盘空间的管理 B.盘的驱动调度 C.文件目录的查找 D.页式虚拟存贮管理中的页面调度 6.下列算法中用于磁盘移臂调度的是() A.时间片轮转法 B.LRU算法 C.最短寻找时间优先算法 D.优先级高者优先算法 7.在以下存贮管理方案中,不适用于多道程序设计系统的是() A.单用户连续分配 B.固定式分区分配 C.可变式分区分配 D.页式存贮管理 8.已知,作业的周转时间=作业完成时间-作业的到达时间。现有三个同时到达的作业J1,J2和J3,它们的执行时间分别是T1,T2和T3,且T1 A.T1+T2+T3 B.(T1+T2+T3) C.T1+T2+T3 D. T1+T2+T3 9.任何两个并发进程之间() A.一定存在互斥关系 B.一定存在同步关系 C.一定彼此独立无关 D.可能存在同步或互斥关系 10.进程从运行状态进入就绪状态的原因可能是() A.被选中占有处理机 B.等待某一事件 C.等待的事件已发生 D.时间片用完

11.用磁带作为文件存贮介质时,文件只能组织成() A.顺序文件 B.链接文件 C.索引文件 D.目录文件 12.一作业8:00到达系统,估计运行时间为1小时,若10:00开始执行该作业,其响应比是() A.2 B.1 C.3 D.0.5 13.多道程序设计是指() A.在实时系统中并发运行多个程序 B.在分布系统中同一时刻运行多个程序 C.在一台处理机上同一时刻运行多个程序 D.在一台处理机上并发运行多个程序 14.文件系统采用多级目录结构后,对于不同用户的文件,其文件名() A.应该相同 B.应该不同 C.可以相同,也可以不同 D.受系统约束 15.在可变式分区分配方案中,某一作业完成后,系统收回其主存空间,并与相邻空闲区合并,为此需修改空闲区表,造成空闲区数减1的情况是() A.无上邻空闲区,也无下邻空闲区 B.有上邻空闲区,但无下邻空闲区 C.有下邻空闲区,但无上邻空闲区 D.有上邻空闲区,也有下邻空闲区 二、双项选择题(每小题2分,共16分) 1.能影响中断响应次序的技术是()和()。 A.时间片 B.中断 C.中断优先级 D.中断屏蔽 E.特权指令 2.文件的二级目录结构由()和()组成。 A.根目录 B.子目录 C.主文件目录 D.用户文件目录 E.当前目录 3.驱动调度算法中()和()算法可能会随时改变移动臂的运动方向。 A.电梯调度 B.先来先服务 C.扫描 D.单向扫描 E.最短寻找时间优先 4.有关设备管理概念的下列叙述中,()和()是不正确的。 A.通道是处理输入、输出的软件 B.所有外围设备的启动工作都由系统统一来做 C.来自通道的I/O中断事件由设备管理负责处理 D.编制好的通道程序是存放在主存贮器中的 E.由用户给出的设备编号是设备的绝对号

操作系统课程设计报告书

题目1 连续动态内存管理模拟实现 1.1 题目的主要研究内容及预期达到的目标 (1)针对操作系统中内存管理相关理论进行设计,编写程序并进行测试,该程序管理一块虚拟内存。重点分析三种连续动态内存分配算法,即首次适应算法、循环首次适应算法和最佳适应算法。 (2)实现内存分配和回收功能。 1.2 题目研究的工作基础或实验条件 (1)硬件环境:PC机 (2)软件环境:Windows XP,Visual C++ 6.0 1.3 设计思想 首次适应算法的实现:从空闲分区表的第一个表目起查找该表,把最先能够满足要求的空闲区分配给作业,这种方法的目的在于减少查找时间。为适应这种算法,空闲分区表中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区,在低址空间造成许多小的空闲区,在高址空间保留大的空闲区。 循环首次适应算法的实现:在分配内存空间时,不再每次从表头开始查找,而是从上次找到空闲区的下一个空闲开始查找,直到找到第一个能满足要求的的空闲区为止,并从中划出一块与请求大小相等的内存空间分配给作业。该算法能使内存中的空闲区分布得较均匀。 最佳适应算法的实现:从全部空闲区中找到能满足作业要求的、且最小的空闲分区,这种方法能使碎片尽量小。为适应此算法,空闲分区表中的空闲分区要按从小到大进行排序,从表头开始查找第一个满足要求的自由分配。 1.4 流程图 内存分配流程图,如图1-1所示。

图1-1 内存分配流程图内存回收流程图,如1-2所示。

图1-2 内存回收流程图 1.5 主要程序代码 (1)分配内存 void allocate(char z,float l) { int i,k; float ad; k=-1; for(i=0;i= l && free_table[i].flag == 1) if(k==-1 || free_table[i].length

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

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

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

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

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

操作系统课程设计报告

操作系统课程设计报告

东莞理工学院 操作系统课程设计报告 学院:计算机学院 专业班级: 13软件工程1班 提交时间: 2015/9/14 指导教师评阅意见: . 项目名称:进程与线程管理功能 一、设计目的 用语言来模拟进程和线程管理系统,加深对进程和线程的理解,掌握对进程和线程各种状态和管理的算法原理。

二、环境条件 系统: WindowsXP、VMWare、Ubuntu Linux 语言:C/C++ 开发工具:gcc/g++、Visual C++ 6.0 三、设计内容 1. 项目背景 计算机的硬件资源有限,为了提高内存的利用率和系统的吞吐量,就要根据某种算法来管理进程和线程的状态从而达到目的。 进程与线程管理功能完成基于优先级的抢占式线程调度功能,完成进程虚拟内存管理功能。 进程与线程管理功能 基本要求:完成基于优先级的抢占式线程调度功能,完成进程虚拟内存管理功能。 提高要求:(增加1项就予以加分) (1) 实现多种线程调度算法; (2)通过“公共信箱”进行通信的机制,规定每一封信的大小为128字节,实现两个用户进程之间通过这个“公共信箱”进行通信。 (3) 实现多用户进程并发的虚拟内存管理功能。

(4) 实现用户进程间通信功能,并用生产者/消费者问题测试进程间通信功能的正确性。 (5) 实现改进型Clock页面置换算法。 (6) 实现Cache功能,采用FIFO替换算法。 2. 扩展内容 实现多种线程调度算法:时间片轮转调度算法 四、人员分工 优先级调度算法:钟德新,莫友芝 时间片轮转调度算法:张德华,袁马龙 设计报告由小组队员共同完成。小组成员设计的代码分工如下:钟德新编写的代码:void Prinft(){ PCB *p; system("cls");//清屏 p=run; //运行队列 if(p!=NULL) { p->next=NULL; } cout<<"当前正在运行的进程:"<procname<<"\t\t"<pri<<"\t"<needOftime<<"\t\t"<runtime<<"\t\t"<state<next; } cout<

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

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

操作系统课程设计报告

上海电力学院 计算机操作系统原理 课程设计报告 题目名称:编写程序模拟虚拟存储器管理 姓名:杜志豪.学号: 班级: 2012053班 . 同组姓名:孙嘉轶 课程设计时间:—— 评语: 成绩: 目录 一、设计内容及要求 (4) 1. 1 设计题目 (4) 1.2 使用算法分析: (4)

1. FIFO算法(先进先出淘汰算法) (4) 1. LRU算法(最久未使用淘汰算法) (5) 1. OPT算法(最佳淘汰算法) (5) 分工情况 (5) 二、详细设计 (6) 原理概述 (6) 主要数据结构(主要代码) (6) 算法流程图 (9) 主流程图 (9) Optimal算法流程图 (10) FIFO算法流程图 (10) LRU算法流程图 (11) .1源程序文件名 (11) . 2执行文件名 (11) 三、实验结果与分析 (11) Optimal页面置换算法结果与分析 (11) FIFO页面置换算法结果与分析 (16) LRU页面置换算法结果与分析 (20) 四、设计创新点 (24) 五、设计与总结 (27)

六、代码附录 (27) 课程设计题目 一、设计内容及要求 编写程序模拟虚拟存储器管理。假设以M页的进程分配了N

块内存(N

操作系统课程练习题

操作系统复习总结1 一、简答题 1、设计现代OS的主要目标是什么?(P1) (1)有效性(2)方便性(3)可扩充性(4)开放性 2、同步机制应遵循哪些基本准则?(P50) (1) 空闲让进。(2) 忙则等待。(3) 有限等待。(4) 让权等待。 3、多道程序环境下,存在哪两种形式的制约关系?(P47) (1)间接相互制约关系(2)直接相互制约关系 4、产生死锁的原因及必要条件 原因:(1)竞争资源(2)进程间推进顺序非法 必要条件:(1) 互斥条件(2) 请求和保持条件(3) 不剥夺条件(4) 环路等待条件 5、如何实现连续分配方式下的动态重定位? 要在不影响指令执行速度的同时实现地址变换,必须有硬件地址变换机构的支持,即须在系统中增设一个重定位寄存器,用它来存放程序在内存中的起始地址。程序在执行时,真正访问的内存地址是相对地址与重定位寄存器中的地址相加而形成的。 6、设备驱动程序要完成哪些工作 (1) 将抽象要求转换为具体要求. (2) 检查I/O请求的合法性(3)读出和检查设备的状态(4)传送必要的参数(5)工作方式的设置(6)启动I/O设备 7、文件系统管理的对象。 ①文件。②目录。③磁盘(磁带)存储空间。 8、什么是终端回送显示? 终端回送显示(回显)是指每当用户从键盘输入一个字符后,终端处理程序便将该字符送往屏幕显示。 二、I/O软件设计的重要目标和重要准则是什么?I/O软件应达到哪六个具体目标? 重要目标:从系统的观点出发,采用多种技术和措施,解决由于外部设备与CPU速度不匹配所引起的问题,提高主机和外设的并行工作能力,提高系统效率,成为操作系统的一个重要目标。 重要准则:设法消除或屏蔽设备硬件内部的低级处理过程,为用户提供一个简便、易用、抽象的逻辑设备接口,保证用户安全、方便地使用各类设备,也是I/O软件设计的一个重要原则。 具体目标: 1) 与具体设备无关2) 统一命名3) 对错误的处理4) 缓冲技术 5) 设备的分配和释放6) I/O控制方式 四、文件系统模型示意图并介绍这几部分的功能。 示意图 1) 对象及其属性

操作系统课程设计实验报告

河北大学工商学院 课程设计 题目:操作系统课程设计 学部信息学部 学科门类电气信息 专业计算机 学号2011482370 姓名耿雪涛 指导教师朱亮 2013 年6月19日

主要内容 一、设计目的 通过模拟操作系统的实现,加深对操作系统工作原理理解,进一步了解操作系统的实现方法,并可练习合作完成系统的团队精神和提高程序设计能力。 二、设计思想 实现一个模拟操作系统,使用VB、VC、CB等windows环境下的程序设计语言,以借助这些语言环境来模拟硬件的一些并行工作。模拟采用多道程序设计方法的单用户操作系统,该操作系统包括进程管理、存储管理、设备管理、文件管理和用户接口四部分。 设计模板如下图: 注:本人主要涉及设备管理模块

三、设计要求 设备管理主要包括设备的分配和回收。 ⑴模拟系统中有A、B、C三种独占型设备,A设备1个,B设备2个,C设备2个。 ⑵采用死锁的预防方法来处理申请独占设备可能造成的死锁。 ⑶屏幕显示 注:屏幕显示要求包括:每个设备是否被使用,哪个进程在使用该设备,哪些进程在等待使用该设备。 设备管理模块详细设计 一、设备管理的任务 I/O设备是按照用户的请求,控制设备的各种操作,用于完成I/O 设备与内存之间的数据交换(包括设备的分配与回收,设备的驱动管理等),最终完成用户的I/O请求,并且I/O设备为用户提供了使用外部设备的接口,可以满足用户的需求。 二、设备管理函数的详细描述 1、检查设备是否可用(主要代码) public bool JudgeDevice(DeviceType type) { bool str = false; switch (type) { case DeviceType.a: {

生产者和消费者问题

班级姓名:学号:成绩: 实验名称: 生产者和消费者问题 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. 用P、V操作管理临界区时,信号量的初值一般应定义为( )。 A.–1 B.0 C.1 D.任意值 2. 有m个进程共享同一临界资源,若使用信号量机制实现对一临界资源的互斥访问, 则信号量的变化范围是( )。 A.1至–(m-1) B.1至m-1 C.1至–m D.1至m 3. 在下面的叙述中,正确的是( )。 A.临界资源是非共享资源 B.临界资源是任意共享资源 C.临界资源是互斥共享资源 D.临界资源是同时共享资源 4. 对进程间互斥地使用临界资源,进程可以( ) A.互斥地进入临界区 B.互斥地进入各自的临界区 C.互斥地进入同一临界区 D.互斥地进入各自的同类资源的临界区 5. 设两个进程共用一个临界资源的互斥信号量mutex,当mutex,1时表示( )。 A.一个进程进入了临界区,另一个进程等待 B.没有一个进程进入临界区 C.两个进程都进入了临界区 D.两个进程都在等待 6. 设两个进程共用一个临界资源的互斥信号量mutex,当mutex,-1时表示( )。 A.一个进程进入了临界区,另一个进程等待

B.没有一个进程进入临界区 C.两个进程都进入了临界区 D.两个进程都在等待 7(当一进程因在记录型信号量S上执行P(S)操作而被阻塞后,S的值为( )。 A.>0 B.<0 C.?0 D.?0 8(当一进程因在记录型信号量S上执行V(S)操作而导致唤醒另一进程后,S的值为 ( )。 A.>0 B.<0 C.?0 D.?0 9(如果信号量的当前值为-4,则表示系统中在该信号量上有( )个进程等待。 A.4 B.3 C.5 D.0 10(若有4个进程共享同一程序段,而且每次最多允许3个进程进入该程序段,则信号 量的变化范围是( )。 A. 3,2,1,0 B. 3,2,1,0,-1 C. 4,3,2,1,0 D. 2,1,0,-1,-2 11(若信号S的初值为2,当前值为-1,则表示有( )个等待进程, A.0 B.1 C.2 D.3 12(如果有三个进程共享同一互斥段,而且每次最多允许两个进程进入该互斥段,则信 号量的初值应设置为( )。 A. 3 B. 1 C. 2 D. 0 13(并发进程之间( ) A.彼此无关 B.必须同步 C.必须互斥 D.可能需要同步或互斥 14(在操作系统中,有一组进程,进程之间具有直接相互制约性。这组并发进程之间( )。

操作系统课程设计报告

东莞理工学院 操作系统课程设计报告学院:计算机学院 专业班级:13软件工程1班 提交时间:2015/9/14 指导教师评阅意见: . 项目名称:进程与线程管理功能 一、设计目的 用语言来模拟进程和线程管理系统,加深对进程和线程的理解,掌握对进程和线程各种状态和管理的算法原理。 二、环境条件 系统:WindowsXP、VMWare、Ubuntu Linux 语言:C/C++ 开发工具:gcc/g++、Visual C++ 6.0 三、设计内容 1. 项目背景

计算机的硬件资源有限,为了提高内存的利用率和系统的吞吐量,就要根据某种算法来管理进程和线程的状态从而达到目的。 进程与线程管理功能完成基于优先级的抢占式线程调度功能,完成进程虚拟内存管理功能。 进程与线程管理功能 基本要求:完成基于优先级的抢占式线程调度功能,完成进程虚拟内存管理功能。 提高要求:(增加1项就予以加分) (1) 实现多种线程调度算法; (2)通过“公共信箱”进行通信的机制,规定每一封信的大小为128字节,实现两个用户进程之间通过这个“公共信箱”进行通信。 (3) 实现多用户进程并发的虚拟内存管理功能。 (4) 实现用户进程间通信功能,并用生产者/消费者问题测试进程间通信功能的正确性。 (5) 实现改进型Clock页面置换算法。 (6) 实现Cache功能,采用FIFO替换算法。 2. 扩展内容 实现多种线程调度算法:时间片轮转调度算法 四、人员分工 优先级调度算法:钟德新,莫友芝 时间片轮转调度算法:张德华,袁马龙 设计报告由小组队员共同完成。小组成员设计的代码分工如下: 钟德新编写的代码:void Prinft(){ PCB *p; system("cls");//清屏 p=run; //运行队列 if(p!=NULL) { p->next=NULL; } cout<<"当前正在运行的进程:"<procname<<"\t\t"<pri<<"\t"<needOftime<<"\t\t"<runtime<<"\t\t"<state<next; } cout<procname<<"\t\t"<pri<<"\t"<needOftime<<"\t\t"<runtime<<"\t\t"<state<next; } cout<

生产者和消费者问题

课程设计 题目生产者和消费者问题学院计算机科学与技术 专业 班级 姓名 指导教师吴利军 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( );

操作系统课程设计报告

课程设计报告课程名称:操作系统原理 院系:计算机科学与技术 专业班级: CS140 ____ __ 学号: U201414_____ 姓名: ______ ___ 指导教师: _______ __ 完成时间: 2017年3月11日_

目录 1实验目的 (2) 2实验环境 (2) 3实验内容 (2) 3.1实验一 (2) 3.2实验二 (2) 3.3实验三 (3) 3.4实验四 (3) 3.5实验五(选做) (3) 4设计与实现 (3) 4.1实验一 (3) 4.2实验二 (6) 4.3实验三 (9) 4.4实验四 (11) 5心得体会 (14)

1 实验目的 ·掌握Linux操作系统的使用方法; ·了解Linux系统内核代码结构; ·掌握实例操作系统的实现方法; 2 实验环境 本次课程设计采用的操作系统环境是windows10、Ubuntu双系统,Ubuntu系统版本号为16.04,内核版本号为linux 4.4.4;前两个实验在当前Ubuntu环境下完成,后两个实验在win10下虚拟机VirtualBox的Ubuntu 15.10(内核为linux4.2.0-42)中完成。 3 实验内容 3.1 实验一 要求熟悉和理解Linux下的编程环境。 (1)编写一个C程序,用fread、fwrite等库函数实现文件拷贝功能。 (2)编写一个C程序,使用基于文本的终端图形编程库(curses)或图形界面(QT/GTK),分窗口显示三个并发进程的运行(一个窗口实时显示当前时间,一个窗口实时监测CPU的利用率,一个窗口做1到100的累加求和,刷新周期分别为1秒,2秒和3秒)。 3.2 实验二 要求掌握添加系统调用的方法,采用编译内核方法,添加一个新的系统调用,实现文件拷贝的功能,另外编写一个应用程序,测试新增加的系统调用。

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

《操作系统》实验报告 生产者和消费者的问题 一、实验目的 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.程序结构图:

操作系统同步例题

13. 对于生产者—消费者问题,假设缓冲区是无界的,试用信号灯与PV操作给出解法。答:由于是无界缓冲区,所以生产者不会因得不到缓冲区而被阻塞,不需要对空缓冲区进行管理,可以去掉在有界缓冲区中用来管理空缓冲区的信号量及其PV操作。 semaphore mutex_in=1; semaphore mutex_out=1; semaphore empty=0; int in=0,out=0; 生产者活动: while(1){ produce next product; P(mutex_in); add the product to buffer[in]; in++; v(mutex_in); V(empty); } 消费者活动: while(1){ P(empty); P(mutex_out); take the product from buffer[out]; out++; V(mutex_out); } 14. 设有一个可以装A、B两种物品的仓库,其容量无限大,但要求仓库中A、B两种物品的数量满足下述不等式: -M≤A物品数量-B物品数量≤N 其中M和N为正整数。试用信号灯和PV操作描述A、B两种物品的入库过程。 答:已知条件 -M≤A物品数量-B物品数量≤N 可以拆成两个不等式,即 A物品数量-B物品数量≤N,

B物品数量-A物品数量≤M。 这两个不等式的含义是:仓库中A物品可以比B物品多,但不能超过N个;B物品可以比A 物品多,但不能超过M个。 semaphore a=n; semaphore b=m; void main(){ createprocess(A,…); createprocess(B,…); } A物品入库:void A(){ while(1){ P(a); A物品入库; V(b); } }B物品入库:void B(){ while(1){ P(b); B物品入库; V(a); } } 15. 试用信号灯与PV操作实现司机与售票员之间的同步问题。设公共汽车上有一个司机和一个售票员,其活动如下图 所示。

相关文档
最新文档