实验1编程实现进程(线程)同步和互斥

实验1编程实现进程（线程）同步和互斥

一、实验目的

①通过编写程序实现进程同步和互斥，使学生掌握有关进程（线程）同步与

互斥的原理，以及解决进程（线程）同步和互斥的算法，从而进一步巩固进程（线程）同步和互斥

②等有关的内容。

③了解Windows2000/XP中多线程的并发执行机制，线程间的同步和互斥。

④学习使用Windows2000/XP中基本的同步对象，掌握相应的

⑤API函数。

⑥掌握进程和线程的概念，进程（线程）的控制原语或系统调用的使用。

⑦掌握多道程序设计的基本理论、方法和技术，培养学生多道程序设计的能

力。

二、实验内容

在Windows XP、Windows 2000等操作系统下，使用的VC、VB、java或C 等编程语言，采用进程（线程）同步和互斥的技术编写程序实现生产者消费者问题或哲学家进餐问题或读者-写者问题或自己设计一个简单进程（线程）同步和互斥的实际问题。

三、实验要求

①经调试后程序能够正常运行。

②采用多进程或多线程方式运行，体现了进程（线程）同步和互斥的关系。

③程序界面美观。

四、实验步骤、过程

让写者与读者、读者与读者之间互斥的访问同一数据集，在无写者进程到来时各读者可同时的访问数据集，在读者和写者同时等待时写者优先唤醒。设置两个全局变量readcount 和writecount来记录读者与写者的数目，设置了3个信号量。h_mutex1表示互斥对象对阻塞在read这一个过程实现互斥，h_mutex2实现全局变量readcount操作上的互斥，h_mutex3实现对全局变量writecount的互斥访问。设置了两个临界区，为了实现写者优先，用了临界区read。数据结构：（1）用了两个临界区（2）自定义结构ThreadInfo记录一条线程信息，多个线程对应一个ThreadInfo数组。（3）设置了互斥量h_mutex1，实现了互斥对象对阻

塞read这一过程，h_mutex2实现对readcount操作的互斥，h_mutex3实现对writecount的互斥访问。

流程：

（1）主函数

（2）临界区初始化

（3）提取线程相关信息

（4）完成线程相关信号量的初始化

（5）创建读者与写者线程

（6）等待所有线程结束

（7）程序结束

（8）读者

（9）提取本线程信息

（10）等待，提出读请求

（11）进入临界区

（12）进行读操作，并判读是否读完

（15）退出临界区，读操作完成

（16）如果readcount=0，则唤醒写者

（17）写者

（18）提取本线程信息

（19）等待，发出写请求

（20）进入临界区

（21）进行写操作，并判断是否写完

（22）退出临界区，写操作完成

（23）如果writecount=0，则唤醒读者

代码：

#include

#include

#include

#include

#include

#define INTE_PER_SEC 1000//每秒时钟中断的数目

#define MAX_THREAD_NUM 64//最大线程数

int readcount=0;//读者数目

int writecount=0;//写者数目

CRITICAL_SECTION cs_write;

CRITICAL_SECTION cs_read;

void Writer(void *p);

void Reader(void *p);

//定义记录在测试文件中的线程参数数据结构

struct ThreadInfo

{ int serial;

char entity;

double delay;

double persist;

};

//全局变量定义

//临界区对象的声明，用于管理缓冲区的互斥访问

int m;

HANDLE h_Thread[MAX_THREAD_NUM]; //存储线程句柄的数组

ThreadInfo Thread_Info[MAX_THREAD_NUM]; //线程信息数组

HANDLE h_mutex1; //互斥对象对阻塞在read这一个过程实现互斥HANDLE h_mutex2; //全局变量readcount实现操作上的互斥DWORD n_Thread=0; //实际线程数目

HANDLE h_mutex3; //对全局变量writecount的互斥访问

int main(void)

{

DWORD wait_for_all;

FILE *inFile; //ifstream inFile;

int i,j;

InitializeCriticalSection(&cs_write); //初始化临界区

InitializeCriticalSection(&cs_read);

//打开输入文件，提取线程信息

inFile=fopen("test.txt","r");

fscanf(inFile, "%d",&m);

//提取各线程信息到相应的数据结构中

while(!feof(inFile))

{

fscanf(inFile,"%d",&Thread_Info[n_Thread].serial);

fscanf(inFile,"\t%c",&Thread_Info[n_Thread].entity);

fscanf(inFile,"%lf",&Thread_Info[n_Thread].delay);

fscanf(inFile,"%lf",&Thread_Info[n_Thread].persist);

n_Thread++;

}

//回显获得的线程信息，便于确认正确性

for(j=0;j<(int)n_Thread;j++)

{

int Temp_serial=Thread_Info[j].serial;

char Temp_entity=Thread_Info[j].entity;

double Temp_delay=Thread_Info[j].delay;

double Temp_persist=Thread_Info[j].persist;

printf(" \n thread%2d %c %lf %lf",Temp_serial,Temp_entity,Temp_delay,Temp_persist);

printf("\n");

}

printf("\n\n");

//创建模拟过程中必要的信号量

h_mutex1=CreateMutex(NULL,FALSE,"mutex_for_readcount");

h_mutex2=CreateMutex(NULL,FALSE,"mutex_for_readwait");

h_mutex3=CreateMutex(NULL,FALSE,"mutex_for_writecount");

//创建读者和写者线程

for(i=0;i<(int)(n_Thread);i++)

{

if(Thread_Info[i].entity=='R'||Thread_Info[i].entity =='r')

{h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Reader),&(Thread_Info[i]),0,N ULL);}

else

{h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Writer),&(Thread_Info[i]),0,N ULL);}

}

//主程序等待各个线程的动作结束

wait_for_all=WaitForMultipleObjects(n_Thread,h_Thread,TRUE,-1);

printf(" \n \nALL READER and WRITER have finished their work, \n");

printf("Press any key to quit!\n");

return 0;

}

//读者线程

void Reader(void *p)

{//局部变量声明

DWORD wait_for_semaphore,wait_for_mutex;

DWORD m_delay;

DWORD m_persist;

int m_serial;

//获得本线程信息

m_serial=((ThreadInfo*)(p))->serial;

m_delay=(DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);

m_persist=(DWORD)(((ThreadInfo*)(p))->persist *INTE_PER_SEC);

Sleep(m_delay);

printf("Reader thread %d sends readering require.\n",m_serial);

wait_for_semaphore=WaitForSingleObject(h_mutex1,-1);

EnterCriticalSection(&cs_read);

wait_for_mutex=WaitForSingleObject(h_mutex2,-1);

readcount++;

if(readcount==1)

{

// 如果是第1个读者,等待写者写完

EnterCriticalSection(&cs_write);

}

ReleaseMutex(h_mutex2);// 释放互斥信号 Mutex2

//让其他读者进去临界区

LeaveCriticalSection(&cs_read);

ReleaseMutex(h_mutex1);

//读文件

printf("Reader thread %d begins to read file.\n",m_serial);

Sleep(m_persist);

//退出线程

printf("Reader thread %d finished reading file.\n",m_serial);

//阻塞互斥对象Mutex2,保证对readcount的访问,修改互斥

wait_for_mutex=WaitForSingleObject(h_mutex2,-1);

readcount--;

if(readcount==0)

{

//最后一个读者,唤醒写者

LeaveCriticalSection(&cs_write);

}

ReleaseMutex(h_mutex2); //释放互斥信号

}

//写者线程

void Writer(void *p)

{ DWORD wait_for_mutex3; //互斥变量

DWORD m_delay; //延迟时间

DWORD m_persist; //读文件持续时间

int m_serial; //线程序号

//从参数中获得信息

m_serial=((ThreadInfo*)(p))->serial;

m_delay=(DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);

m_persist=(DWORD)(((ThreadInfo*)(p))->persist *INTE_PER_SEC);

Sleep(m_delay); //延迟等待

printf("Writer thread %d sents the writing require.\n",m_serial);

wait_for_mutex3=WaitForSingleObject(h_mutex3,-1);

writecount++; //修改写者数目

if(writecount==1)

{

EnterCriticalSection(&cs_read);

}

ReleaseMutex(h_mutex3);

EnterCriticalSection(&cs_write);

printf("Writer thread %d begins to write to the file.\n",m_serial); Sleep(m_persist);

printf("Writer thread %d finished writing to the file.\n",m_serial); LeaveCriticalSection(&cs_write);

wait_for_mutex3=WaitForSingleObject(h_mutex3,-1);

writecount--;

if(writecount==0)

{

LeaveCriticalSection(&cs_read);

}

ReleaseMutex(h_mutex3);

}

五、实验结果或总结

1、测试文件

1 R

2 3

2 R

3 5

3 W 1 1

4 R 10 5

5 R 12 4

6 W 9 8

7 R 13 6

8 W 12 5

9 R 20 10

10 W 21 20 2、测试结果

3、测试结果分析

由测试结果可知，线程3最早发出操作请求，并执行，开始执行后线程1发出读请求，3完成操作，1开始读操作，2发出读请求，2开始读操作，1、2完成读操作，实现了读者同步，6发出写请求，6开始写操作，4、5发出读请求，8发出写请求，7发出读请求，形成2个等待队列，一个是读这等待队列有线程4、5、7，一个是写者等待队列8，当6完成操作时，优先唤醒写者线程8，实现了写者优先，写者写完了再唤醒读者等待队列，实现了多个读者同步。在8开始执行写操作后，10发出写请求，当8写完了才开始执行10的写操作，实现了写

写互斥，一次只能有一个写者在写。