基于信号量机制的进程同步问题模拟程序

最新推荐文章于 2022-07-23 15:53:02 发布
最新推荐文章于 2022-07-23 15:53:02 发布
阅读量2.2k 收藏 7
点赞数
分类专栏： OS 文章标签： semaphore Semaphore signal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xyanghomepage/article/details/8199127
版权
背景：在多任务系统中，进程之间的相互影响成为必须解决的重要问题，由于共享资源争抢（间接制约）和进程之间的固有协作关系（直接制约），导致进程之间存在相互制约关系。1965年荷兰学者Dijkstra提出的信号量机制是用于解决进程间同步问题的一种重要机制。
问题描述：在父亲、女儿和儿子面前有一个放置水果的盘子plate，盘子最多可以放6个水果。父亲随机地向盘子里放入水果，可能是苹果也可能是桔子。女儿和儿子从盘 子中拿水果吃，但是女儿只吃桔子orange，儿子只吃苹果apple，并且每次只能有一个人对盘子访问（放水果或者拿水果）。
这是操作系统课上的第三次作业吧，晚上做了一下，只是个模拟程序，还不够完善。 
#define RUNNING     0  
#define
最低0.47元/天 解锁文章
zhiy_wis
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
《Linux系统编程：进程同步与互斥_System V 信号量》
yexiangCSDN的专栏
12-17 600
信号量概述 信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。 编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。 在实际应用中两个进程间通信可能会使用多个信号量，因此System V 的...
操作系统实验-信号量机制实现进程同步
06-16
这是一个利用信号量机制实现进程同步的模拟程序，如你有更好的方法或觉的我的可以修改欢迎交流学习。
操作系统（六）：信号量实现进程同步
奔跑吧蚂蚁呀
08-24 1669
进程管理2--进程的同步与信号量
weixin_34292959的博客
09-12 361
本文地址：http://www.cnblogs.com/archimedes/p/os-process-management2.html，转载请注明源地址。 进程同步 进程同步：指对多个相关进程在执行次序上进行协调； 同步的任务：使系统中各进程之间能有效地共享资源和相互合作，从而使程序的执行具有可再现性； 系统中各进程之间在逻辑上的相互制约的关系： 直接关系—同步 间接关系—互斥 用...
操作系统进程同步与信号量---08
m0_53157173的博客
07-23 513
信号量有什么组成？需要有一个整形变量value，用作进程同步。需要有一个PCB指针，指向睡眠的进程队列。需要有一个名字来表示这个结构的信号量。同时，由于该value的值是所有进程都可以看到和访问的共享变量，所以必须在内核中定义；同样，这个名字的信号量也是可供所有进程访问的，必须在内核中定义；同时，又要操作内核中的数据结构进程控制块PCB，所以信号量一定要在内核中定义，而且必须是全局变量。系统调用是应用程序访问内核的唯一方法。}......
进程同步模拟设计--哲学家就餐问题
01-29
7. **程序设计**：在Dining.java和Dining2.java这两个源文件中，可能包含了不同的哲学家就餐问题的实现，比如可能一个是基于信号量的解决方案，另一个可能是基于Java并发库中的锁和条件变量的实现。 理解并解决哲学...
PHP进程通信基础之信号量与共享内存通信
10-20
总的来说，PHP中的信号量和共享内存是进程通信的基石，它们提供了在多进程环境下的数据交换和同步机制。通过合理使用这些工具，开发者可以编写出高效且线程安全的程序。在实际开发中，根据具体需求选择合适的进程...
DA.rar_数字信号量
09-19
在计算机系统中，数字信号量常用于多线程或进程间的同步，控制对共享资源的访问。然而，在这个特定的场景下，数字信号量指的是实际的数字信号，而非软件中的同步机制。 2. AD转换器：AD（模拟-数字）转换器是将连续...
进程同步模拟设计--读者和写者问题
01-28
总结起来，"进程同步模拟设计--读者和写者问题"是多进程环境中解决数据共享的关键问题。通过理解进程调度、同步与异步的概念，以及运用信号量、管程等同步机制，我们可以有效地解决这一问题，保证数据的一致性和系统...
进程同步（操作系统实验三，带实验报告哦，亲）
11-26
生产者消费者问题是进程同步的经典案例，模拟了两个不同类型的进程——生产者和消费者之间的协作。生产者将数据放入缓冲区，消费者则从中取出数据消费。问题的关键在于如何确保缓冲区不被填满（避免生产者过快）且不...
操作系统-吃水果问题
06-10
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
进程同步问题模拟程序
06-01
模拟进程管理 #include <stdio.h> #include <malloc.h> //Can only be used in independent situation; //#define getmem(type) (type*)malloc(sizeof(type)) #define buffersize 5 int processnum=0;//the num of processes struct pcb { /* 定义进程控制块PCB */ int flag;//flag=1 denote producer;flag=2 denote consumer; 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;// semaphore char buffer[buffersize];//缓冲区 int bufferpoint=0;//缓冲区指针 void linkqueue(PCB* process,PCB** tail); PCB* getq(PCB* head,PCB** tail); bool hasElement(PCB* pro); void display(PCB* p); void linklist(PCB* p,PCB* listhead); void freelink(PCB* linkhead); bool processproc(); bool waitempty(); bool waitfull(); void signalempty(); void signalfull(); void producerrun(); void comsuerrun(); bool hasElement(PCB* pro); 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(); // if(num>=100){ // printf("您怎么要产生这么多进程！Demands Denied!"); // return false; // } 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 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; } } bool hasElement(PCB* pro) { if(pro->processlink==NULL) return false; else return true; } void main() { char terminate; bool element; printf("你想开始程序吗?(y/n)"); scanf("%c",&terminate); getchar(); //Queue initialize; 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"); 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"); //Free the room; freelink(over); over=NULL; freelink(readyhead); readyhead=NULL; readytail=NULL; freelink(consumerhead); consumerhead=NULL; consumertail=NULL; freelink(producerhead); producerhead=NULL; producertail=NULL; getchar(); }
利用信号量机制实现生产者消费者问题（用进程通信进行模拟）
qq_41648012的博客
06-02 5974
生产者消费者同步问题：生产者进程产生消息放在某个共享资源区，共享资源区的消息不为空时消费者进程从该共享资源区读取消息，为了避免脏读生产者和消费者不能同时访问共享资源，这就涉及到生产者和消费者进程之间的同步。利用信号量解决该问题： 定义两个信号量（不能是一个，否则生产者或者消费者可能会无限的访问共享资源，形成死循环）S1、S2，初始值为1，0。S1=1表示生产者进程可写共享资源，为0则不可；S2=1...
进程同步之信号量机制（pv操作）及三个经典同步问题
Echo_Ana的博客
11-04 8663
出处：http://www.it165.net/os/html/201312/7039.html 锁机制只能判断临界资源是否被占用，所以他解决了互斥问题，但是他不能确定前面的进程是否完成，所以他不能用于同步问题中。下面就为你讲解信号量机制是如何解决这一问题的。 1.信号量机制 信号量机制即利用pv操作来对信号量进行处理。 什么是信号量？信号量（semaphore）的数据结构为一个值和一
操作系统实验一：并发程序设计
weixin_30457551的博客
05-14 390
一、实验目的 （1）加深对进程并发执行的理解，认识多进程并发执行的实质。 （2）观察进程共享资源的现象，学习解决进程互斥和同步的方法。 二、实验要求： 本实验要求用高级语言，启动多进程并发运行，设计相应代码，显示进程无关并发、进程共享变量并发的运行结果。并完成实验报告。 三、实验内容： 分别实现以下四种情况的并发： 1.并发的进程之间无关，显示进程名称，开始与结束时间。 模拟多终端...
桌上有一空盘，最多允许存放一只水果。爸爸只向盘中放一个苹果，妈妈只向盘中放一个桔子，儿子专等吃盘中的桔子，女儿专等吃苹果。用wait、signal操作实现爸爸、妈妈、儿子、女儿四个并发进程的同步。
热门推荐
Struggle_PAN的博客
03-31 3万+
分析设计四个信号量metux,empty、apple、orange；metux表示：爸爸、妈妈、儿子和女儿进程对盘子的互斥使用；empty表示：盘子是否为空；apple表示：是否可以取苹果；orange表示：是否可以取桔子。算法描述如下：semaphore empty=1,nutex=1,apple=0,orange=0; //为四个信号量赋初值 void father(){      do{ ...
操作系统课程设计---实验九 基于信号量机制的并发程序设计
陈陈不like的博客
12-09 2354
操作系统课程设计—实验九基于信号量机制的并发程序设计 实验九 基于信号量机制的并发程序设计 1、实验目的 (1) 回顾操作系统进程、线程的有关概念，针对经典的同步、互斥、死锁与饥饿问题进行并发 程序设计与实现。 (2) 理解互斥体对象，利用互斥与同步操作编写读者-写者问题的并发程序，加深对 P (即semWait)、V(即 semSignal)原语以及利用 P、V 原语进行进程间同步与互斥操作的理解。 (3) 理解 Linux 支持的信息量机制，利用 IPC 的信号量系统调用编程实现哲学家进餐问题。 2、设
进程同步问题（二）——信号量机制
chinahyn的博客
04-22 2540
一、信号量机制 简介： 信号量机制是一种功能较强的机制，可以用来实现互斥与同步的问题。它只能被两个标准的原语wait（S）和signal（S）访问，也称为P、V操作。 PS：原语是指完成某种功能且不被分割、不被中断执行的操作序列，通常可以由硬件来实现。原语功能的不被中断执行特性在单处理机上可由软件通过屏蔽中断方法实现。 整型信号量 整型信号量被定义为是一个用于表示资源数目的整型量S，wait和signal操作可描述为： wait(S){ while(S <= 0); S =
基于java语言对操作系统的读者与写者的进程同步与互斥问题编写程序测试并注释
最新发布
06-03
好的，下面是一份基于Java语言的读者与写者进程同步与互斥问题的代码示例，以供测试和参考。代码注释中会详细解释每个部分的作用和原理。 ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReaderWriterExample { private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); // 创建读写锁 private final Lock readLock = lock.readLock(); // 获取读锁 private final Lock writeLock = lock.writeLock(); // 获取写锁 private int value = 0; // 共享变量 public void write(int newValue) { writeLock.lock(); // 获取写锁 try { System.out.println("Writer " + Thread.currentThread().getName() + " is writing"); value = newValue; // 写入新的值 Thread.sleep(1000); // 模拟写入操作需要一定时间 } catch (InterruptedException e) { e.printStackTrace(); } finally { writeLock.unlock(); // 释放写锁 System.out.println("Writer " + Thread.currentThread().getName() + " finished writing"); } } public int read() { readLock.lock(); // 获取读锁 try { System.out.println("Reader " + Thread.currentThread().getName() + " is reading"); Thread.sleep(500); // 模拟读取操作需要一定时间 return value; // 返回共享变量的值 } catch (InterruptedException e) { e.printStackTrace(); return -1; } finally { readLock.unlock(); // 释放读锁 System.out.println("Reader " + Thread.currentThread().getName() + " finished reading"); } } } ``` 上面的代码使用了Java并发包中的`ReentrantReadWriteLock`类，它提供了读写锁的机制，可以让多个读操作并发地进行，而写操作是互斥的。在此示例中，我们创建了一个`ReaderWriterExample`类，其中包含一个`value`变量，它可以被读者和写者进行读写操作。 在`write()`方法中，我们首先获取写锁，然后进行写入操作，最后释放写锁。在`read()`方法中，我们首先获取读锁，然后进行读取操作，最后释放读锁。这样就能够实现读操作的并发，写操作的互斥了。 为了验证代码的正确性，我们可以编写一个测试类，使用多个线程进行读写操作，如下所示： ```java public class ReaderWriterTest { public static void main(String[] args) { ReaderWriterExample example = new ReaderWriterExample(); // 创建3个读线程，2个写线程 for (int i = 0; i < 3; i++) { new Thread(() -> { System.out.println(example.read()); }).start(); } for (int i = 0; i < 2; i++) { new Thread(() -> { example.write((int) (Math.random() * 100)); }).start(); } } } ``` 在测试类中，我们创建了3个读线程和2个写线程，它们会不断地进行读写操作。我们可以观察到，多个读线程可以并发地读取共享变量的值，而写线程在写入操作时会互斥。这样就能够保证共享变量的正确性和一致性。 需要注意的是，读写锁的机制并不能完全解决并发访问问题，因此在实际使用中还需要考虑其他的并发控制机制，如信号量、条件变量等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值