线程的同步和互斥问题

实验二线程的同步和互斥问题

一．实验内容：

编写程序实现并发线程之间的同步和互斥问题。

线程间的互斥：并发执行的线程共享某些类临界资源，对临界资源的访问应当采取互斥的机制。

线程间的同步：并发执行的线程间通常存在相互制约的关系，线程必须遵循一定的规则来执行，同步机制可以协调相互制约的关系。

二．实验目的和要求

1）了解进程同步与互斥的概念，掌握编写进程同步、互斥的实例。

2）解决一类典型的进程间同步问题，如生产者-消费者问题，读者-写者问题等。

三．实验方法和步骤

1．实验方法

掌握同步与互斥的机制，选取合适的问题，给出演示程序的设计思想，包括流程图的形式；选取C、C++、VC、JA V A等计算机语言，编程调试，最终给出运行正确的程序。

2．程序设计

（1）线程间互斥：

分析问题，创建多个线程，找出临界资源，划出正确的临界区，根据互斥机制的操作模式，编写程序。

互斥机制的操作模式：

p(mutex);/*关锁*/

临界区的操作；

v(mutex);/*开锁*/

（2）线程间同步——读者-写者问题示例：

在Windows 2000 环境下，创建一个包含n 个线程的控制台进程。用这n 个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求，进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的读写操作限制：

1）写-写互斥；2）读-写互斥；3）读-读允许；

运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确信所有处理都遵守相应的读写操作限制。

测试数据文件格式

测试数据文件包括n 行测试数据，分别描述创建的n 个线程是读者还是写者，以及读写操作的开始时间和持续时间。每行测试数据包括四个字段，各字段间用空格分隔。第一字段为一个正整数，表示线程序号。第二字段表示相应线程角色，R 表示读者是，W 表示写者。

第三字段为一个正数，表示读写操作的开始时间。线程创建后，延时相应时间（单位为秒）后发出对共享资源的读写申请。第四字段为一个正数，表示读写操作的持续时间。当线程读写申请成功后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。

下面是一个测试数据文件的例子：

1 R 3 5

2 W 4 5

3 R 5 2

4 R 6 5

5 W 5.1 3

与实验相关的API 介绍

在本实验中可能涉及的API 有：

线程控制：

CreateThread 完成线程创建，在调用进程的地址空间上创建一个线程，以执行指定的函

数；它的返回值为所创建线程的句柄。

HANDLE CreateThread（

LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD

DWORD dwStackSize, // initial stack size

LPTHREAD_START_ROUTINE lpStartAddress, // thread

function

LPVOID lpParameter, // thread argument

DWORD dwCreationFlags, // creation option

LPDWORD lpThreadId // thread identifier

）;

ExitThread 用于结束当前线程。

VOID ExitThread（

DWORD dwExitCode // exit code for this thread

）;

Sleep 可在指定的时间内挂起当前线程。

VOID Sleep（

DWORD dwMilliseconds // sleep time

）;

信号量控制：

CreateMutex 创建一个互斥对象，返回对象句柄；

HANDLE CreateMutex（

LPSECURITY_ATTRIBUTES lpMutexAttributes, // SD

BOOL bInitialOwner, // initial owner

LPCTSTR lpName // object name

）;

OpenMutex 打开并返回一个已存在的互斥对象句柄，用于后续访问；HANDLE OpenMutex（

DWORD dwDesiredAccess, // access

BOOL bInheritHandle, // inheritance option

LPCTSTR lpName // object name

）;

ReleaseMutex 释放对互斥对象的占用，使之成为可用。

BOOL ReleaseMutex（

HANDLE hMutex // handle to mutex

）;

WaitForSingleObject 可在指定的时间内等待指定对象为可用状态；

DWORD WaitForSingleObject（

HANDLE hHandle, // handle to object DWORD dwMilliseconds // time-out interval ）;

实验程序代码

#include

#include

#include

#include

#include

#include

#define MAX_PERSON 100

#define READER 0

#define WRITER 1

#define END -1

#define R READER

#define W WRITER

typedef struct _Person

{

HANDLE m_hThread;

int m_nType;

int m_nStartTime;

int m_nWorkTime;

int m_nID;

}Person;

Person g_Persons[MAX_PERSON];

int g_NumPerson = 0;

long g_CurrentTime= 0;

int g_PersonLists[] = {

1, R, 5, 5,

2, W, 4, 5,

3, R, 2, 2,

4, R, 1, 5,

END,

};

int g_NumOfReading = 0;

HANDLE g_hReadMutex;

HANDLE g_hWriteMutex;

void CheckPersonList(int *pPersonList);

bool CreateReader(int StartTime,int WorkTime);

bool CreateWriter(int StartTime,int WorkTime); DWORD WINAPI ReaderProc(LPVOID lpParam); DWORD WINAPI WriterProc(LPVOID lpParam);

int main()

{

g_hReadMutex = CreateMutex(NULL,FALSE,NULL); g_hWriteMutex = CreateMutex(NULL,FALSE,NULL); g_CurrentTime = 0;

while(true)

{

CheckPersonList(g_PersonLists);

g_CurrentTime++;

Sleep(300);

printf("CurrentTime = %d\n",g_CurrentTime);

}

return 0;

}

void CheckPersonList(int *pPersonLists)

{

int i=0;

int *pList = pPersonLists;

bool Ret;

while(pList[0] != END)

{

if(pList[2] == g_CurrentTime)

{

switch(pList[1])

{

case R:

Ret = CreateReader(pList[2],pList[3]);

break;

case W:

Ret = CreateWriter(pList[2],pList[3]);

break;

}

if(!Ret)

printf("Create Person %d is wrong\n",pList[0]);

}

pList += 4; // move to next person list

}

}

DWORD WINAPI ReaderProc(LPVOID lpParam)

{

Person *pPerson = (Person*)lpParam;

printf("Reader %d is request the Shared Buffer...\n",pPerson->m_nID); WaitForSingleObject(g_hReadMutex,INFINITE);

if(g_NumOfReading ==0)

{

WaitForSingleObject(g_hWriteMutex,INFINITE);

}

g_NumOfReading++;

ReleaseMutex(g_hReadMutex);

printf("Reader %d is request ok\n",pPerson->m_nID);

// modify the reader's real start time

pPerson->m_nStartTime = g_CurrentTime;

printf("Reader %d is Reading the Shared Buffer...\n",pPerson->m_nID);

while(g_CurrentTime <= pPerson->m_nStartTime + pPerson->m_nWorkTime) {

// .. perform read operations

}

printf("Reader %d is Exit...\n",pPerson->m_nID);

WaitForSingleObject(g_hReadMutex,INFINITE);

g_NumOfReading--;

if(g_NumOfReading == 0)

ReleaseMutex(g_hWriteMutex);

ReleaseMutex(g_hReadMutex);

ExitThread(0);

return 0;

}

DWORD WINAPI WriterProc(LPVOID lpParam)

{

WaitForSingleObject(g_hWriteMutex,INFINITE);

Person *pPerson = (Person*)lpParam;

// modify the writer's real start time

pPerson->m_nStartTime = g_CurrentTime;

printf("Writer %d is Writting the Shared Buffer...\n",pPerson->m_nID);

while(g_CurrentTime <= pPerson->m_nStartTime + pPerson->m_nWorkTime)

{

// .. perform write operations

}

printf("Writer %d is Exit...\n",pPerson->m_nID);

ReleaseMutex(g_hWriteMutex);

ExitThread(0);

return 0;

}

bool CreateReader(int StartTime,int WorkTime)

{

DWORD dwThreadID;

if(g_NumPerson >= MAX_PERSON)

return false;

Person *pPerson = &g_Persons[g_NumPerson];

pPerson->m_nID = g_NumPerson;

pPerson->m_nStartTime = StartTime;

pPerson->m_nWorkTime = WorkTime;

pPerson->m_nType = READER;

g_NumPerson++;

// Create an New Thread

pPerson->m_hThread = CreateThread(NULL,0,ReaderProc,(LPVOID)pPerson,0,&dwThreadID);

if(pPerson->m_hThread == NULL)

return false;

return true;

}

bool CreateWriter(int StartTime,int WorkTime)

{

DWORD dwThreadID;

if(g_NumPerson >= MAX_PERSON)

return false;

Person *pPerson = &g_Persons[g_NumPerson];

pPerson->m_nID = g_NumPerson;

pPerson->m_nStartTime = StartTime;

pPerson->m_nWorkTime = WorkTime;

pPerson->m_nType = WRITER;

g_NumPerson++;

// Create an New Thread

pPerson->m_hThread = CreateThread(NULL,0,WriterProc,(LPVOID)pPerson,0,&dwThreadID);

if(pPerson->m_hThread == NULL)

return false;

return true;

}

四．实验结果分析

通过运行多线程并发执行，观察运行的效果，分析互斥与同步的运行效果。在互斥机制下，能否同时访问临界资源；在同步机制下，线程的执行是否存在固定的协调次序，如何修改程序来控制线程的协调运行？