燕山大学课程设计说明书

燕山大学课程设计说明书

课程设计名称：操作系统

题目：多道程序缓冲区协调操作

班级：应用(3)班

开发小组名称：FENGNIAO

课题负责人：王晓峰

课题组成员：姓名: 王晓峰学号: 0901********

班级: 应用3班自评成绩:A

姓名:王燕学号: 0901********

班级: 应用3班自评成绩:B

课题开发日期：2012年1月

1概述：

1.1目的:通过信号量实现多道程序缓冲区协调操作。

1.2主要完成的任务：

1.2.1根据同步机制，编写一个解决类似生产者消费者问题的程序，可显示buffer状态，put、move、get等操作。向buffer1中put信息，buffer2和buffer3从bufer1中取数据。假定这些put和move相互等效，只要buffer1未满，就可以向buffer1中存入信息，只要buffer1未空，就可以move取走一个消息。

1.2.2 显示Buffer的操作过程；

1.2.3程序运行结束，显示汇总数据：

总的运行时间；

Buffer中数据的个数；

已放入BUFFER的数据个数；

已放已取的数据个数；

1.3主要使用的开发工具：VC2010。

2使用的基本概念和原理：

2.1同步与互斥原理

进程互斥是进程之间发生的一种简介性作用，一般是程序不希望的。通常的情况是两个或两个以上的进程需要同时访问某个共享变量。我们一般将发生能够稳共享变量的程序段为临界区。两个进程不能同时进入临界区，否则就会导致数据的不一致性，产生与时间有关的错误。解决互斥问题应该满足互斥与公平俩个原则，即任意时刻只能允许一个进程处于同一共享变量的临界区，而且不能让任意进程无限期地等待。互斥问题可以用硬件方法解决，我们不做展开。

同步是指在互斥的基础上，通过其他机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必须是互斥的。少数情况下可以允许多个访问者同时访问资源。

2.2线程

线程，有时被称为轻量级进程，是程序执行的最小单元。一个标准的线程有线程ID，当前指令指针（PC），寄存器集合和堆栈组合。另外，此案成是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不用有系统资源，只拥有一点在运行中必不可少的资源，但他可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。每一个程序都至少有一个线程，那就是程序本身。

线程是程序中一个单一的顺序控制流程。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

2.3多道程序

多道程序设计是指在主存中同时存放多道用户作业，使他们都处于执行的开始点和开始点之间，这些程序共享计算机系统资源。

多道程序设计的主要优点有：

（1）提高CPU利用率。在多道程序环境下，多个程序共享计算机资源当某个程序等待I/O操作时，CPU可以执行其他程序，大大提高CPU的利用率。

（2）提高设备的利用率。在多道程序环境下，多个程序共享系统的设备，大大提高系统设备的利用率。

（3）提高系统的吞吐量。在多道程序环境下，减少了程序的等待时间，提高了系统的吞吐量。

3总体设计：

面向过程进行设计，分别创建五个函数DWORD WINAPI Put(LPVOID)，DWORD WINAPI Move1(LPVOID)，DWORD WINAPI Move2(LPVOID,DWORD WINAPI Get1(LPVOID),DWORD WINAPI Get2(LPVOID);

然后创建各个互斥信号g_hMutexBuffer1,g_hFullSemaphore1,g_hEmptySemaphore1 ，定义put、move、get函数，调整数值发现，当put个数多余get个数时，put速度快，put经常等待get，反之put经常等待。然后分别创建线程:

for (int i=0;i

hThreads[i]=CreateThread(NULL,0,Put,NULL,0,&putID[i]);

if (hThreads[i]==NULL) return -1;

for (int i=0;i

hThreads[MOVE1_COUNT+i]=CreateThread(NULL,0,Move1,NULL,0,&move1ID[i]);

if (hThreads[i]==NULL) return -1;

}

for (int i=0;i

hThreads[MOVE2_COUNT+i]=CreateThread(NULL,0,Move2,NULL,0,&move2ID[i]);

if (hThreads[i]==NULL) return -1;

}

for (int i=0;i

hThreads[GET1_COUNT+i]=CreateThread(NULL,0,Get1,NULL,0,&get1ID[i]);

if (hThreads[i]==NULL) return -1;

}

for (int i=0;i

hThreads[GET2_COUNT+i]=CreateThread(NULL,0,Get2,NULL,0,&get2ID[i]);

if (hThreads[i]==NULL) return -1;

}

实现循环,然后设置回车结束。

while (g_continue)

{

if (getchar()) {

g_continue = false;

exit(0);

} 流程图：

4程序分析：

4.1设计思路上先编写了五个函数DWORD WINAPI Put(LPVOID)，DWORD WINAPI Move1(LPVOID)，DWORD WINAPI Move2(LPVOID,DWORD WINAPI Get1(LPVOID),DWORD WINAPI Get2(LPVOID);

4.2创建put 线程，在线程中实现循环，其他类似。

for (int i=0;i

hThreads[i]=CreateThread(NULL,0,Put,NULL,0,&putID[i]);

if (hThreads[i]==NULL) return -1;

4.3定义输出函数

void shuChu()

{

std::cout<<"Buffer1"<

for (int i=0;i

std::cout << i <<": " << g_buffer1[i];

if (i==in1) std::cout << " <-- put";

if (i==out1) std::cout << " <-- move";

std::cout << std::endl;

}

std::cout<<"Buffer2"<

for (int i=0;i

std::cout << i <<": " << g_buffer2[i];

if (i==in2) std::cout << " <-- move1";

if (i==out2) std::cout << " <-- get1";

std::cout << std::endl;

}

std::cout<<"Buffer3"<

for (int i=0;i

{

std::cout << i <<": " << g_buffer3[i];

if (i==in3) std::cout << " <-- move2";

if (i==out3) std::cout << " <-- get2";

std::cout << std::endl;

}

clock_t time=clock();

std::cout<<"时间是"<

}

4.4定义各个函数，详见源代码。

void Puts()

{ std::cerr << "put ... ";

PutID++;

g_buffer1[in1] = PutID;

in1 = (in1+1)%SIZE_OF_BUFFER1;

std::cerr << "Succeed" << std::endl;

shuChu();

}

DWORD WINAPI Put(LPVOID lpPara)

{

while (g_continue) {

WaitForSingleObject(g_hFullSemaphore1,INFINITE);

WaitForSingleObject(g_hMutexBuffer1,INFINITE);

Puts();

Sleep(1500);

ReleaseMutex(g_hMutexBuffer1);

ReleaseSemaphore(g_hEmptySemaphore1,1,NULL);

}

return 0;

}

5源代码及函数注释：

#include"stdafx.h"

#include

#include

#include

const unsigned short SIZE_OF_BUFFER1 = 10;

const unsigned short SIZE_OF_BUFFER2 = 10;

const unsigned short SIZE_OF_BUFFER3 = 10;

unsigned short PutID = 0;

unsigned short Move1ID = 0;

unsigned short Move2ID = 0;

unsigned short Get1ID = 0;

unsigned short Get2ID = 0;

unsigned short in1 = 0;

unsigned short out1 = 0;

unsigned short in2 = 0;

unsigned short out2 = 0;

unsigned short in3 = 0;

unsigned short out3 = 0;

int g_buffer1[SIZE_OF_BUFFER1];

int g_buffer2[SIZE_OF_BUFFER2];

int g_buffer3[SIZE_OF_BUFFER3];

bool g_continue = true;

HANDLE g_hMutexBuffer1;

HANDLE g_hFullSemaphore1;

HANDLE g_hEmptySemaphore1;

HANDLE g_hMutexBuffer2;

HANDLE g_hFullSemaphore2;

HANDLE g_hEmptySemaphore2;

HANDLE g_hMutexBuffer3;

HANDLE g_hFullSemaphore3;

HANDLE g_hEmptySemaphore3;

DWORD WINAPI Put(LPVOID);

DWORD WINAPI Move1(LPVOID);

DWORD WINAPI Move2(LPVOID);

DWORD WINAPI Get1(LPVOID);

DWORD WINAPI Get2(LPVOID);

int main()

{

g_hMutexBuffer1 = CreateMutex(NULL,FALSE,NULL);

g_hFullSemaphore1 = CreateSemaphore(NULL,SIZE_OF_BUFFER1-1,SIZE_OF_BUFFER1-1,NULL);

g_hEmptySemaphore1 = CreateSemaphore(NULL,0,SIZE_OF_BUFFER1-1,NULL);

g_hMutexBuffer2 = CreateMutex(NULL,FALSE,NULL);

g_hFullSemaphore2 = CreateSemaphore(NULL,SIZE_OF_BUFFER1-1,SIZE_OF_BUFFER1-1,NULL);

g_hEmptySemaphore2 = CreateSemaphore(NULL,0,SIZE_OF_BUFFER1-1,NULL);

g_hMutexBuffer3 = CreateMutex(NULL,FALSE,NULL);

g_hFullSemaphore3

= CreateSemaphore(NULL,SIZE_OF_BUFFER1-1,SIZE_OF_BUFFER1-1,NULL);

g_hEmptySemaphore3 = CreateSemaphore(NULL,0,SIZE_OF_BUFFER1-1,NULL);

const unsigned short PUT_COUNT = 3;

const unsigned short MOVE1_COUNT = 3;

const unsigned short MOVE2_COUNT = 3;

const unsigned short GET1_COUNT = 3;

const unsigned short GET2_COUNT = 3;

Const unsigned short THREADS_COUNT = PUT_COUNT+MOVE1_COUNT+MOVE2_COUNT+GET1_COUNT+GET2_COUNT;

HANDLE hThreads[THREADS_COUNT];

DWORD putID[PUT_COUNT];

DWORD move1ID[MOVE1_COUNT];

DWORD move2ID[MOVE2_COUNT];

DWORD get1ID[GET1_COUNT];

DWORD get2ID[GET2_COUNT];

for (int i=0;i

hThreads[i]=CreateThread(NULL,0,Put,NULL,0,&putID[i]);

if (hThreads[i]==NULL) return -1;

}

for (int i=0;i

hThreads[MOVE1_COUNT+i]=CreateThread(NULL,0,Move1,NULL,0,&move1ID[i]);

if (hThreads[i]==NULL) return -1;

}

for (int i=0;i

hThreads[MOVE2_COUNT+i]=CreateThread(NULL,0,Move2,NULL,0,&move2ID[i]);

if (hThreads[i]==NULL) return -1;

}

for (int i=0;i

hThreads[GET1_COUNT+i]=CreateThread(NULL,0,Get1,NULL,0,&get1ID[i]);

if (hThreads[i]==NULL) return -1;

}

for (int i=0;i

hThreads[GET2_COUNT+i]=CreateThread(NULL,0,Get2,NULL,0,&get2ID[i]);

if (hThreads[i]==NULL) return -1;

}

while (g_continue)

{

if (getchar()) {

g_continue = false;

exit(0);

}

}

return 0;

}

void shuChu()

{

std::cout<<"Buffer1"<

for (int i=0;i

std::cout << i <<": " << g_buffer1[i];

if (i==in1) std::cout << " <-- put";

if (i==out1) std::cout << " <-- move"; std::cout << std::endl;

}

std::cout<<"Buffer2"<

for (int i=0;i

std::cout << i <<": " << g_buffer2[i];

if (i==in2) std::cout << " <-- move1";

if (i==out2) std::cout << " <-- get1"; std::cout << std::endl;

}

std::cout<<"Buffer3"<

for (int i=0;i

{

std::cout << i <<": " << g_buffer3[i];

if (i==in3) std::cout << " <-- move2";

if (i==out3) std::cout << " <-- get2"; std::cout << std::endl;

}

}

clock_t time=clock();

std::cout<<"时间是"<

{

std::cerr << "put ... ";

g_buffer1[in1] = PutID;

PutID++;

in1 = (in1+1)%SIZE_OF_BUFFER1;

std::cerr << "Succeed" << std::endl;

shuChu();

}

void MoveTo1s()

{

std::cerr << "Move1 ... ";

Move1ID = g_buffer1[out1];

out1 = (out1+1)%SIZE_OF_BUFFER1;

g_buffer2[in2] = Move1ID;

in2 = (in2+1)%SIZE_OF_BUFFER2;

std::cerr << "Succeed" << std::endl;

shuChu();

}

void MoveTo2s()

{

std::cerr << "Move2 ... ";

Move2ID = g_buffer1[out1];

out1 = (out1+1)%SIZE_OF_BUFFER1;

g_buffer3[in2] = Move2ID;

in3 = (in3+1)%SIZE_OF_BUFFER3;

std::cerr << "Succeed" << std::endl;

shuChu();

}

void Get1s()

{

std::cerr << "get1 ";

Get1ID = g_buffer2[out2];

out2 = (out2+1)%SIZE_OF_BUFFER2;

std::cerr << "Succeed" << std::endl;

shuChu();

}

void Get2s()

{

std::cerr << "get2 ";

Get2ID = g_buffer3[out3];

out3 = (out3+1)%SIZE_OF_BUFFER3;

std::cerr << "Succeed" << std::endl;

shuChu();

}

DWORD WINAPI Put(LPVOID lpPara)

{

while (g_continue) {

WaitForSingleObject(g_hFullSemaphore1,INFINITE);

WaitForSingleObject(g_hMutexBuffer1,INFINITE);

Puts();

Sleep(1500);

ReleaseMutex(g_hMutexBuffer1);

ReleaseSemaphore(g_hEmptySemaphore1,1,NULL);

}

return 0;

}

DWORD WINAPI Get1(LPVOID lpPara)

{

while (g_continue) {

WaitForSingleObject(g_hEmptySemaphore2,INFINITE);

WaitForSingleObject(g_hMutexBuffer2,INFINITE);

Get1s();

Sleep(1500);

ReleaseMutex(g_hMutexBuffer2);

ReleaseSemaphore(g_hFullSemaphore2,1,NULL);

}

return 0;

}

DWORD WINAPI Get2(LPVOID lpPara)

{

while (g_continue) {

WaitForSingleObject(g_hEmptySemaphore3,INFINITE);

WaitForSingleObject(g_hMutexBuffer3,INFINITE);

Get2s();

Sleep(1500);

ReleaseMutex(g_hMutexBuffer3);

ReleaseSemaphore(g_hFullSemaphore3,1,NULL);

}

return 0;

}

DWORD WINAPI Move1(LPVOID lpPara)

{

while (g_continue)

{

WaitForSingleObject(g_hEmptySemaphore1,INFINITE);

WaitForSingleObject(g_hMutexBuffer2,INFINITE);

WaitForSingleObject(g_hMutexBuffer1,INFINITE);

WaitForSingleObject(g_hFullSemaphore2,INFINITE);

MoveTo1s();

Sleep(1500);

ReleaseMutex(g_hMutexBuffer2);

ReleaseMutex(g_hMutexBuffer1);

ReleaseSemaphore(g_hFullSemaphore1,1,NULL);

ReleaseSemaphore(g_hEmptySemaphore2,1,NULL);

}

return 0;

}

DWORD WINAPI Move2(LPVOID lpPara)

{

while (g_continue) {

WaitForSingleObject(g_hEmptySemaphore1,INFINITE);

WaitForSingleObject(g_hMutexBuffer3,INFINITE);

WaitForSingleObject(g_hMutexBuffer1,INFINITE);

WaitForSingleObject(g_hFullSemaphore3,INFINITE);

MoveTo2s();

Sleep(1500);

ReleaseMutex(g_hMutexBuffer3);

ReleaseMutex(g_hMutexBuffer1);

ReleaseSemaphore(g_hFullSemaphore1,1,NULL);

ReleaseSemaphore(g_hEmptySemaphore3,1,NULL);

}

return 0;

}

6运行结果

7总结：

能实现要求的功能，能进行数据的输入可以模仿一个进程可以不断地随机产生页面存取序列，也可以输入一个页面存取序列，可以设置输入留驻页面的个数，可以设置内存、快表、缺页中断的时间，并提供省缺值。能实时显示一个进程逻辑页面的状态和内存的使用状况。能计算FIFO、LRU、OPT页面置换算法的置换次数；能计算计算每种页面置换算法每个页面的存取时间。能直观的从输出结果中看到和比较3种算法的不同之处。

缺点：因为不太懂mfc没有对c++源程序进行可视化窗口改写，使用上可能不太方便。

8收获及经验心得：

通过这次课程设计，我们巩固了使用多线程编程的方法，和使用信号量同步进程的技巧。本次课程设计的程序的运行结果跟预期一致，说明改程序能顺利解决多道程序缓冲区协调操作问题实现了本次课程设计的目的。同时使我们体会到任何一门知识的掌握，紧靠学习理论知识是远远不够的，要与实际动手操作相结合才能达到功效。短短的课程设计就要结束了，不但对专业知识有了更深的理解，更使我们认识到实践的重要性。只有理论与实践相结合才能达到更好的学习效果。

9参考文献：

西安电子科技大学出版社计算机操作系统（第三版）清华大学出版社C++面向对象程序设计教程（第三版）