精华内容
下载资源
问答
  • 进程同步互斥经典问题
    千次阅读
    2019-02-26 17:51:04

    经典进程同步与互斥问题

    一、生产者与消费者问题

    1.1 问题概述

    • 生产者与消费者互斥使用一个缓冲池
    • 当缓冲池为空时,生产者才能写入数据
    • 当缓冲池不为空时,消费者才能读取数据

    1.2 解决方法

    设置3个信号量:mutex=1,full=0,empty=n(假设缓冲池大小为n)

    • mutex:互斥信号量
    • full:表达缓冲池中数据量的信号量,初值为0
    • empty:表达缓冲池中空闲块的信号量,初值为n,即缓冲池的大小
    • 生产者
    P(empty)
    P(mutex)
    写入数据
    V(mutex)
    V(full)
    
    • 消费者
    P(full)
    P(mutex)
    读取数据
    V(mutex)
    V(empty)
    

    二、读者与写者问题

    2.1 问题概述

    一个数据对象(如文件、记录)可以被多个进程共享。这些进程可以分为两类:

    • 读者进程:只读取数据对象的值
    • 写者进程:修改或者写入数据对象的值

    这类问题具有以下特点:

    1. 读者进程之间不互斥
    2. 写者与写者、写者与读者之间互斥

    2.2 解决方法

    设置3个信号量:mutex,readerCount,writer

    • mutex:互斥信号量,用于读者进程访问共享变量readerCount,初值为1
    • readerCount:共享信号量,用于记录当前进入临界区的读者进程的数量,初值为0
    • writer:互斥信号量,用于写者与写者、写者与读者之间对临界区的互斥访问
    • 读者
    P(mutex)
    //临界区没有读者时,先判断当前临界区是否有写者进程
    //由第一个进入临界区的读者进程来阻塞后来的写者进程
    if(readerCount == 0)
        P(writer);
    //当此时临界区已经存在读者进程时,countReader++
    ++readerCount;
    V(mutex)
    读数据
    P(mutex)
    --readerCount;
    //由最后一个离开临界区的读者进程唤醒可能被阻塞的写者进程
    if(readerCount == 0)
        V(writer);
    V(mutex)
    
    • 写者
    P(writer)
    写数据
    V(writer)
    

    三、哲学家进餐过程

    3.1 问题概述

    五个哲学家,他们的生活方式是交替地进行思考和进餐。哲学家们共用一张圆桌,分别坐在周围的五张椅子上,在圆桌上有五个碗和五支筷子。

    • 平时哲学家进行思考,饥饿时便试图取其左、右最靠近他的筷子,只有在他拿到两支筷子时才能进餐,
    • 进餐完毕,放下筷子又继续思考。

    3.2 解决方法

    对于上述问题,很容易想到这样一种方法:设置一个互斥信号量数组,第i个哲学家进餐时,分别P(mutex[i-1])和P(mutex[i])。

    while(1){
    P(mutex[i])
    P(mutex[(i+1)%5])
    进餐
    v(mutex[i])
    V(mutex[(i+1)%5])
    思考}
    

    但是上述方法很容易引起死锁。为了解决死锁问题,可以考虑以下方法:

    • 至多允许四个哲学家同时进餐。
    • 仅当左、右两支筷子均可用时,才允许拿起筷子进餐。
    • 奇数号哲学家先拿左筷子再拿右筷子,偶数号哲学家相反。
    更多相关内容
  • 经典进程同步互斥问题

    千次阅读 2020-10-09 16:46:46
    经典进程同步互斥问题前言一、生产者-消费者问题1.问题描述2.问题分析3.代码二、读者-写者问题1.问题描述&&分析2.代码三、哲学家进餐问题1.问题描述&&分析2.代码三、理发师问题1.问题描述&&...


    前言

    在多道程序设计环境中,进程同步是一个非常重要的问题,下面讨论几个经典的进程同步问题。


    一、生产者-消费者问题

    1.问题描述

    生产者-消费者问题是指有两个进程共享一个环形的缓冲池,一组进程为生产者,另一组进程为消费者。缓冲池由若干个大小相等的缓冲区组成。生产者不断将产品放入缓冲池,消费者不断从缓冲池中取出产品。

    2.问题分析

    消费者和生产者既存在同步关系,也存在互斥关系。
    这里简单区别一下什么是同步,什么是互斥
    同步不是我们常识中的共同进行,此处的同步是说不同进程之间相互有时序关系,也就是说一定有个先来后到的固定顺序。拿这里的生产者消费者为例,当缓冲池中产品数量满了时候,生产者只能暂时停止,等到消费者来唤醒他,同理当产品没有了,消费者只能暂停,等到生产者来唤醒他。
    互斥就是说两者之间有竞争关系,这两个人之间可能没有什么关系,但他们需要共同竞争同一个事物。比如这里的消费者和生产者都要对产品进行竞争。

    3.代码

    代码如下(示例):

    semaphore mutex=1;
    semaphore empty=n;
    semaphore full=0;
    int i,j;
    INEM buffer[n];
    ITEM data_p,data_c;
    void producer()  /*生产者进程*/
    {
    while(true)
    {
    produce an item in data_p;
    P(empty);
    P(mutex);
    buffer[i]=data_p;
    i=(i+1)%n;
    V(mutex);
    V(full);
    }
    }
    void consumer()  /*消费者进程*/
    {
    while(true)
    {
    P(full);
    P(mutex);
    data_c=buffer[j];
    j=(j+1)%n;
    V(mutex);
    V(empty);
    consume the item in data_c;
    

    这段代码或者这个实例其实只需要抓住两个关键点:同步和互斥
    如何体现的呢?
    P(empty)

    V(full)
    想象一下,当消费者吧产品都耗光了,他只能暂停在那了,但当生产者执行完他的程序以后,full就不再为0了,消费者就又可以消耗产品了。
    同理,当生产者生产太多了,缓冲池放不下了,经消费者一消耗
    P(full)

    V(empty)
    就又有空位可以提供给新的产品了,生产者又可以供货了!

    二、读者-写者问题

    1.问题描述&&分析

    读者-写者问题要求“写者”只能有一个,且当写者在写入时,读者不能读入,且允许多个读者进行读取

    2.代码

    semaphore Wmutex,Rmutex=1;
    int Rcount=0;
    void reader()  /*读者进程*/
    {
    while(true)
    {
    P(Rmutex);
    if(Rcount==0)  P(Wmutex);
    Rcount++;
    V(Rmutex);
    ...;
    read;
    ...;
    P(Rmutex);
    Rcount-=1;
    if(Rcount==0) V(Wmutex);
    V(Rmutex);
    }
    }
    void writer() /*写者进程*/
    {
    P(Wmutex);
    ....;
    write;
    ....;
    V(Wmutex);
    }
    }
    

    这段代码体现了一个绝对优先的隐含操作。一个是读者是优先考虑的,只有当读者全部读完后,写者才能写。一个是写者优先,如果写者插入到读者中,而这个写者呢又不停在写,那么读者就会在无限的等待中。

    三、哲学家进餐问题

    1.问题描述&&分析

    5个人 5双筷子,每个人只能拿到离自己最近的两双筷子,拿到两双筷子就可以吃饭,没有筷子就思考。

    2.代码

    semaphore cho[5]=[1,1,1,1,1];
    void philoserpher(){
    P(cho[i]);
    P(cho[(i+1)%5]);
    ...;
    eat;
    ...;
    V(cho[(i+1)%5]);
    V(cho[i]);
    ...;
    think;
    ...;
    }
    

    这段代码潜在问题就是死锁。若5个人同时拿起了左边的筷子,那么就会一起进入等待时间,永无休止。

    四、理发师问题

    1.问题描述&&分析

    在这里插入图片描述

    2.代码

    #define CHAIRS 5 /*座椅数*/
    semaphore customers=0;
    semaphore barners=0;
    semaphore mutex=1;
    int waiting;
    void barber()  /*理发师进程*/
    {
    while(true)
    {
    P(customers);/*如果没有顾客,理发师就睡觉*/
    P(mutex);/*互斥进入临界区*/
    waiting--;
    V(barners);/*说明此事理发师状态*/
    V(mutex);
    cut_hair();/*理发*/
    }
    }
    void customer()/*顾客进程*/
    {
    P(mutex);
    if(waiting<CHAIRS)
    {
    waiting++;
    V(customers);
    V(mutex);
    P(barners);/*如果理发师在理发,顾客等待*/
    get_haircut();
    }
    else
    V(mutex);/*人已经满了,顾客离开*/
    }
    

    展开全文
  • 进程同步互斥问题总结.doc
  • (3)作为扩展,有余力的同学,能在界面上能够定时给出可视化展示生产者和消费者问题,动态演示进程同步互斥过程。 (4)实验结果要附上运行结果的截图,并相关文字对实验结果进行说明。 (5)写出实验的体会与...
  • 以生产者消费者模型为基础,在Windows环境下创建一个控制台进程,在该进程中创建读者写者线程模拟生产者和消费者。写者线程写入数据,然后将数据放置在一个空缓冲区中供读者线程读取。读者线程从缓冲区中获得数据,...
  • 操作系统进程同步互斥经典问题之读者写者问题

    读者和写者问题是操作系统中进程同步互斥的经典问题之一

     问题描述:有两组并发进程,读者和写者,二者共享一个数据区,

         要求:允许多个读者同时读,不允许读者和写者同时操作,不允许多个写者同时操作

    问题分析:

    1.有读者来 1)无读者、写者,新读者可以读

        2)有写者等,但其他读者正在读,则新读者可以读

        3)有写者写,则新读者等

           2.有写者来  1)有写者写,则新写者等

         2)有读者,则新写者等

         3)无读者和写者,则新写者可以写

    那么,我们可以通过以下信号量的P V操作来解决这个问题, Wmutux = 1; Rmutux=1; Readercount=0;


    展开全文
  • 本实验要求设计在同一个进程地址空间内执行的两个线程。生产者线程生产物品,然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品,然后释放缓冲区。生产者线程生产物品时,若无空缓冲区...
  • 大连理工大学操作系统大作业, 进程同步互斥 生产者与消费者问题
  • 操作系统进程同步互斥实验

    千次阅读 2021-05-10 07:58:10
    《操作系统进程同步互斥实验》由会员分享,可在线阅读,更多相关《操作系统进程同步互斥实验(7页珍藏版)》请在人人文库网上搜索。1、进程的同步互斥实验进程的同步互斥实验进程的同步互斥实验进程的同步互斥实验 ...

    《操作系统进程同步互斥实验》由会员分享,可在线阅读,更多相关《操作系统进程同步互斥实验(7页珍藏版)》请在人人文库网上搜索。

    1、进程的同步互斥实验进程的同步互斥实验进程的同步互斥实验进程的同步互斥实验 实验目的实验目的实验目的实验目的 1、进一步认识并发执行的实质 2、分析进程竞争资源的现象,学习解决进程同步互斥的方法 实验内容实验内容实验内容实验内容 1、编写程序,使用相关函数实现父子进程对共享文件的同步互斥访问。 2、修改程序,观察对临界资源访问的互斥控制的作用。 实验基础实验基础实验基础实验基础 一、临界资源的互斥访问一、临界资源的互斥访问 为了实现多进程对临界资源的互斥访问,一个进程访问临界资源的典型程序段类似如下 形式: . 进入区进入区 临界区; 退出区退出区 其余代码; 其中,进入区中判断资源是否可用,如。

    2、果可用,则资源数量减 1,进程进入临界区;否 则进程阻塞等待。退出区中资源数量加 1,唤醒阻塞等待该资源的进程。进入区和退出区都 是原子操作。 操作系统中,通常用信号量来实现进入区和退出区,即 P 操作和 V 操作。为了实现用户程序 中对某些资源的同步互斥访问,操作系统也提供了一些函数接口,功能类似于对特定临界区 的进入区和退出区功能。 二、相关的系统调用二、相关的系统调用 (1 1 1 1)lockf(files,function,size)lockf(files,function,size)lockf(files,function,size)lockf(files,function,siz。

    3、e) :用作锁定文件的某些段或者整个文件。 函数原型: #include intlockf(int files,intfunction;long size) 其中:files 是文件描述符;参数 function 可以取以下值:F_LOCK:锁定一个区域。 F_ULOCK:解除锁定。参数 size 指明了从文件当前位置开始的一段连续锁定区域的长度, 当 size 为 0 时,锁定记录将由当前位置一直扩展到文件尾。 如果 lockf 的参数 function 取值为 F_LOCK,而指定文件的对应区域已被其他进程锁定, 那么 lockf 的调用进程将被阻塞直到该区域解锁。 通过使用 lockf 。

    4、函数,可实现多进程对共享文件进行互斥访问。进程的实现中,必须使 得每个进程在使用文件前对文件加锁,使用文件后解锁。 (2 2)openopen:打开一个文件:打开一个文件 函数原型:#include #include #include intopen(char *path,int flags,mode_t mode); 其中:参数 path 是指向所要打开的文件的路径名指针。 参数 falgs 规定如何打开该文件,它必须包含以下值之一 :O_RDONLY,只读打开; O_WRONLY,只写打开 ;O_RDWR,读/写打开;O_CREAT,当文件不存在时创建文件,需参 数 mode;O_APPE。

    5、ND,不论当前文件位置在何处,将文件指针移至文件尾,为 write 添加数据到 文件;O_TRUNC,当以可写的方式成功打开普通文件时,截断该文件的长度为 0。 参数 mode 规定对该文件的访问权限。 open 系统调用可以只使用前面介绍的这两个参数,省略第三个参数 mode。第三个参数 是在用 O_CREAT 创建文件时使用,指出新建文件的存取许可权。由这个参数指出的存取许 可权还要和 umask 进行运算后才得到新建文件的真正存取许可权。 该运算是由 umask 按位取 反, 再按位与上第三个参数给出的数取或(umask 系统调用根据 whence指定的位置将文件描述符 fildes 指。

    6、向文件的文件指针偏移 offset 长度的字节数。Whence 的取值及其含义如下: SEEK_SET:从文件头开始计算偏移量,文件指针值就是 offset 的值。 SEEK_CUR:从文件指针的当前位置开始计算偏移量,文件指针值是当前指针的值加 上 offset 的值。 SEEK_END: 从文件末尾开始计算偏移量, 文件指针的值是文件长度加上 offset 的值, 一般可能使用负的偏移量,使得文件指针从后向前移动。 当 lseek 调用成功时,返回值为一个字节为单位从文件头开始计算文件偏移量的值。调 用失败时,返回值为-1。 文件指针又称文件读/写指针。文件刚打开时, 文件指针指向开头位置。

    7、;文件读写都是从 文件指针处开始,并且在读写过程中同时移动文件指针。Lseek 函数就是用于设置文件指针 位置。 (6)close(6)close:关闭文件:关闭文件 函数原型:#include int close(int fd); 每打开一个文件,系统就给文件分配一个文件描述符,同时为打开文件描述符的引用计 数加。Linux 文件系统最多可以分配 255 个文件描述符。当调用 close()时,打开文件描述 符的引用计数值减,最后一次对 close()的调用将使应用计数值为零。 虽然当一个进程结束时,任何打开的文件将自动关闭,明显地关闭任何打开的文件是良 好的程序设计习惯。 实验指导实验指导。

    8、实验指导实验指导 1、 (1)参照参考程序 1,编写程序。父进程和两个子进程分别连续向共享文件中写入 3 行字 符串。多次运行程序,观察共享文件内容。 (2)修改程序,去掉所有 lock/unlock 调用。多次运行程序,观察分析共享文件中,3 个 进程写入字符串的次序,解释原因。 2、 (1)参照参考程序 2,编写程序。父进程从外界获取字符串,并将其写入共享文件;子进 程从共享文件中获取字符串,并将其打印出来。 (2)修改程序,去掉所有 lock/unlock 调用。观察分析运行结果,解释原因。 (3)修改程序,不是去掉 lock/unlock 调用,而是去掉子进程中的”sleep(1);”。

    9、 。观察分 析运行结果,解释原因。 参考程序参考程序参考程序参考程序 参考程序1 #include #include int fatal (const char* info) perror (info); exit (1); int lock(int fd) lseek(fd,0,SEEK_SET); if(lockf(fd,F_LOCK,0)=-1) fatal(lockf(); return 0; int unlock(int fd) lseek(fd,0,SEEK_SET); if(lockf(fd,F_ULOCK,0)=-1) fatal(unlockf(); return 0; in。

    10、t main() int fd; int p1,p2,i; char str20; if(fd=open(locked_file.txt,O_RDWR|O_APPEND|O_CREAT,0666)0) fatal(open); write(fd,=n,10); while(p1=fork( )= -1);/*创建子进程p1*/ if (p1=0) lock(fd);/*加锁*/ for(i=0;i3;i+) sprintf(str,daughter %dn,i); write(fd,str,strlen(str); sleep(1); unlock(fd);/*解锁*/ else while(。

    11、p2=fork( )=-1);/*创建子进程p2*/ if (p2=0) lock(fd);/*加锁*/ for(i=0;i3;i+) sprintf(str,son %dn,i); write(fd,str,strlen(str); sleep(1); unlock(fd);/*解锁*/ else lock(fd);/*加锁*/ for(i=0;i3;i+) sprintf(str,parent %dn,i); write(fd,str,strlen(str); sleep(1); unlock(fd);/*解锁*/ wait(NULL); wait(NULL); close(fd); 参考。

    12、程序2 #include #include int fatal (const char* info) perror (info); exit (1); int lock(int fd) lseek(fd,0,SEEK_SET); if(lockf(fd,F_LOCK,0)=-1) fatal(lockf(); return 0; int unlock(int fd) lseek(fd,0,SEEK_SET); if(lockf(fd,F_ULOCK,0)=-1) fatal(unlockf(); return 0; int main( ) int pid,fd; char str80; fd=。

    13、open(tmp.txt,O_RDWR|O_CREAT|O_TRUNC,0644); pid=fork(); switch(pid) case-1: fatal(fork fail!); case0: sleep(1); lock(fd); lseek(fd, SEEK_SET,0); read(fd,str,sizeof(str); unlock(fd); printf(son %d:read str from tmpfile:%sn,getpid(),str); exit(0); default: lock(fd); printf(parent %d :please enter a str for tmpfile(strlen80):n,getpid(); scanf(%s,str); lseek(fd, 0, SEEK_SET); write(fd,str,strlen(str); unlock(fd); wait(0); close(fd); exit(0); 思考题思考题思考题思考题 1、函数 unlock 和 lock 的实现中,lseek 的作用? 2、解释参考程序 1,2 中 lock/unlock 的作用? 3、参考程序 2,子进程中的”sleep(1);”的作用。

    展开全文
  • Java实现的进程同步互斥(PV) Hao语言
  • 解决多线程编程中的同步互斥问题
  • 进程同步互斥——不死锁哲学家问题 java实现。计算机系统原理,课程设计,(1)利用进程并发执行原理,采用奇数号哲学家先拿左叉子,偶数号哲学家先拿右叉子的算法解决哲学家就餐问题。 (2)利用java中Swing技术将...
  • # ProcessMutexLock windows、linux跨平台进程同步互斥锁类
  • 实验8 进程同步互斥.c
  • 进程同步互斥

    2013-12-19 10:17:14
    有关于进程同步互斥的C语言实现,希望对你们有帮助!
  • 第三章 同步、通信和死锁实验一:进程互斥进程同步进程的互斥和同步是操作系统课程的重要内容,本实验设计算法实现临界区的互斥进入以及进程的同步。注意:因为进程的管理的权限属于操作系统,用户没有权利管理多...
  • 问题描述:生产者-消费者问题,也叫做缓存绑定问题(bounded-buffer),是一个多进程同步问题。 即有两个进程:制造少和消费者,共享一个固定大小的缓存 制造商的工作是制造一段数据,放进缓存,如此重复。 消费者...
  • 进程同步互斥C++

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

    2016-11-30 14:43:09
    利用Windows提供的API函数,编写程序,解决生产者与消费者问题,实现进程互斥同步
  • 进程同步互斥

    千次阅读 2021-06-05 20:52:11
    1. 进程同步   我们把异步环境下的一组并发进程因直接制约而互相发送消息、进行互相合作、互相等待,使得各进程按一定的速度执行的过程称为进程间的同步。具有同步关系的一组并发进程称为合作进程,合作进程间...
  • 大家的话题一下转到了进程线程同步互斥的控制问题上。回到家,想了想就写了这个东东。现在流行的进程线程同步互斥的控制机制,其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变...
  • d: 经典线程同步互斥问题 e: 使用关键段解决子线程互斥问题 f: 利用事件实现线程同步问题 g: 利用互斥量来解决线程同步互斥问题 h: problem1 生产者消费者问题 (1生产者 1消费者 1缓冲区) problem1 more ...
  • 进程互斥进程同步

    2021-08-20 23:19:59
    同步互斥互斥机制准则 什么是进程同步? 进程的并发性带来了异步性(各个并发的进程独立的以不可预知的速度向前推进),而有的进程则需要有次序的相互配合来完成作业,所以有了进程同步进程同步:在多道程序环境...
  • 进程同步互斥

    万次阅读 多人点赞 2018-10-01 09:18:20
    2.9 进程同步的基本概念:临界资源、同步和互斥 在多道程序环境下,进程是并发执行的,不同进程之间存在着不同的相互制约关系。为了协调进程之间的相互制约关系,引入了进程同步的概念。 临界资源 虽然多个进程...
  • 进程同步互斥习题

    千次阅读 2021-12-22 09:55:41
    进程同步互斥习题
  • 进程-同步互斥机制

    2020-01-21 10:45:26
    同步互斥】 1.同步互斥机制 目的: 解决对共有资源操作产生的争夺 临界资源: 多个进程或线程都能够操作的资源(例如终端) 临界区: 操作临界资源的代码段 同步: 同步是一种合作关系,为完成某个任务多...
  • 1)实验准备 要实验的Windows下的多线程实验,应做如下准备: a) 在新建中选”Win32 Console Application”->An empty project b) 选”工程”->”设置”选项,在”设置”中选择“C/C++”标签,在”Project Option”中...
  • 《操作系统进程同步互斥实验报告》由会员分享,可在线阅读,更多相关《操作系统进程同步互斥实验报告(2页珍藏版)》请在人人文库网上搜索。1、学 生 实 验 报 告姓名: 年级专业班级 学号 成绩 课程名称操作系统...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,528
精华内容 46,211
关键字:

进程同步互斥经典问题

友情链接: set-lope-find.rar