进程(线程)的同步与互斥

一、实验题目

进程(线程)的同步与互斥

二、实验目的

1. 掌握基本的同步与互斥算法,理解生产者消费者模型。
2. 学习使用Windows中基本的同步对象,掌握相关API的使用方法。
3. 了解Windows中多线程的并发执行机制,实现进程的同步与互斥。

三、实验内容与要求

1. 实验内容
以生产者/消费者模型为依据,在Windows 环境下创建一个控制台进程,在该进程中创建n个线程模拟生产者和消费者,实现进程(线程)的同步与互斥。

2. 实验要求
 学习并理解生产者/消费者模型及其同步/互斥规则;
 学习了解Windows同步对象及其特性;
 熟悉实验环境,掌握相关API的使用方法;
 设计程序,实现生产者/消费者进程(线程)的同步与互斥;

四、算法描述(含数据结构定义)或流程图

我们利用Windows SDK提供的API编程实现实验题目要求,而VC中包含有Windows SDK的所有工具和定义。要使用这些API,需要包含 对这些函数进行说明的SDK头文件——最常见的是Windows.h(特殊的API调用还需要包含其他头文件)。
下面给出的是本实验使用到的API的功能和使用方法简单介绍。
(1) CreateThread
 功能——创建一个在调用进程的地址空间中执行的线程
 格式

HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParamiter,
DWORD dwCreationFlags,
Lpdword lpThread  );

 参数说明
lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。
dwStackSize——定义原始堆栈大小。
lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。
lpParamiter——定义一个给进程传递参数的指针。
dwCreationFlags——定义控制线程创建的附加标志。
lpThread——保存线程标志符(32位)
(2) CreateMutex
 功能——创建一个命名或匿名的互斥量对象
 格式
HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCTSTR lpName);
 参数说明
lpMutexAttributes——必须取值NULL。
bInitialOwner——指示当前线程是否马上拥有该互斥量(即马上加锁)。
lpName——互斥量名称。
(3) CreateSemaphore
 功能——创建一个命名或匿名的信号量对象
 格式
HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCTSTR lpName );
 参数说明
lpSemaphoreAttributes——必须取值NULL。
lInitialCount——信号量的初始值。该值大于等于0,但小于等于lMaximumCount指定的最大值。
lMaximumCount——信号量的最大值。
lpName——信号量名称。
(4) WaitForSingleObject
 功能——使程序处于等待状态,直到信号量hHandle出现(即其值大于0)或超过规定的等待时间
 格式
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
 参数说明
hHandle——信号量指针。
dwMilliseconds——等待的最长时间(INFINITE为无限等待)。
(5) ReleaseSemaphore
 功能——对指定信号量加上一个指定大小的量。成功执行则返回非0值
 格式
BOOL ReleaseSemaphore(HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lppreviousCount );
 参数说明
hSemaphore——信号量指针。
lReleaseCount——信号量的增量。
lppreviousCount——保存信号量当前值。
(6) ReleaseMutex
 功能——打开互斥锁,即把互斥量加1。成功调用则返回0
 格式
BOOL ReleaseMutex(HANDLE hMutex);
 参数说明
hMutex——互斥量指针。

五、实验过程

#include <windows.h>  
#include <iostream>
using namespace std;
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#define MAX_THREAD_NUM 64          //最大线程数
#define INTE_PER_SEC 1000             //延迟时间的毫秒值
const int SIZE_OF_BUFFER = 10;          //缓冲区长度
int ProductID = 0;                       //产品号
int ConsumeID = 0;                        //将被消耗的产品号
int in = 0;                              //产品进缓冲区时的缓冲区下标
int out = 0;                                 //产品出缓冲区时的缓冲区下标
bool running=true;                     //判断程序能否继续执行的逻辑值
int g_buffer[SIZE_OF_BUFFER];         //缓冲区是个循环队列
HANDLE g_hMutex;                        //公有信号量,用于线程间的互斥
HANDLE g_hFullSemaphore;             //生产者的私有信号量,当缓冲区满时迫使生产者等待
HANDLE g_hEmptySemaphore;         //消费者的私有信号量,当缓冲区空时迫使消费者等待
//定义一个结构体用于存储线程的信息
struct ThreadInfo
{
       int  serial      ;     //线程号    //填空
       char entity;    //线程类别(生产者或消费者)
       double delay;   //等待时间
       double persist; //操作时间
};
//生产者
void Producer(void *p)
{
       //定义变量用于存储当前线程的信息
       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);
       while(running)
       {
              //P操作
              cout<<"生产者线程 "<<m_serial<<" 请求生产."<<endl;
              WaitForSingleObject(g_hEmptySemaphore,INFINITE);
              cout<<"生产者线程 "<<m_serial<<" 请求独占缓冲区."<<endl;
              WaitForSingleObject(g_hMutex,INFINITE);
              Sleep(m_delay);  //延迟等待
              //生产一个产品
              cout<<"生产者线程 "<<m_serial<<" 生产 "<<++ProductID <<" 号产品成功." <<endl;
              cout<<"生产者线程 "<<m_serial<<" 请求将产品 "<<ProductID<<" 投入缓冲区."<<endl;
              //把新生产的产品放入缓冲区
              g_buffer[in] = ProductID;
               in=(in+1)%SIZE_OF_BUFFER;                									Sleep(m_persist);   //操作等待
              cout<<"生产者线程 "<<m_serial<<" 将产品 "<<ProductID<<" 投入缓冲区中成功."<<endl;
              //输出缓冲区当前的状态
              cout<<"****************************"<<endl
      <<"\n当前缓冲区情况如图(■代表已有产品,□代表没有产品):   "<<endl;
              for (int i=0;i<SIZE_OF_BUFFER;++i)
              {
                     if(g_buffer[i]!=0)   cout<<"■";
                     else  cout<<"□";
              }
              cout<<"\n\n****************************\n"<<endl;
              //V操作
              ReleaseMutex(g_hMutex);       
              ReleaseSemaphore(g_hFullSemaphore,1,NULL);
       }
}
//消费者
void Consumer(void *p)
{
       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);
       while(running)
       {
              //P操作
              cout<<"消费者线程 "<<m_serial<<" 请求消费."<<endl;
              WaitForSingleObject(g_hFullSemaphore,INFINITE);
              cout<<"消费者线程 "<<m_serial<<" 请求独占缓冲区."<<endl;                                  					WaitForSingleObject(g_hMutex,INFINITE);     
              Sleep(m_delay); //延迟等待
              //从缓冲区中取出一个产品
              cout<<"消费者线程 "<<m_serial<<" 请求取出一个产品."<<endl;
              ConsumeID = g_buffer[out];
              g_buffer[out]=0;
              out = (out+1)%SIZE_OF_BUFFER;
              cout<<"消费者线程 "<<m_serial<<" 取出产品 "<<ConsumeID<<" 成功."<<endl;
              //消耗一个产品
              cout<<"消费者线程 "<<m_serial<<" 开始消费消费产品 " <<ConsumeID<<"."<<endl;
              Sleep(m_persist);
              cout<<"消费者线程 "<<m_serial<<" 消费产品 " <<ConsumeID<<" 成功."<<endl;

              //输出缓冲区当前的状态
              cout<<"****************************"<<endl
                     <<"\n当前缓冲区情况如图:   "<<endl;
              for (int i=0;i<SIZE_OF_BUFFER;++i)
              {
                     if(g_buffer[i]!=0)
                            cout<<"■";
                     else  cout<<"□";
              }
              cout<<"\n\n****************************\n"<<endl;
              //V操作
              ReleaseMutex(g_hMutex);
              ReleaseSemaphore(g_hEmptySemaphore,1,NULL);
       }
}
void prod_cons()

{
       //创建互斥信号量
       g_hMutex = CreateMutex(NULL,FALSE,NULL);
    //创建同步信号量
g_hEmptySemaphore=CreateSemaphore(NULL,SIZE_OF_BUFFER,SIZE_OF_BUFFER,NULL);
       g_hFullSemaphore=CreateSemaphore(NULL,0 ,SIZE_OF_BUFFER,NULL);
       srand((unsigned)time(NULL));  //以时间函数为种子
       const unsigned short THREADS_COUNT = rand()%5+5; //总的线程数(随机生成)
       //线程对象的数组
       HANDLE hThreads[MAX_THREAD_NUM];
       ThreadInfo thread_info[MAX_THREAD_NUM];
       DWORD thread_ID; //线程ID
       int num=0;       //临时变量,用于循环语句
       cout<<"系统开始模拟,并自动生成模拟数据..."<<endl;
       system("pause"); //暂停确认开始执行
       cout<<"线程总数:"<<THREADS_COUNT<<endl;
       //循环随机生成各个线程的信息
       while(num!=THREADS_COUNT)
       {
              thread_info[num].serial=num+1;
              if(rand()%2==1)
                     thread_info[num].entity='P';
              else
                     thread_info[num].entity='C';
              thread_info[num].delay=rand()%5+1;
              thread_info[num].persist=rand()%6+2;
              num++;
       }
       cout<<"\n系统生成数据结束,模拟数据如下:"<<endl
              <<"线程号  线程类别    延迟时间    操作时间"<<endl;
       for(int x=0;x<THREADS_COUNT;x++)
              cout<<"  "<<thread_info[x].serial<<"\t"
                     <<"   "<<thread_info[x].entity<<"\t"
                     <<"      "<<thread_info[x].delay<<"\t\t"
                     <<"   "<<thread_info[x].persist<<endl;
       cout<<"\n\n============生产者-消费者 开始============\n"<<endl;
       //创建线程
       for(int i=0;i<THREADS_COUNT;i++)
       {
              //创建生产者线程
              if(thread_info[i].entity=='P')   hThreads[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Producer),&thread_info[i],0,&thread_ID);
              //创建消费者线程
              else    hThreads[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Consumer),&thread_info[i],0,&thread_ID);
       }
       while(running)
       {
              if(getchar())
              {
                running = false;
              }
       }
       cout<<"系统模拟结束..."<<endl;
}
int main()
{
       cout<<"\n======生产者-消费者 模拟==========\n"<<endl;
       prod_cons();
}

六、实验结果分析

1、记录生产者和消费者的同步执行过程
线程号 线程类别 延迟时间 操作时间 操作请求 缓存区请求 生产结果
1 P 1 2 请求生产 请求独占(在2前) 未生产
2 P 2 6 请求生产 请求独占 未消费
3 C 4 5 请求消费 无 未消费
4 C 5 6 请求消费 无 未消费
5 C 3 2 无 无 未消费

2、分析Producer函数和Consumer函数的功能,并画出对应的程序流程图。
Producer函数:通过用变量提取保存提取当前资源信息,然后判断是否执行,接着发出生产请求,请求通过后独占缓冲区资源,接着生产一个产品投入缓冲区,成功后释放所占缓冲区资源,到此此函数执行完成。
Consumer函数:也通过用变量提取保存提取当前资源信息,然后判断是否执行,接着发出消费请求,请求通过后独占缓冲区资源,接着消费一个产品取出缓冲区,成功后释放所占缓冲区资源,到此此函数执行完成。

3、试将同步和互斥的P操作颠倒次序执行,观察并分析程序的运行情况。
程序产生死锁,程序无法正常运行下去,因为同步和互斥的P操作颠倒次序,即先独占缓冲区资源,后发送请求,因为先独占缓冲区资源,若生产(消费)请求无法通过则一直等待,无法释放资源。

  • 8
    点赞
  • 51
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Windows2000环境下,创建一个控制台进程,此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件(后面有介绍)的要求进行读写操作。用信号量机制分别实现读者优先和写者优先的读者-写者问题。 读者-写者问题的读写操作限制(包括读者优先和写者优先): 1)写-写互斥,即不能有两个写者同时进行写操作。 2)读-写互斥,即不能同时有一个线程在读,而另一个线程在写。, 3)读-读允许,即可以有一个或多个读者在读。 读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。 写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。 运行结果显示要求:要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息,以确定所有处理都遵守相应的读写操作限制。 2测试数据文件格式 测试数据文件包括n行测试数据,分别描述创建的n个线程是读者还是写者,以及读写操作的开始时间和持续时间。每行测试数据包括四个字段,各个字段间用空格分隔。第一字段为一个正整数,表示线程序号。第二字段表示相应线程角色,R表示读者,w表示写者。第三字段为一个正数,表示读写操作的开始时间:线程创建后,延迟相应时间(单位为秒)后发出对共享资源的读写申请。第四字段为一个正数,表示读写操作的持续时间。当线程读写申请成功后,开始对共 享资源的读写操作,该操作持续相应时间后结束,并释放共享资源。 下面是一个测试数据文件的例子: 2 W 4 5 3 R 5 2 4 R 6 5 5 W 5.1 3
进程同步互斥是多进程编程中非常重要的概念,下面是一个简单的代码示例: ``` #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> pthread_t tid[2]; int counter; void* thread1(void* arg) { int i; for(i = 0; i < 5; i++) { counter++; printf("Thread 1: Counter = %d\n", counter); usleep(1); } } void* thread2(void* arg) { int i; for(i = 0; i < 5; i++) { counter--; printf("Thread 2: Counter = %d\n", counter); usleep(1); } } int main(void) { int i = 0; int err; while(i < 2) { err = pthread_create(&(tid[i]), NULL, &thread1, NULL); if (err != 0) printf("Can't create thread :[%s]", strerror(err)); i++; } pthread_join(tid[0], NULL); pthread_join(tid[1], NULL); return 0; } ``` 这段代码创建了两个线程,每个线程都执行了一个简单的循环,循环内对共享变量 counter 进行加减操作,并输出结果。由于两个线程都对共享变量进行读写,因此会出现数据不一致的问题。 为了解决这个问题,我们需要使用线程同步互斥机制。下面是一个修改后的代码示例: ``` #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> pthread_t tid[2]; int counter; pthread_mutex_t lock; void* thread1(void* arg) { int i; for(i = 0; i < 5; i++) { pthread_mutex_lock(&lock); counter++; printf("Thread 1: Counter = %d\n", counter); pthread_mutex_unlock(&lock); usleep(1); } } void* thread2(void* arg) { int i; for(i = 0; i < 5; i++) { pthread_mutex_lock(&lock); counter--; printf("Thread 2: Counter = %d\n", counter); pthread_mutex_unlock(&lock); usleep(1); } } int main(void) { int i = 0; int err; if (pthread_mutex_init(&lock, NULL) != 0) { printf("Mutex init failed\n"); return 1; } while(i < 2) { err = pthread_create(&(tid[i]), NULL, &thread1, NULL); if (err != 0) printf("Can't create thread :[%s]", strerror(err)); i++; } pthread_join(tid[0], NULL); pthread_join(tid[1], NULL); pthread_mutex_destroy(&lock); return 0; } ``` 在修改后的代码中,我们增加了一个互斥锁,每当线程要对共享变量进行读写时,需要先获取锁,然后执行操作,最后释放锁。这样可以保证同一时刻只有一个线程可以对共享变量进行操作,从而避免了数据不一致的问题。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值