计算机操作系统课程设计报告.docx
《计算机操作系统课程设计报告.docx》由会员分享，可在线阅读，更多相关《计算机操作系统课程设计报告.docx（17页珍藏版）》请在冰豆网上搜索。
计算机操作系统课程设计报告
操
作
系
统
设
计
报
告
姓名：
韦
学号：
5
日期：
2013年12月30日
第1章需求分析
1.1设计题目
用多线程同步方法解决生产者－消费者问题
1.2设计目的
1.通过编程实现生产者与消费者问题，了解进程同步的概念，理解信号量机制的原理。
2.掌握运用信号量解决进程同步问题的方法，学会运用进程的同步于互斥结局生产者与消费者的冲突问题。
3.通过研究Linux的线程机制和信号量实现生产者消费者问题的并发控制。
1.3设计环境与工具
1.3.1设计环境
Fedora10操作系统
1.3.2设计工具
Vi编辑器，gcc编译器
1.4设计要求
1.有界缓冲区设有20个存储单元，放入/取出的数据项设定为1-20这20个整型数。
2.每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部容、当前指针位置和生产者/消费者线程的标识符。
3.生产者和消费者各有两个以上。
4.多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。
第2章概要设计
2.1设计容与原理
2.1.1设计容
在同一个进程地址空间执行的两个线程，生产者生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品，然后释放缓冲区，当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区，当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，知道新的物品被生产出来，我的具体做法也是如此，建立缓冲区，生产者生产的产品放入，消费者从中取产品，如果没有产品，则等待。
2.1.2设计原理
要实现生产者与消费者的互斥关系，生产者和消费者进程之间必须满足两个同步条件：
1.只有在缓冲池中至少有一个缓冲区已存入消息后，消费者才可以从中提取消息，否则消费者必须等待。
2.只有缓冲池中至少有一个缓冲区是空时，生产者才可以把消息放入缓冲区中，否则生产者必须等待。
要满足第一个同步条件，设置一个同步信号量full_sem，它的值为20时整个缓冲区满，这个资源是消费者进程所拥有，消费者进程可以申请资源，对它做P操作；另外一个信号量empty_sem，它的初值为20，表示整个缓冲区都是空的。
可以用full_sem表示空缓冲区数量，empty_sem表示满缓冲区数量，另外有界缓冲区是一个临界资源，必须互斥使用，所以必须再设置一个互斥信号量mux，初值为1。
在生产者/消费者问题中，信号量实现两种功能，首先，它是跟踪资源的生产和消费的计数器，其次，它是协调产品的生产者和消费者之间动作同步的同步器。
消费者通过再一指派给它的信号量上做P操作来表示消耗资源，而生产者通过再同一个信号量上做V操作来表示生产资源。
而这种信号量的实施中，计数在每次P操作后减1，而在每次V操作后加1。
这个计数器的初始值是可利用的资源数目，当资源是不可利用时，将申请资源的进程防止在等待队列中，如果有一个资源释放，在等待队列中的第一个进程被唤醒并得到资源的控制权。
假定在生产者和消费者之间的公用缓冲区中，具有n个缓冲区，这时可以利用互斥信号量mutex实现诸进程对缓冲区的互斥使用，利用信号量empty和full分别表示缓冲池中空缓冲区和满缓冲区的数量，又假定这些生产者和消费者互相等效果，只要缓冲区未满，生产者便可以将消息送入缓冲池，只要缓冲池未空，消费者便可以从缓冲池中取走一个消息。
2.2程序流程图
图2.1生产者流程图
是否有数据单元
是否可用
取走一条数据
归还使用权
空单元加1，唤醒一个生产者
消费数据
等待资源，阻塞
被唤醒
等待使用权，阻塞
被唤醒
有
是
否
图2.2消费者流程图
第3章详细设计
3.1数据结构
#defineN2//消费者或者生产者的数目
#defineM10//缓冲数目
intin=0;//生产者放置产品的位置
intout=0;//消费者取产品的位置
intbuff[M]={0};//缓冲初始化为0，开始时没有产品
sem_tempty_sem;//同步信号量，当满了时阻止生产者放产品
sem_tfull_sem;//同步信号量，当没产品时阻止消费者消费
pthread_mutex_tmutex;//互斥信号量，一次只有一个线程访问缓冲
intproduct_id=0;//生产者id
intprochase_id=0;//消费者id
3.2算法说明
3.2.1同步机制原语算法
P进程不能往“满”的缓冲区中放产品，设置信号量为sem_empty；
Q进程不能从“空”的缓冲区中取产品，设置信号量为sem_full。
先设置信号量：
sem_empty初值为1，sem_full初值为0
实现原语如下：
P：
Q:
While（true）while（true）
{{
生产一个产品；P（sem_full）；
P（Sem_empty）;从缓冲区去产品
送产品到缓冲区；V（sem_empty）;
V（sem_full）;消费产品；
}}
P原语操作的主要动作是：
1.sem减1；
2.若sem减1后仍大于或等于零，则进程继续执行；
3.若sem减1后仍小于零，则该进程被阻塞后与该信号所对应的队列中，然后转入进程调度；
V原语操作的主要动作时：
1．Sem加1；
2.若相加结果大于零；
3.若相加结果小于或者等于零，则从该信号的等待队列中唤醒一等待队列，然后再返回原进程继续执行或转入进程调度。
3.2.2具体算法实现
Semaphoremutex=1;//定义互斥信号量
Semaphoreempty=n;//定义同步信号量
Semaphorefull=0;
item[n];//定义缓冲池
Intin=0;//生产者放置位置
Intout=0;//消费者放置位置
Producer（）//生产者
{
While（true）
{
Produceaniteminnext_product;//生产者产生数据
Swait（empty,mutex）;//等待缓冲区空信号量
Array[in]=next_product;//将数据放入缓冲池
In=（in+1）%n;
Ssignal（mutex,full）;
}
}
Consumer（）//消费者
{
While（true）
{
Swait（full,mutex）;//等待缓冲池满信号量
Next_consumer=array[out];//从缓冲池取出数据
Out=（out+1）%n;
Ssignal（mutex,empty）;
Consumetheproductinnext_consumer;//等待下一个消费者取出数据
}
}
3.3具体程序实现
3.3.1生产者方法
在生产者方法的实现中，先产生一个数据，然后判断缓冲池空信号量，如果缓冲池至少有一个为空则将先将缓冲池上锁，然后将数据放入缓冲池，将放入数据位置指针后移，放入数据后将缓冲池解锁；如果缓冲池为满，则生产者线程进入阻塞状态，进入进程调度队列，并等待缓冲池空信号量。
/*生产者方法*/
void*product（）
{
intid=++product_id;
while
（1）
{
//用sleep的数量可以调节生产和消费的速度，便于观察
sleep
（1）;
//sleep
（1）;
sem_wait（&empty_sem）;//等待缓冲池空信号量
pthread_mutex_lock（&mutex）;//对缓冲池上锁
in=in%M;
printf（"product%din%d.like:
\t",id,in）;//显示生产者ID
buff[in]=1;//将数据放入缓冲区
print（）;//打印存数结果
++in;//写入位置指针后移
pthread_mutex_unlock（&mutex）;//对缓冲池解锁
sem_post（&full_sem）;//等待缓冲池满信号量
}
}
3.3.2消费者方法
在消费者方法实现中，首先判断缓冲池满信号量，如果缓冲池中不为空，则进行取数操作，并对缓冲池上锁，取数后，显示消费者ID，随后对缓冲池解锁；如果缓冲池为空，则不对缓冲池操作，消费者线程进入阻塞状态，进入线程调度队列。
/*消费者方法*/
void*prochase（）
{
intid=++prochase_id;
while
（1）
{
//用sleep的数量可以调节生产和消费的速度，便于观察
sleep
（1）;
//sleep
（1）;
sem_wait（&full_sem）;//等待缓冲池满指针
pthread_mutex_lock（&mutex）;//对缓冲池上锁
out=out%M;
printf（"prochase%din%d.like:
\t",id,out）;//答应消费者ID
buff[out]=0;
print（）;//答应信息
++out；//取数指针后移
pthread_mutex_unlock（&mutex）;//对缓冲池解锁
sem_post（&empty_sem）;
}
}
3.3.3多线程实现
在线程的创建时，可以用函数pthread_create用来创建一个线程，它的原型为：
intpthread_create__P（（pthread_t*__thread,__constpthread_attr_t*__attr,void*（*__start_routine）（void*）,void*__arg））;
第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。
这里，我们的函数thread不需要参数，所以最后一个参数设为空指针。
第二个参数我们也设为空指针，这样将生成默认属性的线程
函数pthread_join用来等待一个线程的结束。
函数原型为：
externintpthread_join__P（（pthread_t__th,void**__thread_return））;
第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。
这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。
一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数pthread_exit来实现。
它的函数原型为：
externvoidpthread_exit__P（（void*__retval））__attribute__（（__noreturn__））;
唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。
最后要说明的是，一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread_join的线程则返回错误代码ESRCH。
//创建N个生产者线程
for（i=0;i{
ret[i]=pthread_create（&id1[i],NULL,product,（void*）（&i））;//将生产者方法创建成线程
if（ret[i]!
=0）
{
printf（"product%dcreationfailed\n",i）;//打印线程创建信息
exit
（1）;
}
}
//创建N个消费者线程
for（i=0;i{
ret[i]=pthread_create（&id2[i],NULL,prochase,NULL）;//将消费者方法创建成线程
if（ret[i]!
=0）
{
printf（"prochase%dcreationfailed\n",i）;//打印消费者线程创建信息
exit
（1）;
}
}
//销毁线程
for（i=0;i{
pthread_join（id1[i],NULL）;
pthread_join（id2[i],NULL）;
}
exit（0）;
}
第4章程序运行结果和分析
4.1运行结果
4.2结果分析
从运行结果截图中可以看到：
程序创建了5个生产者线程，4个消费者线程。
每次生产者线程产生一个数据并存入缓冲池中，每次消费者线程从缓冲池中取出一个数，并且在每次生产者线程产生数据和消费者取出数据后都打印缓冲区中的数据。
第5章总结与体会
经过快一个星期的努力，终于完成了这个课程设计，从刚开始看到这个课程设计题目时的毫无头绪到最后实现算法和完成课程设计报告，遇到了很多的困难。
在平时操作系统的课上，老师也是主要讲解操作系统的原语算法和实现原理，没有用具体语言实现，突然要求我们用一门具体语言实现生产者消费者算法，一时有点举手无措的感觉。
但是后来通过自己仔细分析课程设计要求，发现课程设计的算法其实可以分为几个模块，并且每个模块都有很大的联系，比如生产者的实现和消费的实现就是信号量的操作不同，于是自己下去后通过仔细学习关于生产者消费者算法的实现和机制，终于理解了生产者消费者算法实现的难点和关键，并通过在图书馆和网上查阅资料，也对用LinuxC实现生产者消费者算法有了一点大概的思路。
在后来的实现算法的过程中也遇到了很多的困难，比如在算法中对两个信号量的操作和多线程的实现。
通过对LinuxC的学习，我也知道了一些LinuxC的信号量操作函数和信号量上锁函数，还有多线程操作中的创建线程和销毁线程的函数，通过认真学习相关函数的调用方法和参数传递方法，终于解决了设计中的困难。
通过这次课程设计，自己也是受益匪浅，因为平时学到的大部分都是理论知识，而课程设计就是将我们的理论应用到实践的过程，通过这个过程，也让我们锻炼了自己的动手能力，也加深了我们对理论知识的理解，提高了我们对操作系统这门课程的认识和理解，也加强了我们的学习效果。
附录：
源程序
#include
#include
#include
#include
#include
#defineN2//消费者或者生产者的数目
#defineM10//缓冲数目
intin=0;//生产者放置产品的位置
intout=0;//消费者取产品的位置
intbuff[M]={0};//缓冲初始化为0，开始时没有产品
sem_tempty_sem;//同步信号量，当满了时阻止生产者放产品
sem_tfull_sem;//同步信号量，当没产品时阻止消费者消费
pthread_mutex_tmutex;//互斥信号量，一次只有一个线程访问缓冲
intproduct_id=0;//生产者id
intprochase_id=0;//消费者id
/*打印缓冲情况*/
voidprint（）
{
inti;
for（i=0;iprintf（"%d",buff[i]）;
printf（"\n"）;
}
/*生产者方法*/
void*product（）
{
intid=++product_id;
while
（1）
{
//用sleep的数量可以调节生产和消费的速度，便于观察
sleep
（1）;
//sleep
（1）;
sem_wait（&empty_sem）;
pthread_mutex_lock（&mutex）;
in=in%M;
printf（"product%din%d.like:
\t",id,in）;
buff[in]=1;
print（）;
++in;
pthread_mutex_unlock（&mutex）;
sem_post（&full_sem）;
}
}
/*消费者方法*/
void*prochase（）
{
intid=++prochase_id;
while
（1）
{
//用sleep的数量可以调节生产和消费的速度，便于观察
sleep
（1）;
//sleep
（1）;
sem_wait（&full_sem）;
pthread_mutex_lock（&mutex）;
out=out%M;
printf（"prochase%din%d.like:
\t",id,out）;
buff[out]=0;
print（）;
++out;
pthread_mutex_unlock（&mutex）;
sem_post（&empty_sem）;
}
}
intmain（）
{
pthread_tid1[N];
pthread_tid2[N];
inti;
intret[N];
//初始化同步信号量
intini1=sem_init（&empty_sem,0,M）;
intini2=sem_init（&full_sem,0,0）;
if（ini1&&ini2!
=0）
{
printf（"seminitfailed\n"）;
exit
（1）;
}
//初始化互斥信号量
intini3=pthread_mutex_init（&mutex,NULL）;
if（ini3!
=0）
{
printf（"mutexinitfailed\n"）;
exit
（1）;
}
//创建N个生产者线程
for（i=0;i{
ret[i]=pthread_create（&id1[i],NULL,product,（void*）（&i））;
if（ret[i]!
=0）
{
printf（"product%dcreationfailed\n",i）;
exit
（1）;
}
}
//创建N个消费者线程
for（i=0;i{
ret[i]=pthread_create（&id2[i],NULL,prochase,NULL）;
if（ret[i]!
=0）
{
printf（"prochase%dcreationfailed\n",i）;
exit
（1）;
}
}
//销毁线程
for（i=0;i{
pthread_join（id1[i],NULL）;
pthread_join（id2[i],NULL）;
}
exit（0）;
}
升级会员 