缓冲池地模拟使用

实用标准文案

GDOU-B-11-112

广

东海洋大学学生实验报告书（学生用表）

实验名称 学院(系) 学生姓名

缓冲池的模拟使用 软件学院

学号

专业

课程名称 操作系统 课程号 班级

软件工程 实验地点

实验日期

一、实验目的

（1）掌握缓冲池的结构 （2）掌握缓冲池的使用方法

二、实验内容

1、实现输入、计算、输出进程并发执行； 2、实现getBuf和putBuf函数。

三、实验步骤

1、整体设计，包括三个线程的模拟设计，三个队列的链表设计，还有三个队列的同步与互斥的设计等；

2、由于本次实验没有需要太多的数据结构，因此，数据结构的设计就只有三个缓冲队列的设计：先构造一个空的缓冲队列，该队列是一个实体，即是一个确定的有结点的链表，它是模拟缓冲池的载体，输入与输出队列在构造时只有它的头尾指针，而没有它的实体，这是因为它可以从空缓冲区里获得，例如，当计算线程要数据计算时，便可从空队列里获取一个缓冲区，作为输入缓冲使用再把它挂载到输入队列的队尾中去

实验内容如下：

//缓冲队列类型的定义

#define EMQ 0 //空缓冲队列 #define INQ 1 //输入缓冲队列 #define OUTQ 2 //输出缓冲队列

const int bufferpoolsize = 50; ////缓冲池大小,默认设置为50个

//结束运行标志

short int m_end ;

精彩文档

实用标准文案

//缓冲结构体的定义 typedef struct Buffer {

int BufNo; //缓冲区号 int buf; //缓冲内容

Buffer *next; //缓冲指向下一个指针 } buffer;

//线程函数声明

DWORD WINAPI InputThreadFunc(LPVOID lpPara); //输入线程函数 DWORD WINAPI OutputThreadFunc(LPVOID lpPara); //输出线程函数 DWORD WINAPI CalThreadFunc(LPVOID lpPara); //计算线程函数

//加入与摘取队列函数声明

void putBuf(int type , buffer *buf); //挂载到队列尾

buffer* getBuf(int type); //从队列头中摘取一个缓冲区

//构造缓冲池函数的声明 void ConstructBuffer();

//线程的句柄

HANDLE hInputT; //输入线程 HANDLE hOutputT; //输出线程 HANDLE hCalculateT; //计算线程

//线程的ID

DWORD InputTid; //输入线程 DWORD OutputTid; //输出线程 DWORD CalculateTid; //计算线程

//三个互斥量信号句柄 HANDLE hmutexEMQ; //空队列的互斥信号量

HANDLE hmutexOUTQ; //装满输出队列的互斥信号量 HANDLE hmutexINQ; //装满输入队列的互斥信号量

//三个同步信号量 HANDLE hsemINQ; HANDLE hsemOUTQ; HANDLE hsemEMQ;

#include \

精彩文档

实用标准文案

#include \#include \#include \#include \

using namespace std;

//三个缓冲队列头与尾指针

buffer *hemq , *hinq , *houtq; //队头指针 buffer *lemq , *linq , *loutq; //队尾指针

//主函数 int main() {

cout<

//创建互斥对象

hmutexEMQ = CreateMutex(NULL,FALSE,NULL); hmutexOUTQ = CreateMutex(NULL,FALSE,NULL); hmutexINQ = CreateMutex(NULL,FALSE,NULL);

//创建信号量对象

hsemINQ = CreateSemaphore(NULL,0,bufferpoolsize,NULL); hsemOUTQ = CreateSemaphore(NULL,0,bufferpoolsize,NULL); hsemEMQ = CreateSemaphore(NULL,bufferpoolsize,bufferpoolsize,NULL);

//创建线程

hInputT = CreateThread(NULL,0,InputThreadFunc,NULL,0,&InputTid); Sleep(10); hCalculateT = CreateThread(NULL,0,CalThreadFunc,NULL,0,&CalculateTid); Sleep(10); hOutputT = CreateThread(NULL,0,OutputThreadFunc,NULL,0,&OutputTid);

//Sleep(10000); //system(\ if(getchar())

{ //按回车后终止程序运行 m_end = 0 ;

cout<<\程序已经终止!\

精彩文档

实用标准文案

}

//等待三个线程的结束返回

WaitForSingleObject(hInputT,INFINITE); WaitForSingleObject(hCalculateT,INFINITE); WaitForSingleObject(hOutputT,INFINITE);

//释放线程的资源

CloseHandle(hInputT); CloseHandle(hCalculateT); CloseHandle(hOutputT);

return 0; }

//输入线程函数的实现

DWORD WINAPI InputThreadFunc(LPVOID lpPara) //输入线程函数 {

int nRandom; buffer* getbuf;

srand(time(0)); //保证每次运行时产生的随机数独立 while(m_end) {

Sleep(100);

nRandom = rand()0 + 1 ; //产生1到100的随机数 //同步与互斥的控制

WaitForSingleObject(hsemEMQ,INFINITE); WaitForSingleObject(hmutexEMQ,INFINITE);

getbuf = getBuf(EMQ); //访问空队列 getbuf->buf = nRandom ;

cout<<\输入线程从 \缓冲单元 \收容输入--->\

ReleaseMutex(hmutexEMQ); //释放互斥对象信号

//控制访问输入队列的互斥量

WaitForSingleObject(hmutexINQ,INFINITE);

putBuf(INQ,getbuf) ; //将输入的缓冲区挂载到输入队列的队尾 ReleaseMutex(hmutexINQ);

ReleaseSemaphore(hsemINQ,1,NULL); }

return 0;

精彩文档

实用标准文案

}

//输出线程函数的实现

DWORD WINAPI OutputThreadFunc(LPVOID lpPara) //输出线程函数 {

buffer* Outputbuf ; //一个临时交换区

while(m_end) {

Sleep(100);

////同步与互斥的控制

WaitForSingleObject(hsemOUTQ,INFINITE); WaitForSingleObject(hmutexOUTQ,INFINITE);

Outputbuf = getBuf(OUTQ) ; //从输出队列中提取一个提取输出缓冲区 cout<<\输出线程从 \缓冲单元 \提取输出--->\

//Outputbuf->buf = -1 ; //提取完成后将该缓冲区回收

ReleaseMutex(hmutexOUTQ);

WaitForSingleObject(hmutexEMQ,INFINITE);

putBuf(EMQ,Outputbuf) ; //回收的把它挂载到空队列的队尾 ReleaseMutex(hmutexEMQ);

ReleaseSemaphore(hsemEMQ,1,NULL); }

return 0; }

//计算线程函数的实现

DWORD WINAPI CalThreadFunc(LPVOID lpPara) //计算线程函数 {

buffer* Calbuf1 = NULL; buffer* Calbuf2 =NULL; int nCal; while(m_end) {

Sleep(10); //因为计算线程的速度远远快于输入与输出线程，所以它的休眠时间应很小

////同步与互斥的控制

精彩文档