操作系统实验7-死锁

实验七死锁

一、基本信息

二、实验内容

编写一个多线程程序，实现7.5.3小节所描述的银行家算法。创建n个线程来向银行申请或释放资源。只有保证系统安全，银行家才会批准请求。可以用Pthread或Win32线程来编程。注意共享数据的并发访问要安全。可以通过互斥锁来保证访问安全。关于这两个库的互斥锁的讨论。

三、实验目的

1. 通过实验，理解银行家算法的算法思想及其实现方法，加深对线程死

锁、系统安全状态等概念的理解。

四、设计思路和流程图

(1)创建信号量：Mutex

(2)主程序创建10个线程，从控制台读取需求请求，由随机线程执行请求

(3)子线程中，首先判断需求是否超过该线程最大需求。接着判断可用资源

能否满足需求。

(4)判断该线程是否存在一个或多个安全线程执行顺序。有，则表示安全，

通过需求请求；没有，则表示不安全，不能通过需求请求

(5)同时利用信号量Mutex产生对缓冲区使用的互斥功能

(6)主程序等待子程序结束后，结束整个程序

五、主要数据结构及其说明

#include

#include

#include

#include

#include

#define N 5 //线程数

#define M 3 //资源种类数

HANDLE Mutex; //互斥量

int Available[M] = {20,20,20}; //每种资源的现有实例数量

int Max[N][M] = {{9,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; //每个进程的最大需求

int Allocation[N][M] = {{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//每个进程现在所分配的各种资源类型的实例数量

int Need[N][M]; //每个进程还需要的剩余的资源

int Request[M]; //需求记录

int flag; //标记发出需求请求的线程(0-9表示线程号，-1为初始值)

int Work[M]; //记录剩余可获得的资源

bool Finish[N]; //记录可以执行的线程

void init()

{

flag = -1;

Mutex = CreateMutex(NULL, FALSE, NULL);//互斥锁初始化

//初始化Need

int i,j;

for(i=0; i

for(j=0; j

Need[i][j] = Max[i][j] - Allocation[i][j];

}

bool CheckSafty(int thr)

{

//初始化数据

int i,j,k;

for(i=0; i

Work[i] = Available[i];

for(j=0; j

Finish[j] = false;

int proc[N]; //记录安全线程顺序int cnt = 1; //记录安全线程个数proc[cnt-1] = thr;

bool flag = true;

Finish[thr] = true;

//临界区

WaitForSingleObject(Mutex, INFINITE);

for(k=0; k

{

for(i=0; i

{

if(!Finish[i])

{

for(j=0; j

if(Need[i][j] > Work[j])

{flag = false;break;}

if(flag)

{

proc[cnt++] = i;

Finish[i] = true;

for(int m=0; m

Work[j] += Allocation[i][j];

}

else flag = true;

}

}

if(cnt == N) break;

}

ReleaseMutex(Mutex);

//判断所有线程都符合

if(cnt != N)

return false;

//打印安全顺序

printf("Request of Thread %d is safe!\nThe safe order of threads is:\n",thr);

for(i=0; i

printf("%d ",proc[i]);

putchar('\n');

return true;

}

int RequestSource(int thr)

{

int j;

//判断是否超过最大所需

for(j=0; j

if(Request[j] > Need[thr][j])

return -1; //超出最大请求

//判断需求是否能够满足

for(j=0; j

if(Request[j] > Available[j])

return -2;

//临界区

WaitForSingleObject(Mutex, INFINITE);

for(j=0; j

{

Available[j] -= Request[j];

Allocation[thr][j] += Request[j];

Need[thr][j] -= Request[j];

}

ReleaseMutex(Mutex);

//如果不安全，则请求失败

if(!CheckSafty(thr))

{

//临界区

WaitForSingleObject(Mutex, INFINITE);

for(j=0; j

{

Available[j] += Request[j];

Allocation[thr][j] -= Request[j];

Need[thr][j] += Request[j];

}

ReleaseMutex(Mutex);

return 1;//请求失败

}

return 0;

}

DWORD WINAPI runner(void *param)

{

int i,result,thr = (int)param;

while(true)

{

Sleep(1000);

if(flag == thr)

{

result = RequestSource((int)param);

switch(result)

{

case -2:

printf("Request for thread %d is not available\n",thr);

break;

case -1:

printf("Request for thread %d is exceeded\n",thr);

break;

case 1:

printf("Request for thread %d is not Safe!\n",thr);

break;

default: break;

}

flag = -1;

}

}

}

int main()

{

int i,j;

init();

srand((unsigned)time(NULL));//播种

DWORD ThreadId[N];

HANDLE ThreadHandles[N];

for(i=0; i

{

ThreadHandles[i] = CreateThread(

NULL,

0,

runner, //线程函数

(LPVOID)i, //传递给线程函数的参数

0,

&ThreadId[i]);

}

for(i=0; i

{

printf("Input request:");

for(j=0; j

scanf("%d",&Request[j]);

flag = rand() % N;

Sleep(5000); //主线程休息5秒

}

printf("The main thread ends.\n");

WaitForMultipleObjects(N,ThreadHandles,TRUE,INFINITE);

system("pause");

return 0;

}

六、程序运行时的初值和运行结果

七、实验体会

通过实验，深刻了解到了银行家算法的实现机制。并且，进一步学习了Windows环境下互斥锁的实现方法，加深了对临界区问题和进程同步机制的理解，同时巩固利用Windows API进行多线程编程的方法。