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

一、实验题目

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

二、实验目的

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
    点赞
  • 52
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
智慧校园整体解决方案是响应国家教育信息化政策,结合教育改革和技术创新的产物。该方案以物联网、大数据、人工智能和移动互联技术为基础,旨在打造一个安全、高效、互动且环保的教育环境。方案强调从数字化校园向智慧校园的转变,通过自动数据采集、智能分析和按需服务,实现校园业务的智能化管理。 方案的总体设计原则包括应用至上、分层设计和互联互通,确保系统能够满足不同用户角色的需求,并实现数据和资源的整合与共享。框架设计涵盖了校园安全、管理、教学、环境等多个方面,构建了一个全面的校园应用生态系统。这包括智慧安全系统、校园身份识别、智能排课及选课系统、智慧学习系统、精品录播教室方案等,以支持个性化学习和教学评估。 建设内容突出了智慧安全和智慧管理的重要性。智慧安全管理通过分布式录播系统和紧急预案一键启动功能,增强校园安全预警和事件响应能力。智慧管理系统则利用物联网技术,实现人员和设备的智能管理,提高校园运营效率。 智慧教学部分,方案提供了智慧学习系统和精品录播教室方案,支持专业级学习硬件和智能化网络管理,促进个性化学习和教学资源的高效利用。同时,教学质量评估中心和资源应用平台的建设,旨在提升教学评估的科学性和教育资源的共享性。 智慧环境建设则侧重于基于物联网的设备管理,通过智慧教室管理系统实现教室环境的智能控制和能效管理,打造绿色、节能的校园环境。电子班牌和校园信息发布系统的建设,将作为智慧校园的核心和入口,提供教务、一卡通、图书馆等系统的集成信息。 总体而言,智慧校园整体解决方案通过集成先进技术,不仅提升了校园的信息化水平,而且优化了教学和管理流程,为学生、教师和家长提供了更加便捷、个性化的教育体验。
进程同步互斥是多进程编程中非常重要的概念,下面是一个简单的代码示例: ``` #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、付费专栏及课程。

余额充值