操作系统原理实验报告.doc

. -

?操作系统原理?
实验报告

班级:
:
学号:
指导教师：

目录:
实验题目：实验一线程创立与撤销2
实验题目：实验二线程同步3
实验题目：实验三线程互斥3
实验题目：实验四进程通信3
实验题目：实验五读者-写者问题3
实验题目：实验六进程调度3
实验题目：实验七存储管理之动态库3
实验题目：实验八存储管理之内存分配3
实验题目：实验九存储管理之页面置换算法3
实验题目：实验十设备管理3
实验题目：实验十一文件管理之文件读写3

实验题目：实验一线程创立与撤销
完成人：XXX
报告日期：2018年3月31日
一、 实验内容简要描述

〔1〕熟悉VC++、Visual Studio开发环境。
〔2〕使用相关函数创立和撤销线程。
〔3〕在一个进程中创立3个线程，名字分别为threada、threadb、threadc。
threada输出“hello world! 〞。
threadb输出“My name is …〞。
threadc输出“Please wait…〞，然后sleep 5秒钟，接着输出“I wake up〞。

二、 程序设计
1、 设计思路
该函数创立一个在调用进程的地址空间中执行的线程。
2、 主要数据构造
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
)；
VOID ExitThread(DWORD dwExitCode)；
VOID Sleep(DWORD dwMilliseconds);
VOID Sleep(DWORD dwMilliseconds);

三、实验结果
1、根本数据
lpThreadAttributes：指向一个SECURITY_ATTRIBUTES构造，该构造决定了返回的句柄是否可被子进程继承。假设lpThreadAttributes为NULL，那么句柄不能被继承。
在WindowsNT中该构造的lpSecurityDescriptor成员定义了新进程的平安性描述符。假设lpThreadAttributes为NULL，那么线程获得一个默认的平安性描述符。
dwStackSize：定义原始堆栈提交时的大小(按字节计)。系统将该值舍入为最近的页。假设该值为0，或小于默认时提交的大小，默认情况是使用与调用线程同样的大小。更多的信息，请看ThreadStackSize。
lpStartAddress：指向一个LPTHREAD_START_ROUTlNE类型的应用定义的函数，该线程执行此函数。该指针还表示溃程进程中线程的起始地址。该函数必须存在于远程进程中。
lpParameter：定义一个传递给该迸程的32位值。
dwCreationFIags：定义控制进程创立的附加标志。假设定义了CREATE_SUSPENDED标志，线程创立时处于挂起状态，并且直到ResumeThread函数调用时d能运行。假设该值为0，那么该线程在创立后立即执行。
lpThreadId：指向一个32位值，它接收该线程的标识符。

2.
源程序代码行数
完成该实验投入的时间〔小时数〕
与其他同学讨论次数
31
1
1

3、 测试结果分析

四、实验体会
1、实验体会和收获
深入理解了线程与进程的概念，熟悉了在Windows环境下何时使用进程，何时使用线程，怎么创立和撤销线程。

五、源代码
#include <windows.h>
#include <iostream>
using namespace std;

DWORD WINAPI ta(LPVOID argv)
{
cout<<"Hello World!\n";
}
DWORD WINAPI tb(LPVOID argv)
{
cout<<"我的名字：婷 \n";
cout<<"我的学号：141340209\n";
}
DWORD WINAPI tc(LPVOID argv)
{
cout<<"Please wait...\n";
Sleep(5000);
cout<<"I wake up.\n";
}
int main()
{
HANDLE threada,threadb,threadc;
DWORD TEST;
threada=CreateThread(NULL,0,ta,NULL,0,0);
threadb=CreateThread(0,0,tb,0,0,0);
threadc=CreateThread(0,0,tc,0,0,0);
ExitThread(TEST);
ExitThread(TEST);
ExitThread(TEST);
return 0;
}

实验题目：实验二线程同步
完成人：XXX
报告日期：2018年4月7日
一、 实验内容简要描述
1） 在程序中使用CreateSemaphore(NULL,0,1,〞SemaphoreName1〞)创立一个名为SemaphoreName1的信号量，其初值为0。
2） 使用OpenSemaphore (SYNCHRONIZE| SEMAPHORE__MODIFY_STA
TE, NULL,〞 SemaphoreName1〞)翻开该信号量。
3） 创立一个子线程，主线程创立子线程后调WaitForSingleObject(hHandle,
INFINITE)，这里等待时间设置为INFINITE表示要一直等待下去，直到该信号量被唤醒为止。
4） 子线程sleep 5秒钟，然后输出“I am over.〞完毕，调用ReleaseSemaphore(hHandle1,1,NULL)释放信号量，使信号量的值加1。

二、 程序设计
1、 设计思路
A〕等待一个对象
WaitForSingleObjects函数决定等待条件是否被满足。如果等待条件并没有被满足，调用线程进人一个高效的等待状态，当等待满足条件时占用非常少的处理器时间。
在运行前，一个等待函数修改同步对象类型的状态。修改仅发生在引起函数返回的对象身上。
例如，信号的计数减l。
WaitForSingleObject函数能等待的对象包括：Change notification(改变通告);Console input(控制台输入);Event(事件);Job(作业);Mutex(互斥对象);Process(进程);Semaphore(信号量);Thread(线程);Waitable timer(可等待定时器)。
当使用等待函数或代码直接或间接创立窗口时，一定要小心。如果一个线程创立了任何窗口，它必须处理进程消息。消息播送被发送到系统的所有窗口。一个线程用没有超时的等待函数也许会引起系统死锁。间接创立窗口的两个例子是DDE和 CoInitialize。因此，如果用户有一个创立窗口的线程，用MsgWaitForMultipleObjects或MsgWaitForMultipleObjectsEx函数，而不要用
SignalObjectAndWait函数。
B〕等待多个对象
WaiForMultipleObjects函数当以下条件之一满足时返回：(1)任意一个或全部指定对象处于信号态；(2)超时间隔已过。
C〕创立信号量
如果成功就传回一个handle，否那么传回NULL。不管哪一种情况，GetLastError都会传回一个合理的结果。如果指定的Semaphore名称已经存在，那么函数还是成功的，GetLastError会传回ERROR_ ALREADY_EXISTS。
D〕翻开信号量
为现有的一个已命名信号机对象创立一个新句柄。
E〕增加信号量的值
该函数将指定信号对象的计数增加一个指定的值。

2、 主要数据构造
DWORD WaitForSingleObject(HANDLE hHandle，DWORD dwMilliseconds);
DWORD WaitForMultipleObjects(
DWORD nCount，
CONST HANDLE *lpHandles，
BOOL fWaitAll，
DWORD dwMilliSeconds
)
HANDLE CreateSemaphore(
LPSECURITY_ATTRIBUTES lpAttributes，
LONG lInitialCount，
LONG lMaximumCount，
LPCTSTR lpName
)；
HANDLE OpenSemaphore(
DWORD dwDesiredAccess， //访问标志
BOOL bInheritHandle, // 继承标志
LPCTSTR lpName // 信号量名
)；
BOOL ReleaseSemaphore(
HANDLE hSemaphore，
LONG lReleaseCount，
LPLONG lpPreviousCount
)

三、实验结果
1、根本数据
源程序代码行数
完成该实验投入的时间〔小时数〕
与其他同学讨论次数
61
2
1
2、测试结果分析

四、实验体会
1、实验体会和收获
进一步认识了线程同步的实质，学会使用信号量控制线程间的同步。

五、源代码
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

static HANDLE hThread1; //子进程的句柄，作为主线程的局部变量也行
static HANDLE hHandle1=NULL; //信号量的句柄，全局变量
void func(); //子线程的声明

int main(int argc,TCHAR* argv[],TCHAR* envp[])
{
int nRetCode=0;
DWORD dwThreadID1;
DWORD dRes,err;

hHandle1=CreateSemaphore(NULL,0,1,"SemaphoreName1"); //创立一个信号量
if(hHandle1==NULL) printf("Semaphore Create Fail!\n");
else printf("Semaphore Create Success!\n");
hHandle1=OpenSemaphore(SYNCHRONIZE|SEMAPHORE_MODIFY_STATE,NULL,"SemaphoreName1");
if(hHandle1==NULL)printf("Semaphore Open Fail!\n");
else printf("Semaphore Open Success!\n");

hThread1=CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0,
(LPTHREAD_START_ROUTINE)func,
(LPVOID)NULL,
0,&dwThreadID1); //创立子线程
if (hThread1==NULL) printf("Thread1 create Fail!\n");
else printf("Thread1 create Success!\n");

dRes=WaitForSingleObject(hHandle1,INFINITE); //主线程等待子线程完毕
err=GetLastError();
printf("WaitForSingleObject err=%d\n",err);

if(dRes==WAIT_TIMEOUT)
printf("TIMEOUT!dRes=%d\n",dRes);
else if(dRes==WAIT_OBJECT_0)
printf("WAIT_OBJECT!dRes=%d\n",dRes);
else if(dRes==WAIT_ABANDONED)
printf("WAIT_ABANDONED!dRes=%d\n",dRes);
else printf("dRes=%d\n",dRes);

CloseHandle(hThread1);
CloseHandle(hHandle1);
printf("我的名字：孙婷\n");
printf("我的学号：141340209\n");
ExitThread(0);

return nRetCode;
}
//实现子线程
void func()
{
BOOL rc;
DWORD err;
printf("Now In Thread !\n");
printf("I am over.\n");
rc=ReleaseSemaphore(hHandle1,1,NULL); //子线程唤醒主线程
err=GetLastError();
printf("ReleaseSemaphore err=%d\n",err);
if(rc==0) printf("Semaphore Release Fail!\n");
else printf("Semaphore Release Success!rc=%d\n",rc);
}

实验题目：实验三线程互斥
完成人：XXX
报告日期：2018年4月14日
三、 实验内容简要描述
完成两个子线程之间的互斥。在主线程中使用系统调用CreateThread〔〕创立两个子线程，并使两个子线程互斥的使用全局变量count。
四、 程序设计
3、 设计思路
a．使用临界区对象〔Criticalsection〕
Critical Section Object ，A segment of code that is not reentrant and therefore does not support concurrent access by multiple threads. Often, a critical section object is used to protect shared resources。通过定义在数据段中的一个CRITICAL_SECTION 构造实现。
CRITICAL_SECTION myCritical；
并且在任何线程使用此临界区对象之前必须对它进展初始化。
void InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection );
之后，任何线程访问临界区中数据的时候，必须首先调用EnterCriticalSection 函数，申请进入临界区〔又叫关键代码段，使用共享资源的任何代码都必须封装在此〕。在同一时间内，Windows 只允许一个线程进入临界区。所以在申请的时候，如果有另一个线程在临界区的话，EnterCriticalSection 函数会一直等待下去，直到其他线程离开临界区才返回。EnterCriticalSection 函数用法如下：
void EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection);
当操作完成的时候，还要将临界区交还给Windows，以便其他线程可以申请使用。这个工作由LeaveCriticalSection 函数来完成。
void LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection);
当程序不再使用临界区对象的时候，必须使用DeleteCriticalSection 函数将它删除。
void DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection);
b．使用互斥锁〔Interlocked〕
提供一种手段来保证值的递增(减)能够以原子操作方式来进展，也就是不中断地进展。
LONG InterlockedIncrement( LPLONG lpAddend ) ; // 增一操作
LONG InterlockedDecrement( LPLONG lpAddend); // 减一操作
LONG InterlockedExchangeAdd (
PLONG Addend, // pointer to the addend
LONG Increment // increment value
); //增减任意值

4、 主要数据构造
void InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection );
void EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection);
void LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection);
void DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection);
LONG InterlockedIncrement( LPLONG lpAddend ) ; // 增一操作
LONG InterlockedDecrement( LPLONG lpAddend); // 减一操作
LONG InterlockedExchangeAdd (
PLONG Addend, // pointer to the addend
LONG Increment // increment value

三、实验结果
1、根本数据
源程序代码行数
完成该实验投入的时间〔小时数〕
与其他同学讨论次数
68
2
0

2.测试结果分析

四、实验体会
1、实验体会和收获
熟练了Windows系统环境下线程的创立与撤销，熟悉了Windows系统提供的线程互斥API，使用Windows系统提供的线程互斥API解决实际问题。

五、源代码
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

static int count=5; //共享变量
static HANDLE h1,h2; //两个子进程的句柄变量
LPCRITICAL_SECTION hCriticalSection; //定义指向临界区对象的地址指针
CRITICAL_SECTION Critical; //定义临界区
void func1( ); //线程函数的定义不符合WIN32格式，后面CreateThread函数中
void func2( ); //要附加强制类型转换

//主线程的实现
int main(int argc, TCHAR* argv[],TCHAR* envp[])
{
int nRetCode=0;
DWORD dwThreadID1, dwThreadID2;
hCriticalSection=&Critical; //将指向临界区的对象的指针指向临界区
InitializeCriticalSection(hCriticalSection); //初始化临界区
//创立子线程func1
h1=CreateThread((LPSECURITY_ATTRIBUTES)NULL,
0,
(LPTHREAD_START_ROUTINE)func1,
(LPVOID)NULL,
0,&dwThreadID1);
if(h1==NULL)printf("Thread1 create Fail!\n");
else printf("Thread1 create success!\n");

//创立子线程func2
h2=CreateThread((LPSECURITY_ATTRIBUTES)NULL,
0,
(LPTHREAD_START_ROUTINE)func2,
(LPVOID)NULL,
0,&dwThreadID2);
if(h2==NULL) printf("Thread2 create Fail!\n");
else printf("Thread2 create success!\n");

Sleep(1000);
CloseHandle(h1);
CloseHandle(h2);
DeleteCriticalSection(hCriticalSection); //删除临界区
ExitThread(0);
return nRetCode;
}//主线程完毕

//子线程fun c2的实现
void func2()
{
int r2;
EnterCriticalSection(hCriticalSection); //进入临界区
r2=count;
Sleep(100);
r2=r2+1;
count=r2;
printf("count in func2=%d\n",count);
LeaveCriticalSection(hCriticalSection); //退出临界区
}
//子线程func1的实现
void func1()
{
int r1;
EnterCriticalSection(hCriticalSection); //进入临界区
r1=count;
Sleep(500);
r1=r1+1;
count=r1;
printf("count in func1=%d\n",count);
LeaveCriticalSection(hCriticalSection); //退出临界区
}

实验题目：实验四进程通信
完成人：XXX
报告日期：2018年4月21日
五、 实验内容简要描述
1） 利用命名管道的相关知识及函数，分别编写效劳器进程和客户端进程程序。
2） 要求效劳器进程和客户端进程程序能够通过互相传送数据。
3） 当效劳器进程和客户端进程中的任何一端输入“end〞时，完毕会话。
六、 程序设计
5、 设计思路
〔1〕建立命名管道
〔2〕连接命名管道
〔3〕撤除命名管道的连接
〔4〕客户端进程连接效劳器已建立的命名管道
〔5〕客户端进程等待命名管道
6、 主要数据构造
Handle CreateNamedPipe(LPCTSTR lpName，……)；
BOOL ConnectNamedPipe(HANDLE hNamePipe，OVERLAPPED lpOverlapped)；
BOOL DisconnectNamedPipe (Long hNamedPipe)；
BOOL CallNamedPipe( String lpNamedPipeName，//欲翻开管道的名称
lpInBuffer Any， //要写入管道的数据的内存缓冲区
nInBufferSize Long， //内存缓冲区中的字符数量
lpOutBuffer Any， //指定一个内存缓冲区，用于装载从管道中读出的数据
nOutBufferSize Long，//指定一个长整数变量，用于装载来自管道的数据
lpBytesRead Long， //指定从管道中读出的字节数
nTimeOut Long， //管道是否可用及超时设置
)；
BOOL WaitNamedPipe(LPCTSTR lpNamedPipeName, DWORD nTimeOut)；

三、实验结果
测试结果

四、实验体会
1、实验体会和收获
了解命名管道的概念，并学会了使用命名管道实现进程间的根本通信。
五、源代码
/效劳器进程/
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
int nRetCode=0;
BOOL rc;
int err;
HANDLE hPipeHandle;
char lpName[]="\\\\.\\pipe\\myPipe";
char InBuffer[50]="";
char OutBuffer[50]="";
DWORD BytesRead,BytesWrite;
hPipeHandle=CreateNamedPipe(
(LPCTSTR)lpName,
PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED|WRITE_DAC,
PIPE_TYPE_MESSAGE|PIPE_READMODE_BYTE|PIPE_WAIT,
1,20,30,NMPWAIT_USE_DEFAULT_WAIT,
(LPSECURITY_ATTRIBUTES)NULL
) ; //创立命令管道
if((hPipeHandle==INVALID_HANDLE_VALUE)||(hPipeHandle==NULL))
{
err= GetLastError();
printf("Server Pipe Create Fail!err=%d\n",err);
exit(1);
}
else printf("Server Pipe Create Success!\n");
while(1) //连接命名管道
{
rc=ConnectNamedPipe(hPipeHandle,(LPOVERLAPPED)NULL);
if(rc==0)
{
err=GetLastError();
printf("Server Pipe Connect Fail!err=%d\n",err);
exit(2);
}
else printf("Server Pipe Connect Success!\n");
strcpy(InBuffer,"");
strcpy(OutBuffer,"");
//命名管道读数据
rc= ReadFile(hPipeHandle,InBuffer,sizeof(InBuffer),
&BytesRead,(LPOVERLAPPED)NULL);
if(rc==0 && BytesRead==0)
{
err=GetLastError();
printf("Server Pipe Read Fail!err=%d\n",err);
exit(3);
}
else printf("Server Pipe Read Success!\n DATA from Client is=%s\n",InBuffer);
rc=strcmp(InBuffer,"end");
if(rc==0) break;
printf("Please Input Data to Send\n");
scanf("%s",OutBuffer);
//向命令管道写数据
rc=WriteFile(hPipeHandle,OutBuffer,sizeof(OutBuffer),
&BytesWrite,(LPOVERLAPPED)NULL);
if(rc==0 )
{err=GetLastError();
printf("Server Pipe Write Fail!err=%d\n",err);}
else printf("Server Pipe Write Success!\n");
DisconnectNamedPipe(hPipeHandle); //撤除与管道命令连接
rc=strcmp(OutBuffer,"end");
if(rc==0) break;
}
printf("Now server be END!\n");
CloseHandle(hPipeHandle);
return nRetCode;
}

/客户端进程/
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
BOOL rc=0;
char lpName[]="\\\\.\\pipe\\myPipe";
char InBuffer[50]="";
char OutBuffer[50]="";
DWORD BytesRead;
int nRetCode = 0;
int err=0;
while(1)
{
strcpy(InBuffer,"");
strcpy(OutBuffer,"");
printf("Input Data Please!\n");
scanf("%s",InBuffer);
if(!strcmp(InBuffer,"end"))
{CallNamedPipe(lpName,InBuffer,sizeof(InBuffer),OutBuffer,sizeof(OutBuffer),
&BytesRead,NMPWAIT_USE_DEFAULT_WAIT);
break;}
rc=WaitNamedPipe(lpName,NMPWAIT_WAIT_FOREVER); //等待命名管道
if(rc==0)
{
err=GetLastError();
printf("Wait Pipe Fali!err=%d\n",err);
exit(1);
}
else printf("Wait Pipe Success!\n");

//使用管道命令读数据
rc=CallNamedPipe(lpName,InBuffer,sizeof(InBuffer),OutBuffer,sizeof(OutBuffer), &BytesRead,NMPWAIT_USE_DEFAULT_WAIT);
rc=strcmp(OutBuffer,"end");
if (rc==0) break;
if (rc==0)
{
err=GetLastError();
printf("Call Pipe Fali!err=%d\n",err);
exit(1);
}
else printf("Call Pipe Success!\n Data from Server is %s\n",OutBuffer);
}
printf("Now Client to be END!\n");
return nRetCode;
}

实验题目：实验五读者-写者问题
完成人：XXX
报告日期：2018年4月28日
七、 实验内容简要描述
a) 创立一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求进展读写操作。用信号量机制分别实现读者优先和写者优先的读者-写者问题。
b) 读者-写者问题的读写操作限制(包括读者优先和写者优先)：
j写-写互斥，即不能有两个写者同时进展写操作。
k读-写互斥，即不能同时有一个线程在读，而另一个线程在写。
l读-读允许，即可以有一个或多个读者在读。
c) 读者优先的附加限制：如果一个读者申请进展读操作时已有另一个读者正在进展读操作，那么该读者可直接开场读操作。
d) 写者优先的附加限制：如果一个读者申请进展读操作时已有另一写者在等待访问共享资源，那么该读者必须等到没有写者处于等待状态后才能开场读操作。
e) 运行结果显示要求：要求在每个线程创立、发出读写操作申请、开场读写操作和完毕读写操作时分别显示一行提示信息，以确定所有处理都遵守相应的读写操作限制。
八、 程序设计
7、 设计思路
将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者，当写允许时，释放第一个写者操作。

读者优先：
如果没有写者正在操作，那么读者不需要等待，用一个整型变量readcount记录当前的读者数目，用于确定是否释放写者线程，〔当readcout=0 时，说明所有的读者都已经读完，释放一个写者线程〕，每个读者开场读之前都要修改readcount,为了互斥的实现对readcount 的修改，需要一个互斥对象Mutex来实现互斥。
另外，为了实现写-写互斥，需要一个临界区对象 write,当写者发出写的请求时，必须先得到临界区对象的所有权。通过这种方法，可以实现读写互斥，当readcount=1 时，〔即第一个读者的到来时，〕，读者线程也必须申请临界区对象的所有权.
当读者拥有临界区的所有权，写者都阻塞在临界区对象write上。当写者拥有临界区对象所有权时，第一个判断完readcount==1 后，其余的读者由于等待对readcount的判断，阻塞在Mutex上！

写者优先：
写者优先和读者优先有一样之处，不同的地方在：一旦有一个写者到来时，应该尽快让写者进展写，如果有一个写者在等待，那么新到的读者操作不能读操作，为此添加一个整型变量writecount,记录写者的数目，当writecount=0时才可以释放读者进展读操作！
为了实现对全局变量writecount的互斥访问，设置了一个互斥对象Mutex3。
为了实现写者优先，设置一个临界区对象read,当有写者在写或等待时，读者必须阻塞在临界区对象read上。
读者除了要一个全局变量readcount实现操作上的互斥外，还需要一个互斥对象对阻塞在read这一个过程实现互斥，这两个互斥对象分别为mutex1和mutex2。

8、 主要数据构造
void RP_ReaderThread(void* p) 读者线程信息
voi