精华内容
下载资源
问答
  • 操作系统的实验课设,实现Dekker,Lamport,Peterson,Eisenberg进程互斥访问临界区算法,使用java语言完成,可以动态显示进程访问临界区时各个进程的状态
  • 1、利用fork函数创建新进程,并根据fork函数的返回值,判断自己是处于父进程还是子进程中; 2、在新创建的子进程中,使用exec类的函数启动另一程序的执行;分析多进程时系统的运行状态和输出结果; 3、利用最常用的...
  • 个人写的,测试LINUX下进程互斥的两个方案的例子。希望能够网友提供帮助。
  • C例子:进程互斥

    2015-12-22 22:32:44
    该程序是我写的博客“一起talk C栗子吧(第八十回:C语言实例--进程互斥)”的配套程序,共享给大家使用
  • 进程互斥

    千次阅读 2018-04-11 21:07:58
    前文所介绍的都是软件方法实现进程的互斥,但硬件实现进程互斥通常会比采用软件方法要简单,不需要过多的动作,不过这需要以硬件支持为前提。 “测试并设置”指令的定义如下: int test_and_set( int *target) { ...

    顺序和并发的对比

    以多线程观点理解

    并发程序


    从上述种种原因,我们可以看出,并发程序每次运行的结果不能保证都相同,这是由于并发程序的非封闭性造成的,而这也是我们需要解决的问题——只有可在现的结果才是正确的。

    如何才能保持程序的可再现性呢?
    我们说,当两段程序之间的读写集合互不相交,其写集合也互不相交时,就能保证可再现性。

    保证可再现性的条件——Bernstein条件

    1. 背景                                                                                                                                                                                                              首先,看个例子,进程P1,P2共用一个变量COUNT,初始值为0

                                             

         因为P1,P2两个进程的执行顺序是随机的,可能顺序执行也可能是并发的,由图可见,不同的执行顺序,COUNT的值会不同,这是不允许的。
         像这种情况,及多个进程并发访问和操作同一数据且执行结果与访问发生的特定顺序有关,称为竞争条件。

    进程互斥


    进程互斥在并发编程时是特别需要注意的,否则就会因为并发程序的非封闭性而造成无可挽救的损失。

    进程互斥是进程之间所发生的一种间接相互作用,是进程本身所不希望的,也是运行进程感受不到的。

    在继续向下讲述前,先解释几项概念:
    1. 共享变量
    多个进程均需访问的变量。

    可以近似的理解为高级语言中的全局变量或静态变量(因为这两种变量类型是多个程序段或函数均可访问的)。
    另外需要注意:共享变量既可能属于操作系统空间,也可能属于用户进程空间

    1. 临界区
      访问共享变量的程序段。

    2. 进程互斥
      多个进程不能同时进入关于同一组共享变量的临界区,否则可能发生与时间有关的错误。

      由于互斥是操作系统乃至并发程序设计中十分重要的概念,故需要准确的理解互斥的概念。

      • 不允许多个进程同时进入关于同一组共享变量的不同临界区

      • 不允许多个进程同时进入关于同一组共享变量的相同临界区 

    .临界资源

    上面讲到了临界区,那么就有必要提到临界资源了。虽然在多道程序系统中的诸进程可以共享各类资源,然而临界资源却是一次只能供一个进程使用,使用完后归还系统,才能给其他进程使用。(例如上面例子中的COUNT是临界资源)
    进程对临界资源必须互斥使用,为实现临界资源的互斥访问,应该保证诸进程互斥地进入自己的临界区。为此每个进程在进入其临界区前,必须先申请,经过允许后方能进入。

    同步机制应该遵循的准则:

    空闲让进
    当无进程处于临界区内时,必须让一个要求进入临界区的进程立即进入,以有
    效地利用
    临界资源
    忙则等待
    当已有进程处于临界区内时,其它试图进入临界区的进程必须等待,以保证它
    们互斥地进入
    临界区
    有限等待
    对要求进入临界区的进程,应在有限时间内使之进入,以免陷入“死等”。
    让权等待
    对于等待进入临界区的进程而言,它必须立即释放处理机,以免进程“忙等

    实现进程互斥

    实现互斥,就是保证同一时刻最多只有一个进程处于临界区内,也即实现对于临界区的管理。
    需要满足如下几个正确性原则:
    1. 互斥性原则
    任意时刻之多只能有一个进程处于关于同一组共享变量的临界区之中。
    2. 进展性原则
    临界区空闲时,只有执行了临界区入口及出口部分代码的进程参与下一个进入临界区的决策,该决策不可无限期延迟。
    3. 有限等待性原则
    请求进入临界区的进程应该在有限的等待时间内获得进入临界区的机会。

    Dekker互斥算法

    算法核心思想就是:

    • 设置一个可以表示进程是否将要进入或已经处于临界区的标志位。
    • 某一进程要进入临界区,需要查看其它进程是否处于临界区(检查对应进程号的标志位是否为1),做出等待或进入临界区的动作。

    Dekker算法


    Peterson互斥算法

    算法核心思想为:

    • 只要第二个进程在临界区,第一个进程就等待。

    相较于Dekker算法简单

    Peterson算法

    public class Peterson implements Runnable {
    
        private static boolean[] in = { false, false };
        private static volatile int turn = -1;
    
        public static void main(String[] args) {
            new Thread(new Peterson(0), "Thread - 0").start();
            new Thread(new Peterson(1), "Thread - 1").start();
        }
    
        private final int id;
    
        public Peterson(int i) {
            id = i;
        }
    
        private int other() {
            return id == 0 ? 1 : 0;
        }
    
        @Override
        public void run() {
            in[id] = true;
            turn = other();
            while (in[other()] && turn == other()) {
                System.out.println("[" + id + "] - Waiting...");
            }
            System.out.println("[" + id + "] - Working ("
                    + ((!in[other()]) ? "other done" : "my turn") + ")");
            in[id] = false;
        }}

    Lamport面包店算法

    算法核心思想为:

    • 对每个进程增设一个“摇号”状态,以及摇出的号码。
    • 进程处于“摇号”状态时不被获准进入临界区。
    • 对于“摇号”结束的进程进行所持有号码的比较,小号先行原则。

    Lamport算法

    算法思想源于面包店,但是这种情况确实经常会经历的。
    现在支付宝,微信用的比较多,以前去银行存钱,每次都得在门口的柜台机取一个号码,等柜员叫号,有时候银行里明明没什么人,取号的时候却显示有xx人在我前面,那叫一个气哦,所以在银行等的时候就很无聊了,时不时的要注意一下柜员有没有叫到自己。
    所以每次看到那种拿金卡去后面办业务的人好羡慕……
    银行取号排队的这个过程可能是Lamport算法最好的一个实例(天知道这些算法是不是哪个人在买面包的时候想到的)。

    Eisenberg-Mcguire算法

    个人觉得该算法是Dekker算法的加强版本,这算法的核心思想是:

    • 设置一个标志位表示空闲准备进入已进入三种状态。并标记当前正在临界区的进程号。(是不是很像Dekker算法呢)
    • 某一进程想要进入临界区时,判断是否存在其他进程已在临界区。
    • 退出临界区时找到下一个非空闲的进程。

    Eisenberg-Mcguire算法

    #define true    1
    #define false   0
    #define process_num 4//线程数目
    int choosing[process_num]={false};
    int number[process_num]={0};
    
    int find_max(void)/*找出最大号码*/
    {
        int max=0;
        int i=0;
        for(;i<process_num;++i)
        {
            if(number[i]>max)
                max=number[i];
        }
        return max;
    }
    
    void enter_lock(int thread_id)
    {
        int i=0;
        choosing[thread_id]=true;
        number[thread_id]=find_max()+1;/*选号码*/
        choosing[thread_id]=false;
        for(;i<process_num;++i)
        {
            while(choosing[i]);/*等待其他线程选号码*/
            while((number[i] != 0)&&
                ( (number[i] < number[thread_id]) || ((number[i] == number[thread_id]) && (i < thread_id)) ));/*阻塞,等待调度*/
        }
    }
    
    void exit_lock(int thread_id)
    {
        number[thread_id]=0;/*释放号码*/
    }
    void process_A(void)//线程0
    {
        enter_lock(1);
        //临界区
        //访问资源
        exit_lock(1);
    }
    void process_B(void)//线程1
    {
        enter_lock(2);
        //临界区
        //访问资源
        exit_lock(2);
    }


    我们发现,在Lamport和Eisenberg算法中出现了一条循环语句,可以让进程处于“等待”状态,但这并不是让进程从运行态变为等待态,只是让活动进程执行循环直到条件满足才能跳出而已,并不涉及到进程的状态改变。
    这种等待状态也称“忙式等待”

    “测试并设置”指令

    前文所介绍的都是软件方法实现进程的互斥,但硬件实现进程互斥通常会比采用软件方法要简单,不需要过多的动作,不过这需要以硬件支持为前提。
    “测试并设置”指令的定义如下:

    int test_and_set(int *target)
    {
        int temp;
        temp = *target;
        *target = 1;
        return temp;
    }

    这条指令是原子的,即在指令执行时是不可分割的。

    基于ts指令的算法思想与Dekker算法较为类似,为:

    • 查看现在是否有进程处于临界区。

    测试并设置指令的两种互斥算法

    左边的算法非常简单,但是却不满足有限等待性,即公平性。

    当某一进程退出临界区时,该算法没有指定下一个可以进入临界区的进程,如此便可造成一些进程长时间处于等待状态,甚至出现饿死的情况,即为不公平的算法。

    右边的算法则稍显复杂,但主要只增设了两个标志位,waiting表示是否处于等待态,key表示是否被获准进入临界区。

    由于出现了waiting这一标志位,因而现在可以得到多个进程的状态用于判断是否可以指定下一个可以进入临界区的进程。

    “交换”指令

    交换指令也是原子的,其定义为:

    void swap(int *a, int *b)
    {
        int temp;
        temp = *a;
        *a = *b;
        *b = temp;
    }

    交换和测试并设置指令的算法都是套路……

    交换指令的算法

    硬件提供中断指令:

    do{
         非临界区代码;
         关中断;
         临界区;
         开中断;
         其余代码;
    }while(1);

    转载·于:https://blog.csdn.net/ai977313677/article/details/72411488


    展开全文
  • 临界区进程互斥模拟

    2014-10-13 16:59:13
    文档加Java实现代码,实现临界区资源模拟
  • 该程序是我写的博客“一起talk C栗子吧(第一百零二回:C语言实例--使用信号量进行进程间同步与互斥三)”的配套程序,共享给大家使用
  • 线程进程互斥

    2017-03-01 19:58:16
    线程进程互斥
  • 进程互斥实验

    2015-10-07 21:27:11
    进程互斥实验
  • FileLock进程互斥

    2015-12-12 14:30:34
    使用FileLock实现进程互斥对应的说明在这里http://blog.csdn.net/codehxy/article/details/50274709
  • 进程互斥,使用CreatMutex创建互斥量啦实现的例子。
  • 进程同步与进程互斥

    千次阅读 2020-02-18 18:35:39
    (2)什么是进程互斥 2.什么是进程同步 进程具有异步性的特征。异步性是指,各并发执行的进程以各自独立的、不可预知的速度向前推进。 再看另一个例子:进程通信--------管道通信 读进程和写进程并发地运行,由于...

    1. 知识一览

    同步、互斥问题
    (1)什么是进程同步
    (2)什么是进程互斥

    2.什么是进程同步

    进程具有异步性的特征。异步性是指,各并发执行的进程以各自独立的、不可预知的速度向前推进。
    在这里插入图片描述再看另一个例子:进程通信--------管道通信
    在这里插入图片描述
    读进程和写进程并发地运行,由于并发必然导致异步性,因此“写数据"和“读数据”两个操作执行的先后顺序是不确定的。而实际应用中,又必须按照“写数据≥读数据”的顺序来执行的。

    如何解决这种异步问题,就是“进程同步”所讨论的内容。

    同步亦称直接制约关系,它是指为完成某种任务而建立的两个或多个进程,这些进程因为需要在某些位置上协调它们的工作次序而产生的制约关系。进程间的直接制约关系就是源于它们之间的相互合作。

    3 .什么是进程互斥

    进程的“并发"需要“共享”的支持。各个并发执行的进程不可避免的需要共享一些系统资源(比如内存,又比如打印机、摄像头这样的I/O设备)

    两种资源共享方式

    互斥共享方式
    系统中的某些资源,虽然可以提供给多个进程使用,但一个时间段内只允
    许一个进程访问该资源

    同时共享方式
    系统中的某些资源,允许一个时间段内由多个进程“同时”对它们进行访问

    我们把一个时间段内只允许一个进程使用的资源称为临界资源。许多物理设备( 比如摄像头、打印机)都属于临界资源。此外还有许多变量、数据、内存缓冲区等都属于临界资源。

    对临界资源的访问,必须互斥地进行。互斥,亦称间接制约关系。进程互斥指当一个进程访问某临界资源时,另一个想要访问该临界资源的进程必须等待。当前访问临界资源的进程访问结束,释放该资源之后,另一个进程才能去访问临界资源。

    对临界资源的互斥访问,可以在逻辑上分为如下四个部分:
    在这里插入图片描述
    注意:
    临界区是进程中访问临界资源的代码段。
    进入区和退出区是负责实现互斥的代码段。
    临界区也可称为“临界段”。

    为了实现对临界资源的互斥访问,同时保证系统整体性能,需要遵循以下原则:
    1.空闲让进。临界区空闲时,可以允许一个请求进入临界区的进程立即进入临界区
    2.忙则等待。当已有进程进入临界区时,其他试图进入临界区的进程必须等待
    3. 有限等待。对请求访问的进程,应保证能在有限时间内进入临界区(保证不会饥饿)
    4. 让权等待。当进程不能进入临界区时,应立即释放处理机,防止进程忙等待。
    在这里插入图片描述

    4. 小结

    在这里插入图片描述

    展开全文
  • 实验5 用信号量实现进程互斥

    千次阅读 2020-12-18 18:29:38
    实验5 利用信号量实现进程互斥 【实验目的】 (1) 理解互斥概念、信号量机制及信号量结构; (2) 掌握信号量的使用方法; (3) 掌握PV操作的定义; (4) 掌握PV操作实现互斥的方法。 【实验原理/实验基础知识】...

    实验5 利用信号量实现进程互斥
    【实验目的】
    (1) 理解互斥概念、信号量机制及信号量结构;
    (2) 掌握信号量的使用方法;
    (3) 掌握PV操作的定义;
    (4) 掌握PV操作实现互斥的方法。
    【实验原理/实验基础知识】
    一、 互斥
    多进程不能同时访问共享的临界资源的现象称为互斥。
    二、 Linux信号量结构
    每一个信号量集由一个sem_array结构来描述,该结构定义在文件/usr/src/linux-2.4/include/linux/sem.h中(若实验使用操作系统为ubuntu,则在以下路径中查找/usr/src/linux-header2.6.32-21/include/linux/sem.h)。
    三、 有关信号量的系统调用函数

    1. 创建一个新的信号量集或获取一个已经存在的信号量集
      命令格式:int semget(key_t key, int nsems, int semflg)
      返回值:正确时返回信号量集的标识符号,错误时返回-1。
      参数说明:
    1. key:信号量集的key值。
      a) 使用IPC_PRIVATE,由系统产生key值并返回标识符,或者返回key值已存在的信号量集的标识符。
      b) 若key值不使用IPC_PRIVATE,而是由用户指定一个非0的整型数值,则对信号量集的打开或存取操作依赖于semflag参数的取值。
    2. nsems:指定打开或者新创建的信号量集将包括的信号量的数目。如果该key值的信号量集已存在,而semflg只指定IPC_CREAT标志,那么参数nsems必须与原来的值一致,否则也会返回错误信息。该参数最大值在linux/sem.h中定义如下。
      #define SEMMSL 250 /* <= 8000 */
    3. semflg:当key值不为IPC_PRIVATE时使用。
      a) 若只设置semflag的IPC_CREAT位,则创建一个信号量集,如果该信号量集已经存在,则返回其标识符号。
      b) 若设置semflag的IPC_CREAT|IPC_EXCL位,则创建一个新的信号量集,如果该key值的信号量集已经存在,则返回错误信息。
      c) 只设置IPC_EXCL位而不设置IPC_CREAT位没有任何意义。
    1. 对信号量的P、V操作
      命令格式:int semop(int semid, struct sembuf * sops, unsigned nsops);
      返回值:正确时返回0,错误时返回-1。
      参数说明:
      (1) semid:信号量集的标识符号,由semget()得到。
      (2) sops:指向一个sembuf结构数组,该数组的每个元素对应一次信号量操作。其sembuf数据结构如下。
      struct sembuf
      {
      unsigned short sem_num;
      short sem_op;
      short sem_flg;
      }
      其参数含义如下:
      sem_num:标明是信号量集的第几个元素,第一个信号量为0,第二个信号量为1,依次类推。
      sem_op:确定对信号量采取何种操作,可以为负数、正数、零。
    1. sem_op为负数则相当于P操作,从信号量的值中减去sem_op的绝对值:
       差值大于0:表示该进程可以使用临界资源进入临界区;
       差值小于0:在没有指定IPC_NOWAIT的情况下,该进程睡眠,并插入sem_queues等待队列尾部,直到请求的条件得到满足;如果指定了IPC_NOWAIT,则出错返回。
    2. sem_op为正数,此时相当于V操作,把它的值加到信号量中,意味着该进程释放资源。如果是互斥则出临界区,释放临界资源。
    3. sem_op为0,则该进程进入睡眠,直到信号量的值也为0。
      系统会按顺序检查信号量等待队列(sem_pending)中的每一个成员,查看在当前信号量的状态下,其请求的操作是否可以成功,如果可以,则将它从等待队列中唤醒,并插入就绪队列等待调度运行。
      sem_flg:指明操作的执行模式,它有两个标志位。一个是IPC_NOWAIT,指明以非阻塞方式操作信号量。另一个是SEM_UNDO,指明内核为信号量操作保留恢复值。
      (3) nsops:是第二个参数所指向的sembuf结构数组中元素的个数,如果只有一个信号量,则为1。
      实验中使用该系统调用实现P、V操作,使用格式为:
      struct sembuf P,V;
      semop(semid,&P,1);
      semop(semid,&V,1);
    1. 信号量集的控制函数
      命令格式:int semctl(int semid, int semnum, int cmd, union semun arg);
      返回值:正确时根据cmd的不同返回需要的值或0,错误时返回-1。
      参数说明:
      (1) semid:信号量集的标识符,由semget()得到。
      (2) semnum:指定semid信号量集的第几个信号量,在撤销信号量集时,此时参数可以默认。
      (3) cmd用于指定操作类别。其取值如下:
       GETVAL:返回semnum指定的信号量的semval域值。
       SETVAL:置信号量semval域值为arg.val。
       GETPID:返回semnum指定的信号量的sempid,即最近对该信号量进行操作的进程ID。
       GETNCNT:返回semncnt。
       GETZNCT:返回semzcnt。
       GETALL:返回所有信号量的值。
       SETALL:通过对arg.arrary更新所有信号量的值。
       IPC_STAT:获取信号量集的sem_array,存入arg.buf。
       IPC_SET:将arg.buf数据结构的sem_perm.uid、sem_perm.gid、sem_perm.mode成员赋给信号量的sem_array结构。
       IPC_RMID:删除指定信号量集。
       IPC_INFO:获取信号量集相关的信息,存放在arg.buf中。
      (4) arg为5种数据的共用体类型semun,该类型在include/linux/sem.h中定义如下:
      union semun
      {
      int val;
      struct semid_ds *buf;
      unsigned short *array;
      struct seminfo *_buf;
      void *_pad;
      };
    1. 该数据表示int数值时,用于GETVAL、SETVAL或GETPID等设置或获取整型数据的操作。
    2. 该数据指向semid_ds(即sem_array)结构数据时,用于IPC_STAT或IPC_SET等针对信号量集进行的操作。
    3. 该数据指向unsigned short数组时,用于GETALL或SETALL。
    4. 该数据指向seminfo结构时,用于IPC_INFO操作,所指向的seminfo结构在include/linux/sem.h中定义,其定义如下:
      struct seminfo
      {
      int semmap;
      int semmni;
      int semmns;
      int semmnu;
      int semmsl;
      int semopm;
      int semume;
      int semusz;
      int semvmx;
      int semaem;
      };
      上述系统调用使用系列头文件:
      #include<sys/types.h>
      #inclue<linux/sem.h>
      四、 信号量及其P、V操作的实现方式
    1. 定义信号量标识符号
      int semid;
    2. 定义信号量数据结构
    1. 定义P、V操作所用的数据结构
      struct sembuf P,V;
    2. 定义给信号量赋初值的参数数据结构
      union semun arg;
    1. 申请只有一个信号量的信号量集
      semid=semget(IPC_PRIVATE,1,IPC_0666);
      IPC_PRIVATE:可由系统产生key值;
      1:表示信号量集中只有一个信号量;
      IPC_0666:表示操作权限。0666表示任意用户可读可写,只设置semflag的IPC_CREAT位,则创建一个信号量集。
    2. 分别对每个信号量semid赋初值
      arg.val=初值;
      semctl(semid,0,SETVAL,arg);
      其中0表示第0个信号量,arg的值由arg.val决定,所以必须事先为arg.val赋值。
    3. 定义信号量P操作
      P.sem_num=0;
      P.sem_op=-1;
      P.sem_flg=SEM_UNDO;
    4. 定义信号量V操作
      V.sem_num=0;
      V.sem_op=1;
      V.sem_flg=SEM_UNDO;
    5. 对信号量semid执行P操作
      semop(mutexid,&P,1);
    6. 对信号量semid执行V操作
      semop(mutexid,&V,1);
    7. 撤销信号量
      semctl(semid,IPC_REID,0);
      信号量非普通变量,对它的赋值操作只能通过semctl(semid,0,SETVAL,arg)进行,其值的修改只能通过P、V操作,而不能使用普通的赋值语句。因此其初值和信号量的P、V操作需要事先定义好后才能在进程中执行。
      【实验环境】VMware Workstation、RedHat
      【实验步骤】
      一、父子进程以非互斥方式共享访问临界资源
    1. 创建父子进程
    2. 父子进程共享一个临界资源,每个进程循环进入该临界区3次。
    3. 父进程每次进入临界区后显示“parent in”,出临界区显示“parent out”。
      printf(“parent in\n”);
      sleep(1);
      printf(“parent out\n”);
    4. 子进程每次进入临界区后显示“child in”,出临界区显示“child out”。
      printf(“child in\n”);
      sleep(1);
      printf(“child out\n”);
    5. 观察执行结果。
      #include<stdio.h>标准输入输出函数库
      #include<stdlib.h>是C语言库头文件之一,包含了以下函数:
      1 字符串转换为数字的函数,包括atoi, atof, strtol等。
      2 随机数函数,包括srand, rand等。
      3 内存分配释放函数,如malloc,calloc,realloc,free等。
      4 程序运行控制函数,如exit, abort等。
      5 系统访问相关函数,如printenv, setenv,system等。
      6 常用算法函数,如qsort, bsearch, abs,div等。
      #include<unistd.h>不是c语言的东西,是linux/unix的系统调用,包含了许多U N I X系统服务的函数原型,例如 read,write和getpid函数。unistd.h在unix中类shu似于window中的windows.h!
      #include<sys/types.h>此头文件还包含适当时应使用的多个基本派生类型。尤其是以下类型更为重要:clock_t 表示系统时间(以时钟周期为单位)。  dev_t 用于设备号。  off_t 用于文件大小和偏移量。  ptrdiff_t 是一种带符号整型,用于对两个指针执行减法运算后所得的结果。  size_t 反映内存中对象的大小(以字节为单位)。  ssize_t 供返回字节计数或错误提示的函数使用。  time_t 以秒为单位计时。  所有这些类型在 ILP32 编译环境中保持为 32 位值,并会在 LP64 编译环境中增长为 64 位值。
      #include<sys/sem.h>是glibc提供的调用接口,#include <linux/sem.h>是系统提供的调用接口,本身不是同一个实现。

    #include<stdio.h>
    #include<unistd.h>
    #include<stdlib.h>
    #include<sys/types.h>
    #include<linux/sem.h>
    int mutexid;
    int main()
    {
    int chld,i,j;
    while((chld=fork())-1);
    if(chld>0)
    {
    i=1;
    while(i<=3)
    {
    sleep(1);
    printf(“parent in.\n”);
    sleep(1);
    printf(“parent out.\n”);
    i++;
    }
    wait(0);
    exit(0);
    }
    else
    {
    j=1;
    while(j<=3)
    {
    sleep(1);
    printf(“child in.\n”);
    sleep(1);
    printf(“child out.\n”);
    j++;
    }
    exit(0);
    }
    }
    在这里插入图片描述
    在这里插入图片描述
    二、PV操作实现进程互斥。以实验步骤一为基础,增加PV操作,实现父子进程互斥访问临界区。
    (1) 定义与PV操作相关的数据结构;
    (2) 定义信号量,给信号量赋值;
    (3) 定义PV操作;
    (4) PV操作实现进程互斥。
    (5) 观察执行结果,并与实验步骤一的结果比较。
    #include<unistd.h>
    #include<stdio.h>
    #include<stdlib.h>
    #include<sys/types.h>
    #include<linux/sem.h>
    int mutexid;
    int main()
    {
    int chld,i,j;
    struct sembuf P,V;
    union semun arg;
    untexid = semget(IPC_PRIVATE,1,0666|IPC_CREAT);
    arg.val=1;
    if(semctl(mutexid,0,SETVAL,arg)
    -1)
    perror(“semctl setval error.”);
    P.sem_num=0;
    P.sem_op=-1;
    P.sem_flg=SEM_UNDO;
    V.sem_num=0;
    V.sem_op=1;
    V.sem_flg=SEM_UNDO;
    while((chld=fork())==-1)
    if(chld>0)
    {
    i=1;
    while(i<=3)
    {
    sleep(1);
    semop(mutexid,&P,1);//进入临界区,执行P操作
    printf(“parent in.\n”);
    sleep(1);
    printf(“parent out.\n”);//出临界区,执行V操作
    semop(mutexid,&V,1);
    i++;
    }
    wait(0);
    semctl(mutexid,IPC_RMID,0);
    exit(0);
    }
    else
    {
    j=1;
    while(j<=3)
    {
    sleep(1);
    semop(mutexid,&P,1);
    printf(“child in.\n”);
    sleep(1);
    printf(“child out.\n”);
    semop(mutexid,&V,1);
    j++;
    }
    exit(0);
    }
    }
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    【实验报告】
    填写《信息技术学院学生上机实验报告》。
    【思考题】
    (1) 实验步骤一的结果说明什么?
    (2) P、V操作在各进程代码中的位置应该如何处理?

    展开全文
  • 操作系统实验五:进程互斥实验报告。进一步研究和实践操作系统中关于并发进程同步与互斥操作的一些经典问题的解法,加深对于非对称性互斥问题有关概念的理解。观察和体验非对称性互斥问题的并发控制方法。进一步了解...
  • 操作系统实验四——进程互斥 实验目的: 进一步认识并发执行的实质,学习解决进程互斥的方法。 实验内容: 用lock()给每个进程加锁实现进程之间的互斥。 实验指导: 本实验中涉及的系统调用如下: lockf(files,...

    操作系统实验四——进程互斥

    实验目的:
    进一步认识并发执行的实质,学习解决进程互斥的方法。

    实验内容:
    用lock()给每个进程加锁实现进程之间的互斥。

    实验指导:
    本实验中涉及的系统调用如下:

    lockf(files,function,size)
    

    lock()用于锁定文件的某些端或整个文件。
    函数头文件为:

    #include<unistd.h>
    

    参数定义:

    int lockf(files,function,size)
    int files,function;
    long size;
    

    其中,files是文件描述符。function是锁定和解锁:1表示锁定,0表示解锁。size是锁定或解锁的字节数,为0表示从文件的当前位置到文件尾。

    参考程序源代码:

    #include<stdio.h>#include<unistd.h>
    *#include<sys/types.h>*/
    main( )
    {
    int pl,p2,i;
    pl=fork() ;
    if(pl==0)
    	{lockf(1,1,0);for(i=0;i<10;i++)
    	printf ( "daughter %dn",i) ;lockf( 1,0,0 ) ;
    	}
    else
    	{p2=fork( );
    	if(p2==0)
    		{lockf(1,1,0);for(i=0;i<10; i++)
    		printf ( "son %d\n",i);iockf(1,0,0);
    		}
    	else
    		{lockf( 1,1,0);for( i=o;i<10 ; i++)
    		printf ( "parent %d\n",i);lockf( 1,0,0 ) ;
    		}
    	}
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • 进程互斥访问临界区

    千次阅读 2019-10-21 20:17:35
    进程对临界资源的访问需要互斥,其需要遵从以下四个原则: 1、空闲让进:临界区空闲时应该允许一个进程访问; 2、忙则等待:临界区被访问时,其余想访问他的进程必须等待; 3、有限等待:等待的进程在外等待的...
  • 一、进程互斥 由于进程具有独立性和异步性等并发特征,计算机的资源有限,导致了进程之间的资源竞争和共享,也导致了对进程执行过程的制约。 1.临界区相关概念: 临界资源:也就是一次只允许一个进程操作使用的...
  • 实现进程互斥的方法

    千次阅读 2020-03-23 11:15:31
    (OS)实现互斥的方法 一、软件方法(3种): ①单标记法:该算法设置一个公用整型变量turn,用于指示被允许进入临界区的进程编号,即若turn=0,则允许P0进程进入临界区。该算法可确保每次只允许一个进程进入临界区。...
  • 文章目录前言知识总览信号量机制实现进程互斥信号量机制实现进程同步信号量机制实现前驱关系知识回顾与重要考点 前言 此篇文章是我在B站学习时所做的笔记,大部分图片都是课件老师的PPT,方便复习用。此篇文章仅供...
  • 进程互斥(C语言实现)

    千次阅读 2019-02-22 20:55:16
    //Sleep(100) //启用互斥量时也去除注释,为进程调度提供时间 } return NULL; } void* My_thread_2(void* args){ while(1){ char *p=Share; //pthread_mutex_lock(&work_mutex); //加锁 for(int i=0;i;...
  • 进程互斥的软件实现方法 1.单标志法 2.双标志先检查法 3.双标志后检查法 4.Peterson算法 5.Peterson算法的评价 6.总结
  • 进程互斥1.flock实验1实验2 1.flock 头文件 #include<sys/file.h> 函数原型 lockf(fd,mode,size) 函数参数 fd:操作的文件名,如果文件不存在,系统会创建这个文件名,其中0为锁住键盘,1为锁住显示器 mode...
  • 实现进程互斥的软件四种方法

    千次阅读 2019-12-09 23:57:46
    算法思想:每个进入临界区的全县只能被另一个进程赋予。如图一 缺点:违背了“空闲让进”的原则。 2.双标志先检查法 算法思想:每个进程在进入临界区之前先检查当前有没有别的进程想进入临界区,如果没有,则把自身...
  • 实现进程互斥的硬件方法 中断禁用 单处理器系统中进程在进入临界区前禁用中断,离开临界区后启用中断,这样保证进程在临界区时不会被打断,不会被抢占 while (true){ //禁用中断 //临界区 //启用中断 //其他部分...
  • 进程互斥和进程同步

    千次阅读 2018-05-27 22:40:27
    概念: 1.临界资源(critical resource): 系统中某些资源一次只允许一个进程使用,称这样的资源为...3.进程互斥(mutual exclusive):由于各进程要求使用共享资源(变量、文件等),而这些资源需要排他性使用,...
  • 理发店问题:假设理发店的理发室中有3个理发椅子和3个理发师,有一个可容纳4个顾客坐等理发的沙发。此外还有一间等候室,可容纳13位顾客等候... 请利用linux系统提供的IPC进程通信机制实验并实现理发店问题的一个解法。
  • 进程互斥实例.rar

    2020-10-02 21:58:01
    单个进程运行,mutex创建和存在性判断,作为程序是否被启动的判断依据,头文件有具体调用方法。可以直接拿来使用。
  • 进程互斥的硬件实现方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,862
精华内容 56,744
关键字:

进程互斥