操作系统课程设计用多线程同步方法解决生产者 (1)

临界区管理实现
本组组员：周琪皓，董泉伟，钟佳锋，张倬慎
0 引言
随着多处理机体系结构的演变和分布式与并行系统的发展，并发多任务的程序设计技术已愈来愈显得重要，多线程设计模式在这些技术的发展中起着重要作用。

在现代操作系统中，利用进(线)程间的并发性实现程序中并发成分的并行执行，可大大提高系统的处理能力和效率，但也可能带来诸如执行结果的不确定性等不良现象，因此并发系统中处理好进(线)程间的互斥与同步就显得至关重要。

C++语言中的多线程机制是解决线程间的互斥与同步问题的重要工具，其应用(如网络多媒体应用、工业自动化控制等)很广泛，很复杂且常易出错。

因此在应用程序设计过程中，要考虑多个线程如何同步使用进程的共享资源，如何让一个线程与另一个线程协调合作，以免产生线程间的访问冲突。

语言提供的多线程机制能有避免同一共享互斥资源被多个线程同时访问，维护数据的一致性、安全性。

生产者/消费者问题可作为并发进程的同步和互斥问题的一个抽象模型，广泛应用于通信和控制系统中。

本文基于C++语言中的多线程机制，实现操作系统中生产者/消费者问题，以助人们更好地透解同步概念及其实现方法。

1 课程设计目的
通过模拟操作者生产者经典问题的实现，以及关于信号量和互斥锁对于多线程的运用，深入理解操作系统中多线程同步法的理论知识, 加深对教材中的重要算法的理解。

同时通过编程实现这些算法,更好地掌握操作系统的原理及实现方法,提高综合运用各专业课知识的能力。

2 课程设计题目和要求
2.1 课程设计题目
题目: 临界区管理实现.
2.2课程设计目的与要求
初始条件：
1.操作系统：Windows
2.程序设计语言：C++语言
3.有界缓冲区内设有20个存储单元，其初值为0。

放入／取出的数据项按增序设定为1－20这20个整型数。

技术要求：
1、生产者和消费者各有两个以上。

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

每个生产者和消费者对有界缓冲
区进行操作后，即时显示有界缓冲区的全部内
容，当前指针位置。

2、编写多线程同步方法解决生产者-消费者的程
序，并完成对进程进行模拟同步和互斥的控制。

2 设计总体思路
2.1 多线程编程思想
编写Windows下的多线程程序，需要使用头文件pthread.h以及windows.h.在LINUX下进行多线程编程首先要用到CreateThread()这个函数.函数CreateThread()用来创建一个线程，它的原型为：
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
// pointer to security attributes
DWORD dwStackSize,
// initial thread stack size
LPTHREAD_START_ROUTINE lpStartAddress,
// pointer to thread function
LPVOID lpParameter,
// argument for new thread
DWORD dwCreationFlags,
// creation flags
LPDWORD lpThreadId);
// pointer to receive thread ID
第一个参数是指向SECURITY_ATTRIBUTES型态的结构的指针。

在Windows 98中忽略该参数。

在Windows NT中，它被设为NULL。

第二个参数是用于新线程的初始堆栈大小，默认值为0。

在任何情况下，Windows根据需要动态延长堆栈的大小。

第三个参数是指向线程函数的指标。

函数名称没有限制，但是必须以下列形式声明：
DWORD WINAPI ThreadProc (PVOID pParam) ;
第四个参数为传递给ThreadProc的参数。

这样主线程和从属线程就可以共享数据。

第五个参数通常为0，但当建立的线程不马上执行时为旗标CREATE_SUSPENDED。

线程将暂停直到呼叫ResumeThread来恢复线程的执行为止。

第六个参数是一个指标，指向接受执行绪ID值的变量。

2.1.1线程数据
在单线程的程序里，有两种基本的数据：全局变量和局部变量。

但在多线程程序里，还有第三种数据类型：线程数据。

它和全局变量很象，在线程内部，各个函数可以象使用全局变量一样调用它，但它对线程外部的其它线程是不可见的。

这种数据的必要性是显而易见的。

例如我们常见的变量errno，它返回标准的出错信息。

它显然不能是一个局部变量，几乎每个函数都应该可以调用它；但它又不能是一个全局变量，否则在A线程里输出的很可能是B线程的出错信息。

ThreadHandle[0]=CreateThread(NULL,0,Producer,NULL,0,&produc er1)其六个参数分别表示为安全设置，堆栈大小，入口函数，函数参数，启动选项，输出线程ID，返回线程句柄。

2.1.2 互斥锁
互斥锁用来保证一段时间内只有一个线程在执行一段代码，必要性显而易见：假设各个线程向同一个文件顺序写入数据，最后得到的结果一定是灾难性的.函数mutex = CreateMutex(NULL,FALSE,NULL);用来生成一个互斥锁.NULL 参数表明使用默认属性.如果需要声明特定属性的互斥锁，须调用函数CreateMutex(NULL,FALSE,NULL) WaitForSingleObject(mutex,INFINITE)声明开始用互斥锁上锁，直至调用ReleaseMutex(mutex)为止，均被上锁，
即同一时间只能被一个线程调用执行.当一个线程执行到pthread_mutex_lock处时，如果该锁此时被另一个线程使用，那么此线程被阻塞，即程序将等待到另一个线程释放此互斥锁.
2.1.3 信号量
信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。

当公共资源增加时，调用函数aitForSingleObject(empty,INFINITE)增加信号量。

只有当信号量
值大于０时，才能使用公共资源，使用后，函数WaitForSingleObject(full,INFINITE)减少信号量。

函数ReleaseSemaphore(full,1,NULL)用来增加信号量的值。

当有线程阻塞在这个信号量上时，调用这个函数会使其中的一个线程不在阻塞，选择机制同样是由线程的调度策略决定的。

函数ReleaseSemaphor()用来释放信号量。

2.2 设计原理
生产者线程和消费者线程共享同一个缓冲队列，生产者线程向缓冲区中写数据，消费者线程从缓冲区中取数据。

但两者必须在使用缓冲队列资源时保持互斥，否则可能会导致在写入时产生数据覆盖，在读出时得到错误数据。

因而要在程序中设置一个互斥锁或公用信号量，用于保证线程间的互斥执行。

同时生产者线程和消费者线程必须保持同步关系，因为生产者线程的执行为消费者线程提供了需要的数据，是其执行的前提。

反之，消费者线程的执行为生产者线程腾出了空闲的缓冲单元，为写数据提供了条件。

即消费者线程执行的前提：缓冲队列中至少有一个单元有数据；生产者线程执行的前提：缓冲队列中至少有一个单元是空的。

在设计过程中，利用信号量和wait 、signal原语操作来实现。

如图1所示：
图1 生产者、消费者共享有界缓冲区
2.3 原语操作实现
The structure of the producer process
do {
// 生产产品
wait (empty);
wait (mutex);
// 往Buffer中放入产品
signal (mutex);
signal (full);
} while (true);
The structure of the consumer process
do {
wait (full);
wait (mutex);
// 从Buffer中取出产品
signal (mutex);
signal (empty);
// 消费产品
} while (true);
3 开发环境与工具
系统平台：Windows环境
实现语言：C++语言
开发工具：Vs2012
4 概要设计
4.1 数据结构设计
通过分析课程设计要求，具体设计出如下数据结构:
1. int buffer[20]={0};//定义缓冲区空间大小
2.包含数据结构pthread_t 它记录一个线程的号，主要包括下面几
个函数，完成不同的功能：
ThreadHandle[0]=CreateThread(NULL,0,Producer,NULL,0,&produc er1); //创建一个线程。

ExitThread(0);
CloseHandle(ThreadHandle[0]);
//等待一个线程结束。

4.2 程序模块实现
4.2.1 生产者（Producer）模块
生产者线程向一缓冲区中写入数据，且写入缓冲区的数目不能超过缓冲区容量。

当生产者产生出数据，需要将其存入缓冲区之前，首先检查缓冲区中是否有“空”存储单元，若缓冲区存储单元全部用完，则生产者必须阻塞等待，直到消费者取走一个存储单元的数据，唤醒它。

若缓冲区内有“空”存储单元，生产者需要判断此时是否有别的生产者或消费者正在使用缓冲区，若是有，则阻塞等待，否则，获得缓冲区的使用权，将数据存入缓冲区，释放缓冲区的使用权，其流程图如图2所示：
生产一条数据
是否可用存储单
元等待资源，阻塞被唤醒是否可用存入一条数据等待使用权，阻塞被唤醒
归还使用权
数据单元加1，唤醒消费者Yes No
No
Yes
图2 生产者流程图
//生产者线程
DWORD WINAPI Producer(LPVOID lpPara )
{
do {
WaitForSingleObject(empty,INFINITE );
//空缓冲区减1
WaitForSingleObject(mutex,INFINITE );
//信号量上锁
buffer[in]=in+1; //往Buffer中放入产品
in=(in+1)%BUFFER_SIZE;
//放入指针调整，为下次送出做准备
printAll();
ReleaseMutex(mutex); //信号量解锁
ReleaseSemaphore(full,1,NULL);
//满缓冲区加1，即当公共资源增加时，调用函数ReleaseSemaphore （）增加信号量
}while(1);
}
4.2.2 消费者(Consumer)模块
消费者线程从缓冲区中读取数据，且消费者读取的数目不能超过生产者写入的数目。

消费者取数据之前，首先检查缓冲区中是否存在装有数据的存储单元，若缓冲区为“空”，则阻塞等待，否则，判断缓冲区是否正在被使用，若正被使用，若正被使用，则阻塞等待，否则，获得缓冲区的使用权，进入缓冲区取数据，释放缓冲区的使用权。

其执行流程如图3所示：
是否可用存储单元等待资源，阻塞被唤醒是否可用取出一条数据等待使用权，阻塞被唤醒
归还使用权
空缓冲区加1，
唤醒一个生产
者
Yes No
No Yes 消费数据
图3 消费者流程图
//消费者线程
DWORD WINAPI Consumer(LPVOID lpPara ) {
do {
WaitForSingleObject(full,INFINITE ); //满缓冲区减1
WaitForSingleObject(mutex,INFINITE ); //信号量上锁
buffer[out]=0; //从Buffer中取出产品
out=(out+1)%BUFFER_SIZE; //取指针调整，为下次取做准备
printAll();
ReleaseMutex(mutex); //信号量解锁
ReleaseSemaphore(empty,1,NULL); //空缓冲区加1 }while(1);
}
5 详细设计
5.1 源程序代码
#include<iostream>
#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<windows.h>
using namespace std;
DWORD WINAPI Producer(LPVOID);
DWORD WINAPI Consumer(LPVOID);
#define WINAPI_stdcall
#define THREAD_NUM 20
#define BUFFER_SIZE 20 //20个缓冲区
int buffer[20]={0};
HANDLE empty;
HANDLE full;
HANDLE mutex; //for mutual exclusion进程信号量
int in=0; //point to the next free positon
int out=0; //point to the first full positon
//把所有的缓冲区输出到屏幕上
void printAll(){
int i;
for(i=0;i<20;i++)
cout<<i<<" ";
cout<<endl；
cout<<"current producer pointer:"<<in<<endl;
cout<<"current consumer pointer:"<<out<<endl;
}
//生产者线程
DWORD WINAPI Producer(LPVOID lpPara)
{
do{
WaitForSingleObject(empty,INFINITE); //空缓冲区减1
WaitForSingleObject(mutex,INFINITE); //信号量上锁
buffer[in]=in+1; //往Buffer中放入产品
in=(in+1)%BUFFER_SIZE;
//放入指针调整，为下次送出做准备
printAll();
ReleaseMutex(mutex); //信号量解锁
ReleaseSemaphore(full,1,NULL);
//满缓冲区加1，即当公共资源增加时，调用函数ReleaseSemaphore （）增加信号量
}while(1);
}
//消费者线程
DWORD WINAPI Consumer(LPVOID lpPara)
{
do{
WaitForSingleObject(full,INFINITE); //满缓冲区减1
WaitForSingleObject(mutex,INFINITE); //信号量上锁
buffer[out]=0; //从Buffer中取出产品
out=(out+1)%BUFFER_SIZE; //取指针调整，为下次取做准备
printAll();
ReleaseMutex(mutex); //信号量解锁
ReleaseSemaphore(empty,1,NULL); //空缓冲区加1 }while(1);
}
//主线程
int main()
{ //创建进程
DWORD
producer[THREAD_NUM],consumer[THREAD_NUM];
mutex = CreateMutex(NULL,FALSE,NULL); // 用默认属性初始化一个互斥变量mutex
HANDLE ThreadHandle[THREAD_NUM];
// 初始化信号量
full=CreateSemaphore(NULL,0,10,NULL);
empty=CreateSemaphore(NULL,10,10,NULL);
//CreateThreade函数用来创建生产者和消费者进程，其六个参数分别表示为安全设置，堆栈大小，入口函数，函数参数，启动选项，输出线程ID，返回线程句柄
for(int i=0;i<THREAD_NUM;i++)
{
ThreadHandle[i] =
CreateThread(NULL,0,Producer,NULL,0,&producer[i]);
ThreadHandle[i] = CreateThread(NULL,0,Consumer,NULL,0,&consumer[i]);
ThreadHandle[i+1] = CreateThread(NULL,0,Producer,NULL,0,&producer[i+1]);
ThreadHandle[i+1] = CreateThread(NULL,0,Consumer,NULL,0,&consumer[i+1]);
}
}
6 程序运行结果及分析
6.1 运行结果
进入Windows开发环境后，通过Vs2012编辑器在其中编写。

进入Vs2012的命令，对程序执行编译运行命令后，即可在屏幕上显示出程序运行的结果，其运行结果如下图5所示：
7 总结
其实在做这道题目时花费了好长时间，第一点是书上大多介绍的是关于UNIX系统下的消费者生产者线程问题，因此一开始调试不出来，后来查阅了有一些资料知道要在windows平台下运行必
须要导入<pthread.h>以及<windows.h>两个库。

通过这次课程设计,不但加深了对操作系统这们课程的认识,而且还了解了操作系统中使用信号量解决生产者—消费者问题算法的实现。

比如：用信号量解决生产者—消费者问题时，可以通过一个有界缓冲区(用数组来实现，类似循环队列)把生产者和消费者联系起来。

假定生产者和消费者的优先级是相同的，只要缓冲区未满，生产者就可以生产产品并将产品送入缓冲区。

类似地，只要缓冲区未空，消费者就可以从缓冲区中去走产品并消费它。

为了解决生产者/消费者问题，应该设置两个资源信号量，其中一个表示空缓冲区的数目，用full表示，其初始值为有界缓冲区的大小；另一个表示缓冲区中产品的数目，用empty表示，其初始值为0。

另外，由于有界缓冲区是一个临界资源，必须互斥使用，所以还需要再设置一个互斥信号量mutex，起初值为1。

在生产者/消费者问题中，信号量实现两种功能。

首先，它是生产产品和消费产品的计数器，计数器的初始值是可利用的资源数目(有界缓冲区的长度)。

其次，它是确保产品的生产者和消费者之间动作同步的同步器。

生产者要生产一个产品时，首先对资源信号量full和互斥信号量mute进行操作，申请资源。

如果可以通过的话，就生产一个产品，并把产品送入缓冲区。

然后对互斥信号量mutex和资源信号量empty进行操作，释放资源。

消费者要消费一个产品时，首先对资源信号量empty和互斥信号量mutex进行操作，申请资源。

如果可以通过的话，就从缓冲区取出一个产品并消费掉。

然后对互斥信号量mutex和资源信号量full进行操作，释放资源。

另外，使我们体会最深的是：任何一门知识的掌握，仅靠学习理论知识是远远不够的，要与实际动手操作相结合才能达到功效。

短短的课程设计就要结束了，不但对专业知识有了更深的理解，更使自己认识到实践的重要性，理论、实践相结合才能达到很好的学习效果，特别是程序语言的学习。