精华内容
下载资源
问答
  • 进程同步与互斥

    2013-12-19 10:17:14
    有关于进程同步互斥的C语言实现,希望对你们有帮助!
  • 大连理工大学操作系统大作业, 进程同步与互斥 生产者消费者问题
  • Java实现的进程同步与互斥(PV) Hao语言
  • 进程同步与互斥C++

    2012-02-10 22:16:23
    进程同步与互斥,C++实现,附详细注释,可用于课程设计
  • 操作系统——进程同步与互斥

    千次阅读 2019-10-21 22:13:19
    文章目录进程同步与互斥简介进程间合作进程间合作的问题竞争条件原子操作临界区相关的几个概念忙等待的互斥基于硬件的同步解决办法:屏蔽中断基于软件的同步解决方法严格轮换法Peterson解法N线程的软件方法基于软件...

    进程同步与互斥

    简介

    多线程并发会导致资源竞争。

    同步即协调多线程对共享数据的访问,保证任何时刻都只能有一个线程执行临界区代码。

    互斥是解决进程同步的方式。

    进程间合作

    独立进程是指一个进程在运行过程中不会与其他进程进行交互的进程。

    但是,进程在运行的过程中不可避免的要进行进程间合作。

    进程合作的优势:

    • 共享资源
      • 一台电脑,多个用户
      • 一个银行存储余额,多台ATM机
      • 嵌入式系统(机器人控制:手臂和手的协调)
    • 加速
      • I / O操作和计算可重叠
      • 多处理机——将程序分成多个部分执行
    • 模块快
      • 将大程序分解成小程序
        • 如编译系统。
      • 视系统易于扩展

    进程间合作的问题

    进程间合作要避免不确定性和不可重现性。由于进程调度的不确定性,因此进程的一个操作可能被打断。

    进程间通信要解决三个问题:

    1. 一个进程如何将信息传递给另一个进程
    2. 确保多个进程在关键活动中不会交叉,即进程互斥问题。
    3. 保证正确的访问顺序,即进程同步问题。

    竞争条件

    竞争条件是说多个进程读写某些共享数据,而最后的结果取决于进程运行的精确时序。

    案例:

    • 通过调用函数fork来创建一个进程。
      • new_pid = next_pid++;
      • 这一条语句翻译成汇编代码会是四句,因此要把他们当成一个原子操作去执行。
    • 两个程序并发执行访问并更改一个变量x。

    原子操作

    原子操作是指一次不存在任何中断或者失败的执行。

    • 该执行成功结束
    • 或者根本没有执行
    • 并且不应该出现任何部分执行的状态

    但是实际上操作往往不是原子的

    • 有些看上去是原子操作,但是实际上不是,如x++,实际上此条语句由三条汇编语言组成。
    • 有时甚至连单条机器指令都不是原子的,如Pipiline、super-scalar、out-of-order、page fault等。

    操作系统需要利用同步机制在进程并发执行的同时保证一些操作是原子操作。

    临界区相关的几个概念

    临界区是指多个程序访问临界资源的一段代码。也可以说是进程访问临界资源的一段需要互斥的代码。

    1. 在进入临界区前检查是否可进入临界区。
    2. 若可以进入,则设置相应标志表示正在访问临界区。
    3. 在访问完成之后将标志恢复为可访问临界区。
    4. 然后去执行非临界区代码。

    要避免竞争条件,即要找出某个途径来阻止多个进程同时读写共享数据,提出一种解决方案为互斥,即以某种手段保证当一个程序在使用一个共享爱那个文件或变量时,其他进程不能做同样的操作。

    互斥是指当一个进程处于临界区并访问共享资源时,没有其他进程会处于临界区并访问任何相同的共享资源。

    死锁是指多个进程相互等待完成特定任务二最终无法将自身任务进行下去。

    饥饿是指一个可执行的进程被调度器持续忽略,以至于虽然处于可执行状态却不被执行。

    避免竞争条件即使临界区中只能有一个进程。

    一个好的解决竞争条件的方案需要满足下列四个条件:

    1. 任何两个进程不能同时处于临界区
    2. 不应对CPU的速度和数量做任何假设
    3. 临界区外执行的进程不得阻塞其他进程
    4. 不得使进程无限期等待进入临界区
    5. 不能进入临界区的进程应该释放CPU资源(可选)。

    忙等待的互斥

    连续测试一个变量直到某个值出现为止称为忙等待,用于忙等待的锁称为自旋锁

    下列几种方式都可以保证任意两个进程不同时处于临界区。

    基于硬件的同步解决办法:屏蔽中断

    单处理器系统中,最简单的方法是使每个进程刚进入临界区后就立即屏蔽所有中断,并在就要离开之前再打开中断。屏蔽中断后,时钟中断也会被屏蔽,而CPU只有发生时钟中断或其他中断时才会进行进程切换,因此在屏蔽中断之后就不会被切换到其他进程。

    但是这种方式有一个问题:若此进程不打开中断的话其他进程就都无法执行。

    而且若是处于多处理器系统中,其他的CPU也可以将进程调度,从而还是无法避免多个进程同时访问临界区的问题。

    因此,屏蔽中断对用户进程不是一种合适的通用互斥机制。

    总结如下:

    • 硬件将中断处理延迟到中断被启用之后
    • 现代计算机体系结构都提供指令来实现禁用中断
      • 首先保存当前CPU状态
      • 然后禁用中断,访问临界区
      • 最后恢复CPU状态

    缺点:

    • 禁用中断之后,进程无法被停止。
      • 整个系统都会为之停下来
      • 可能导致其他进程处于饥饿状态
    • 临界区可能很长
      • 无法确定响应中断所需的时间

    基于软件的同步解决方法

    通过共享一些共有变量来同步进程的行为。

    严格轮换法

    在这里插入图片描述

    turn用来表示哪一个进程进入临界区,假设只有两个进程,进程0执行a代码,进程1执行b代码,此时考虑两种情况:

    1. 一个进程连续两次进入临界区,第一次进入临界区时发现turn是0,因此进入,在执行完临界区代码之后将turn的值设置为1,那么他在下次进入临界区之前发现turn不是0,因此一直循环等待,但此时临界区中是没有进程在执行的。
    2. 进程0先被调度执行,此时turn的值为0,因此进程0进入临界区执行代码,在它执行完临界区代码退出后,将turn的值更改为1,此时进程1被调度进入CPU执行,发现此时turn的值为1,因此执行临界区的代码,当临界区代码执行完毕之后将要更改turn的值时,CPU调度进程0进入CPU执行,但是此时turn的值还是为1,因此进程0不能执行临界区代码,但是此时临界区却没有进程在执行,因为违反了上面的第三条规则:为处于临界区的进程不得阻塞其他进程。

    由此可见,此种方式也不合适。

    Peterson解法

    在这里插入图片描述

    此算法可以解决两个进程的同步问题。

    N线程的软件方法

    进程Pi要等待从turn到i-1的进程都退出临界区后访问临界区。

    进程Pi退出时将turn给下一个想要进入的进程Pj。

    基于软件解决办法的分析

    • 复杂
      • 需要两个进程之间共享数据项
    • 需要忙等待
      • 浪费CPU时间

    更高级的抽象方法

    简介

    硬件提供了一些同步原语

    • 中断禁用,原子操作指令等

    操作系统提供更高级的编程抽象来监护进程同步

    • 如:锁、信号量
    • 用硬件原语来创建。

    原子操作指令

    现代CPU体系结构都提供一些特殊的原子操作指令。

    测试和置位(Test-and-set)指令

    • 从内存单元中读取值
    • 测试该值是否为1,然后返回真与假
    • 内存单元值设置为1

    交换(exchange)指令

    • 交换内存中的两个值。

    锁变量

    锁是一个抽象的数据结构

    • 一个二进制变量(锁定/解锁)
    • Lock::Acquire()
    • Lock::Release()

    使用锁来控制临界区的访问:当进程进入临界区之前先判断锁变量的值,若有锁的话就等待,否则进入临界区并且更改锁变量的值,然后再退出临界区时将锁变量的值再次修改。

    但是这又回到了最开始的问题:读锁变量和修改锁变量时两个操作,在第一个进程读取锁变量时发现可以进入,然后CPU调度第二个进程进入CPU进行执行,此时第一个进程还未将锁变量进行修改,因此第二个进程也发现可以进入,因此更改了锁变量进入临界区,此时又被切换至第一个进程,第一个进程认为此时临界区中没有进程,因此也进入了临界区,所以还是不能解决竞争条件的问题。

    使用TS指令实现自旋锁

    //忙等待,此种方式为自旋锁方式
    class Lock {
    	int value = 0;
    }
    Lock::Acquire() { //若锁被释放,则TS指令读取0并将值设置为1,否则,TS指令读取1并将值设置为1
    	while(test-and-set(value))
    		;
    }
    Lock::Release() {
    	value = 0;
    }
    
    //无忙等待,此种方式为等待队列方式,即阻塞式方法。
    class Lock {
        int value = 0;
        WaitQueue q;
    }
    Lock::Acquire() {
        while(test-and-set(value)) {
            //将当前进程加入等待队列
            add this PCB to wait queue q
            //执行调度
            schedule();
        }
    }
    Lock::Release() {
        value = 0;
        //从等待队列中移除一个进程p,并唤醒他去执行。
        remove one process p from q;
        wakeup(p);
    }
    

    基于原子操作指令锁的特征

    优点:

    • 适用于单处理器或者共享主存的多处理器任意数量的进程同步机制
    • 简单并且容易验证
    • 支持多临界区

    缺点:

    • 忙等待锁会消耗处理器时间
    • 可能导致饥饿
      • 进程离开临界区时有多个进程在等待
    • 死锁
      • 拥有临界区的低优先级进程
      • 请求访问临界区的高优先级进程获得处理器并等待临界区(忙等待的情况)

    参考资料

    清华大学—操作系统原理
    现代操作系统

    展开全文
  • 进程同步与互斥:System V 信号量,相关使用教程链接如下: http://blog.csdn.net/tennysonsky/article/details/47811201
  • 操作系统中进程同步与互斥的实现.pdf 深入理解操作系统
  • P、V操作实现进程同步与互斥是《操作系统》教学中的一个难点,通过示例给出了解决这类问题的一般模型。
  • 进程同步与互斥实验

    千次阅读 2020-11-04 17:53:18
    进程同步与互斥实验 #include <stdio.h> #include <pthread.h> #include <unistd.h> #include <stdlib.h> #define true 1 //生产者ID int product_id = 0; //消费者ID int consumer_id = 0;...

    进程同步与互斥实验

    #include <stdio.h>
    #include <pthread.h>
    #include <unistd.h>
    #include <stdlib.h>
    #define true 1
    //生产者ID
    int product_id = 0;
    //消费者ID
    int consumer_id = 0;
    //缓冲区大小
    int N;
    //生产者数目
    int producerNum;
    //消费者数目
    int consumerNum;
    //类型定义 int型 信号
    typedef int semaphore;
    //类型定义 int型 商品
    typedef int item;
    //定义 商品类型的缓冲数组
    item* buffer;
    //头索引,输入索引,头指针,用于标识生产者的输入位置
    int in = 0;
    //尾索引,输出索引,尾指针,用于标识消费者的输出位置
    int out = 0;
    //产品数目
    int proCount = 0;
    //mutex 互斥变量,empty 缓冲区空白大小,full 缓冲区非空白大小,proCmutex 生产者互斥变量
    semaphore mutex = 1, empty , full = 0, proCmutex = 1;
    //pthread_create函数创建进程时,需要一个指针类型的函数作为参数,所以定义为指针类型。
    //producer与consumer作为线程的执行体。
    void * producer(void * a){
    int id = ++product_id;
    while(true){
    int flag = 0;
    //如果缓冲区已满报错
    while(empty <= 0){
    printf(“生产者%d:缓冲区已满!阻塞中……\n”,id);
    flag =1;
    sleep(1);
    }
    if(flag ==1)
    printf(“生产者%d因缓冲区有空位唤醒!\n”,id);
    //如果有其他生产者占用进程则互斥,检查有没有其他生产者生产产品
    flag = 0;
    while(proCmutex <= 0){printf(“生产者%d生产阻塞中……\n”,id);flag = 1;sleep(1);};
    //将互斥变量置0,代表已占用
    proCmutex–;
    if(flag == 1)
    printf(“生产者%d生产唤醒!\n”,id);
    //产品号+1
    proCount++;
    printf(“生产者%d:生产一个产品ID%d!\n”,id,proCount);

        //总互斥变量,检查有没有其他进程修改缓冲区数据
        flag = 0;
        while(mutex <= 0){printf("生产者%d装入阻塞中……\n",id);sleep(1);flag=1;};
        //占用进程
        mutex--;
    
        if(flag == 1)
            printf("生产者%d装入唤醒,装入产品ID%d,缓冲区位置为%d!\n",id,proCount,in);
        else
            printf("生产者%d装入产品ID%d,缓冲区位置为%d!\n",id,proCount,in);
        //否则缓冲区空白大小-1
        empty--;
        //缓冲区头指针放入产品
        buffer[in] = proCount;
        //头指针+1
        in = (in + 1) % N;
    
        //缓冲区非空白大小+1
        full++;
        //解除占用
        mutex++;
        //解除生产占用
        proCmutex++;
        //睡一觉
        sleep(1);
    }
    

    }

    void * consumer(void *b){
    int id = ++consumer_id;
    while(true){
    int flag = 0;
    while(full <= 0){
    printf("\t\t\t\t消费者%d:缓冲区为空!阻塞中……\n",id);
    flag = 1;
    sleep(1);
    }
    full–;
    if(flag ==1)
    printf("\t\t\t\t消费者%d因缓冲区有产品唤醒!\n",id);
    flag = 0;

        while(mutex <= 0){printf("\t\t\t\t消费者%d消费阻塞中……\n",id);sleep(1);};
        mutex--;
        if(flag == 1)
            printf("\t\t\t\t消费者%d消费唤醒!\n",id);
        int nextc = buffer[out];
        buffer[out] = 0;//消费完将缓冲区设置为0
        empty++;
        printf("\t\t\t\t消费者%d:消费一个产品ID%d,缓冲区位置为%d\n",id, nextc,out);
        out = (out + 1) % N;
        mutex++;
        sleep(1);
    }
    

    }

    int main()
    {
    int tempnum;
    //输入生产者数目
    printf(“请输入生产者数目:\n”);
    scanf("%d",&tempnum);
    producerNum = tempnum;
    //输入消费者数目
    printf(“请输入消费者数目:\n”);
    scanf("%d",&tempnum);
    consumerNum = tempnum;
    //输入缓冲区大小
    printf(“请输入缓冲区大小:\n”);
    scanf("%d",&tempnum);
    N = tempnum;
    empty = N;
    buffer = (item*)malloc(N*sizeof(item));
    for(int i=0;i<N;i++)
    {
    buffer[i]=0;
    }
    //pthread_t是线程结构,用来保存线程相关数据,可以理解为线程类型,声明线程对象(这里声明的时线程对象数组)
    pthread_t threadPool[producerNum+consumerNum];//声明了线程数组作为线程池
    int i;
    for(i = 0; i < producerNum; i++){
    pthread_t temp;
    //if语句中,第一个参数是线程指针,第二个是线程属性指针,第三个是函数指针,即线程要执行的代码
    //函数通过producer函数指针创建对象,赋值给temp作为线程执行
    if(pthread_create(&temp, NULL, producer, NULL) == -1)
    {
    printf(“ERROR, fail to create producer%d\n”, i);
    exit(1);
    }
    //将temp作为能够执行的线程放入了进程池
    threadPool[i] = temp;
    }//创建生产者进程放入线程池

    //对于消费者进程也同样创建进程
    for(i = 0; i < consumerNum; i++){
        pthread_t temp;
        if(pthread_create(&temp, NULL, consumer, NULL) == -1){
            printf("ERROR, fail to create consumer%d\n", i);
            exit(1);
        }
        threadPool[i+producerNum] = temp;
    }//创建消费者进程放入线程池
    
    
    void * result;
    for(i = 0; i < producerNum+consumerNum; i++){
        //pthread_join函数用与等待线程的结束
        //等待的是子进程的结束,因为如果主进程不等待子进程而直接结束,子进程将没有执行就被杀死。
        if(pthread_join(threadPool[i], &result) == -1){
            printf("fail to recollect\n");
            exit(1);
        }
    }//运行线程池
    return 0;
    

    }

    远哥是真强啊!帅!

    展开全文
  • 实验-进程同步与互斥

    2021-07-02 09:37:52
    在Visual C++ 6.0集成开发环境下使用C语言,利用相应的Win32 API函数,以生产者/消费者模型为依据,创建一个控制台进程,在该进程中创建n个进程模拟生产者和消费者,实现进程同步与互斥。 3.实验原理提示 进程数据...

    实验内容:
    1.实验目的和要求

    (1)理解生产者/消费者模型及其同步/互斥规则。
    (2)了解Windows同步对象及其特性。
    (3)熟悉实验环境,掌握相关API的使用方法。
    (4)设计程序,实现生产者/消费者进程的同步与互斥。

    2.实监内容
    在Visual C++ 6.0集成开发环境下使用C语言,利用相应的Win32 API函数,以生产者/消费者模型为依据,创建一个控制台进程,在该进程中创建n个进程模拟生产者和消费者,实现进程的同步与互斥。
    3.实验原理与提示
    进程数据结构:每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程类型标号,进程系统号,进程状态(本程序未用),进程产品(字符),进程链指针等。系统开辟了一个缓冲区,大小由buffersize指定。程序中有三个链队列,一个链表。一个就绪队列(ready),两个等待队列:生产者等待队列( producer);消费者等待队列(consumer)。一个链表(over),用于收集已经运行结束的进程。
    本程序通过函数模拟信号量的原子操作。
    算法的文字描述:

    (1由用户指定要产生的进程及其类别,存入就绪队列。
    (2)调度程序从就绪队列中提取一个就绪进程运行,如果申请的资源不存在则进入相应的等待队列,调度程序调度就绪队列中的下一个进程﹔进程运行结束时,会检查相应的等待队列,激活等待队列中的进程进入就绪队列;运行结束的进程进人over链表。重复这一过程直至就绪队列为空。
    (3)程序询问是否要继续?如果要继续转至(1)开始执行,否则退出程序。

    参考代码

    
    #include <stdio.h>
    #include <malloc.h>
    #define buffersize 5						//假设有5个缓冲区
    int processnum=0;							//初始化产品数量
    struct pcb									/* 定义进程控制块PCB*/	
    {
    	int flag;
    	int numlabel;
    	char product;
    	char state;
    	struct pcb*processlink;
    }*exe=NULL,*over=NULL;
    typedef struct pcb PCB;
    PCB* readyhead=NULL,* readytail=NULL;
    PCB* consumerhead=NULL,* consumertail=NULL;
    PCB* producerhead=NULL,* producertail=NULL;
    int productnum=0;												//产品数量
    int full=0,empty=buffersize;									//信号量
    char buffer[buffersize];										//缓冲区
    int bufferpoint=0;												//缓冲区指针
    void linklist(PCB * p,PCB* listhead)							//创建就绪队列
    {
    	PCB*cursor=listhead;
    	while(cursor->processlink!=NULL){
    		cursor=cursor->processlink;
    	}
    	cursor->processlink=p;
    }
    void freelink(PCB* linkhead)
    {
    	PCB* p;
    	while(linkhead!=NULL)
    	{
    		p=linkhead;
    		linkhead=linkhead->processlink;
    		free(p);
    	}
    }
    void linkqueue(PCB* process,PCB** tail)				//初始化队列
    {
    	if((*tail)!=NULL)
    	{
    		(*tail)->processlink=process;
    		(*tail)=process;
    	}
    	else{printf("队列未初始化!");}
    }
    PCB* getq(PCB*head,PCB** tail)
    {
    	PCB* p;
    	p=head->processlink;
    	if(p!=NULL)
    	{
    		head->processlink=p->processlink;
    		p->processlink=NULL;
    		if(head->processlink == NULL) (* tail)=head;
    	}
    	else return NULL;
    	return p;
    }
    bool processproc()											//初始化进程
    {
    	int i,f,num;
    	char ch;
    	PCB* p=NULL;
    	PCB** p1=NULL;
    	printf("\n 请输入希望产生的进程个数:");
    	scanf("%d",&num);
    	getchar();
    	for(i=0;i<num;i++)
    	{
    		printf("\n请输入您要产生的进程:输入 1为生产者进程;输入2为消费者进程\n");
    		scanf("%d",&f);
    		getchar();
    		p=(PCB* )malloc(sizeof(PCB));
    		if(!p){printf("内存分配失败");return false;}
    		p->flag=f;
    		processnum++;
    		p->numlabel=processnum;
    		p->state='w';
    		p->processlink=NULL;
    		if(p->flag==1)
    		{
    			printf("您要产生的进程是生产者,它是第%d个进程。请您输入您要该进程产生的字符:\n",processnum);
    			scanf("%c",&ch);
    			getchar();
    			p->product=ch;
    			productnum++;
    			printf("您要该进程产生的字符是%c\n",p->product);
    		}
    		else{printf("您要产生的进程是消费者,它是第%d个进程。\n",p->numlabel);}
    		linkqueue(p,&readytail);
    	}
    	return true;
    }
    bool hasElement(PCB* pro)							//判断队列中是否有进程存在
    {
    	if(pro->processlink== NULL) return false;
    	else return true;
    }
    bool waitempty()										//判断生产者等待队列是否为空
    {
    	if(empty<=0)
    	{
    		printf("进程%d:缓冲区存数,缓冲区满,该进程进入生产者等待队列\n",exe->numlabel);
    		linkqueue(exe,&producertail);
    		return false;
    	}
    	else{empty--; return true;}
    }
    void signalempty()											//唤醒生产者进程
    {
    	PCB* p;
    	if(hasElement(producerhead)){
    		p=getq(producerhead,&producertail);
    		linkqueue(p,&readytail);
    		printf("等待中的生产者进程进入就绪队列,它的进程号是%d\n",p->numlabel);
    	}
    	empty++;
    }
    bool waitfull()										//判断消费者等待队列是否为满
    {
    	if(full<=0)
    	{
    		printf("进程%d缓冲区取数,缓冲区空,该进程进入消费者等待队列\n",exe->numlabel);
    		linkqueue(exe,&consumertail);
    		return false;
    	}
    	else{ full--;  return true;}
    }
    void signalfull()									//唤醒消费者进程
    {
    	PCB* p;
    	if(hasElement(consumerhead)){
    		p=getq(consumerhead,&consumertail);
    		linkqueue(p,&readytail);
    		printf("等待中的消费者进程进入就绪队列,它的进程号是%d\n",p->numlabel);
    	}
    	full++;
    }
    void producerrun()						//生产者进程
    {
    	if(!waitempty()) return;
    	printf("进程%d开始向缓冲区存数%c\n",exe->numlabel,exe->product);
    	buffer[bufferpoint]=exe->product;
    	bufferpoint++;
    	printf("进程%d向缓冲区存数操作结束\n",exe->numlabel);
    	signalfull();
    	linklist(exe,over);
    }
    void comsuerrun()						//消费者进程
    {
    	if(!waitfull()) return;
    	printf("进程%d开始向缓冲区取数\n",exe->numlabel);
    	exe->product=buffer[bufferpoint-1];
    	bufferpoint--;
    	printf("进程%d向缓冲区取数操作结束,取数是%c\n",exe->numlabel,exe->product);
    	signalempty();
    	linklist(exe,over);
    }
    void display(PCB* p)								//显示进程
    {
    	p=p->processlink;
    	while(p!=NULL){
    		printf("进程%d,它是一个",p->numlabel);
    		p->flag==1? printf("生产者\n"):printf("消费者\n");
    		p=p->processlink;
    	}
    }
    void main()
    {
    	char terminate;
    	bool element;
    	printf("你想开始程序吗?(y/n)");
    	scanf("%c",&terminate);
    	getchar();
    	readyhead=(PCB* )malloc(sizeof(PCB));			//初始化队列
    	if(readyhead ==NULL) return;
    
    		readytail=readyhead;
    		readyhead->flag=3;
    		readyhead->numlabel=processnum;
    		readyhead->state='w';
    		readyhead->processlink=NULL;
    		consumerhead=(PCB* )malloc(sizeof(PCB));
    		if(consumerhead==NULL) return;
    		consumertail=consumerhead;
    		consumerhead->processlink=NULL;
    		consumerhead->flag=4;
    		consumerhead->numlabel=processnum;
    		consumerhead->state='w';
    		consumerhead->processlink=NULL;
    		producerhead=(PCB*)malloc(sizeof(PCB));
    		if(producerhead==NULL) return;
    		producertail=producerhead;
    		producerhead->processlink=NULL;
    		producerhead->flag=5;
    		producerhead->numlabel=processnum;
    		producerhead->state='w';
    		producerhead->processlink=NULL;
    		over=(PCB*)malloc(sizeof(PCB));
    		if(over==NULL)return;
    		over->processlink=NULL;
    		while(terminate=='y')
    		{
    			if(!processproc()) break;
    			element=hasElement(readyhead);
    			while(element){
    				exe=getq(readyhead,&readytail);
    				printf("进程%d申请运行,它是一个",exe->numlabel);
    				exe->flag==1? printf("生产者\n"):printf("消费者\n");
    				if(exe->flag==1) producerrun();
    				else comsuerrun();
    				element=hasElement(readyhead);
    			}
    			printf("就绪队列没有进程\n");
    			if(hasElement(consumerhead))
    			{
    				printf("就绪队列没有进程\n");
    				if(hasElement(consumerhead))
    				{
    					printf("消费者等待队列中有进程:\n");
    					display(consumerhead);
    				}
    				else {printf("消费者等待队列中没有进程\n");}
    				if(hasElement(producerhead))
    				{
    					printf("生产者等待队列中有进程:\n");
    					display(producerhead);
    				}
    				else{
    					printf("生产者等待队列中没有进程\n");
    				}
    				printf("你想继续吗?(press 'y'for on)");
    				scanf("%c",&terminate);
    				getchar();
    			}
    			printf("\n\n进程模拟完成.\n");
    			freelink(over);							//释放空间
    			over=NULL;
    			freelink(readyhead);
    			readyhead=NULL;
    			readytail=NULL;
    			freelink(consumerhead);
    			consumerhead=NULL;
    			consumertail=NULL;
    			freelink(producerhead);
    			producerhead=NULL;
    			producertail=NULL;
    			getchar();
    		}
    }
    

    实验结果:
    在这里插入图片描述

    展开全文
  • C语言实现进程同步与互斥

    千次阅读 2020-11-17 16:14:14
    进程同步与互斥 实验原理 (1)同步和互斥(生产者消费者问题) 同步是一种更为复杂的互斥,而互斥是一种特殊的同步。 互斥:是指某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性。但互斥无法限制...

    C语言实现进程同步与互斥

    实验原理

    (1)同步和互斥(生产者消费者问题)
    同步是一种更为复杂的互斥,而互斥是一种特殊的同步。
    互斥:是指某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序,即访问是无序的。

    同步:是指在互斥的基础上(大多数情况),通过其它机制实现访问者对资源的有序访问。在大多数情况下,同步已经实现了互斥,特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源
    (2)信号量
    在系统中,给予每一个进程一个信号量,代表每个进程目前的状态,未得到控制权的进程会在特定地方被强迫停下来,等待可以继续进行的信号到来。信号量又存在着两种操作,分别为V操作与P操作,V操作会增加信号量 S的数值,P操作会减少它。
    (3)锁
    在多线程编程中,操作系统引入了锁机制。通过锁机制,能够保证在多核多线程环境中,在某一个时间点上,只能有一个线程进入临界区代码,从而保证临界区中操作数据的一致性。
    加锁过程用如下伪码表示:
    1、read lock;
    2、判断lock状态;(0表示资源可用,1表示资源已被占用)
    3、如果已经加锁,失败返回;
    4、把锁状态设置为上锁;
    5、返回成功。

    实验内容和方法

    1.实验一(进程同步):
    1)实验内容
    分别创建两个工程,用来scanf和printf,从键盘输入,在屏幕上显示输入了多少个数,以此来实现进程同步。
    2)代码以及代码分析

    Scanf.c

    #include<stdio.h>
    #include<windows.h>
    int main(){
    		HANDLE h;
    		int a=0;
    		h=CreateSemaphore(NULL,0,10,"scanfcount");
    		while(1)
    		{
    			scanf("%d",&a);
    			printf("%d",a);
    			ReleaseSemaphore(h,1,NULL);
    		}
    }
    

    Printf.c

    #include<stdio.h>
    #include<windows.h>
    int main(){
    		HANDLE h;
    	int count=0;
    	h=CreateSemaphore(NULL,0,10,"scanfcount");
    	
    	while(1)
    	{
    			WaitForSingleObject(h,INFINITE);
    			count++;
    		printf("%d",count);
    
    	
    	}
    }
    

    3)实验结果截图
    每当我在scanf窗口输入一个数,printf窗口的计数器就加1。
    2.实验二(进程互斥):
    1)实验内容
    本次实验中,模拟两个线程实现信号量的争夺(无序性)。通过加锁实现在某一个时间点上,只能有一个线程进入临界区代码,从而保证临界区中操作数据的一致性。
    2)代码及代码分析

    MultiThread.c

    #include<stdio.h>
    #include<windows.h>
    HANDLE m_hMutex; 
    //线程1
    DWORD WINAPI ThreadFunc1(LPVOID lpParam)
    {
    	int i;
    	for(i=0;i<5;i++)
    	{
    				WaitForSingleObject(m_hMutex,INFINITE);//进入临界区域
    		printf("Thread1 step1 in the critical section\n");
    		printf("Thread1 step2 in the critical section\n");
    		ReleaseMutex(m_hMutex);//释放
    	}
        return 0;
    }
    //线程2
    DWORD WINAPI ThreadFunc2(LPVOID lpParam)
    {
    	int i;
    	for(i=0;i<5;i++)
    	{
    		WaitForSingleObject(m_hMutex,INFINITE);
    		printf("Thread2 step1 int the critical section\n");
    		printf("Thread2 step2 inthe critical section\n");
    		ReleaseMutex(m_hMutex);
    	}
        return 0;
    }
    void main()
    {
    	char c;
    	m_hMutex=CreateMutex(NULL,FALSE,NULL);
    	CreateThread(NULL, 0, ThreadFunc1, 0, 0, 0);
    	CreateThread(NULL, 0, ThreadFunc2, 0, 0, 0);
    	scanf("%c\n",&c);
    }
    

    3)实验结果截图

    展开全文
  • 进程同步与互斥习题

    2020-08-05 22:31:05
    在这里插入图片描述 答案:B 答案:A 答案:D 答案:D
  • 使用DEV C++打开:这是进程同步与互斥代码,第一次自己写的,写得不好多多支持 #include<stdio.h> #include<windows.h> #include<string> using namespace std; FILE* fw; HANDLE event; char s[1...
  • 经典进程同步与互斥问题

    万次阅读 2018-06-18 08:13:41
    经典进程同步与互斥问题 1. 生产者-消费者问题 1.1 简单的“生产者-消费者”问题 设进程A、B是两个相互合作的进程,它们共享一个缓冲区,进程A向其中写入数据,进程B从中读出数据。producer:生产者进程,...
  • 同步与互斥 同步 1.进程A和进程B具有协助被协助关系 A需要B产生的一个数据,才能完成整个执行过程 A进程没有B进程的话,不能完成运行 互斥 进程A和进程B需要**竞争同一个资源 **
  • 用C写的进程同步与互斥,初学《操作系统》的可以看看,在控制台界面实现单个进程的生产者消费者问题
  • 1.进程同步与互斥的区别? 互斥:某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性。互斥无法限制访问者对资源的访问顺序即访问时无序的。如:接学家就餐问题,每个人手中只有一个筷子。 同步:基于...
  • 互斥与同步的概念 在多道程序环境下,系统中可能有许多并发的进程,在这些进程之间存在以下两种关系:间接相互制约关系、直接相互制约关系。 间接相互制约关系 多个进程彼此无关,它们并不知道其他进程的存在。由...
  • 传送门: 进程同步与互斥——信号量(实现锁、条件变量) 进程同步与互斥——哲学家就餐问题源码实现(dining philosopher’s problem) 进程同步与互斥——读者/写者问题源码实现(reader-writer lock) 进程同步与...
  • 实验四 同步与互斥 实验目的和要求 1掌握进程线程的同步与互斥 2掌握生产者消费者问题的实现方法 3掌握多线程编程方法 实验内容 实现生产者消费者问题 1有一个仓库生产者负责生产产品并放入仓库消费者会从仓库中拿走...
  • 操作系统实验:实现进程同步与互斥——生产者/消费者问题
  • 进程同步与互斥实验报告 实验序号01 实验项目名称进程同步与互斥 学 号 姓 名 专业班 实验地点 指导教师 时间 一实验目的 1掌握基本的进程同步与互斥算法理解生产者-消费者问题 2学习使用Windows 2000/XP 中基本的...
  • 9进程同步与互斥.png

    2021-08-07 10:19:28
    9进程同步与互斥.png
  • 9进程同步与互斥.xmind

    2021-08-07 10:19:27
    9进程同步与互斥.xmind
  • 操作系统中P、V操作实现进程同步与互斥
  • 实验8 进程同步与互斥.c
  • 进程间相互作用 相关进程和无关进程 时间有关的错误 ...经典的进程同步问题 简单生产者—消费者问题 多个生产者—消费者问题 读者—写者问题 同步与互斥机制的综合应用 管程 管程的提出 管程的概念及...
  • 问题描述:生产者——消费者...核心:生产者——消费者问题,既存在着进程同步问题,也存在着临界区互斥问题。当缓冲区满时,表示供大于求,生产者必须停止生产,进入等待状态,同时唤醒消费者;当所有缓冲区都为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,507
精华内容 39,802
关键字:

进程同步与互斥