精华内容
下载资源
问答
  • 3.整型信号量4.记录型信号量(1)举一个生动形象的例子了解记录型信号量(2)梳理一下记录型信号量的知识点(P、V) 0.思维导图 1.为什么引入信号量机制? 为了更好的解决进程互斥与同步的问题 2.什么是信号量...


    0.思维导图

    在这里插入图片描述

    1.为什么引入信号量机制?

    • 为了更好的解决进程互斥与同步的问题
      在这里插入图片描述

    2.什么是信号量机制?

    在这里插入图片描述

    3.整型信号量

    在这里插入图片描述

    4.记录型信号量

    在这里插入图片描述

    (1)举一个生动形象的例子了解记录型信号量
    • 一张图咱们回忆一下进程的状态
      在这里插入图片描述
    • 一个例子
      在这里插入图片描述
      在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    (2)梳理一下记录型信号量的知识点(P、V)

    在这里插入图片描述
    参考:https://www.bilibili.com/video/av70156862?p=20

    展开全文
  •  整型信号量S(数据结构是一个整型数,用整型数代表信号可用不可用,小于等于0时不可用,大于0时可用) 整型数P操作(wait)原语 、V操作(signal)原语(用完之后,释放资源)wait(s): while s<=0; //do.....

        信号量是一种数据结构(可以是整型数、整型数组、链表、记录型变量(结构体))。信号量的值与相应资源的使用情况有关。信号量的值仅由P、V操作改变。

        整型信号量S(数据结构是一个整型数,用整型数代表信号可用不可用,小于等于0时不可用,大于0时可用)

        整型数P操作(wait)原语 、V操作(signal)原语(用完之后,释放资源)

    wait(s): while s<=0; //do no-op //当s≤0时,循环检测s是否≤0
             s:=s-1; //s>=0时
    signal(s): s:=s+1;

    wait(s)和signal(s)是原子操作(最基本、最小的、中间不允许插入任何中断的操作。要执行就要执行完),只要信号量s≤0就不断测试,不满足让权等待。

    缺点:不满足让权等待,空闲时仍占着CPU。

    优点:实现简单。

        记录型信号量:记录型结构,

    type semaphore = record  //一种结构的表示方法,定义为record类型(可以看作结构体类型)

    //包含两个数据项:

    value: integer; 

    L : list of process; //存放进程的PCB,是一个阻塞队列

    end

    S.value 为资源信号量的初值,表示某类资源的数目。当s.value大于等于0时,表示系统中可用资源的实体数;当s.value<0时,其绝对值代表等待使用资源的进程个数

    wait操作:申请一个单位资源。

    Procedure wait(S) Var S:semaphore;

    begin S.value = S.value -1;

    If S.value <0 then block(S,L)  //如果申请资源失败,使正在执行的进程进入阻塞队列(等待队列),block函数指定是哪个资源(S),和等待该资源的进程的阻塞队列(链表L)

    end

    该PCB链表是一个阻塞队列,当有进程申请S所代表的资源申请不到时,进入链表当中,陷入阻塞状态。

    等待队列有多个,等待打印机的站在一个队列,等待磁带机的站在一个队列。(根据等待原因不同,系统当中有多个阻塞队列)。

    signal操作:释放一个单位资源

    Proceduce signal(S)  //S代表资源的信号量

      Var S:semaphore;

    begin

    S.value := S.value +1; //系统当中可用资源的数目多个一个(value >0),系统当中等待资源的进程数目少了一个(value <0),

    //当value<0时,value+1其绝对值变小

    If S.value <= 0 

    then wakeup(s.L) //将等待队列中的进程拿出一个放入就绪队列,(唤醒一个等待进程)

    end

    S.value 初值为1时(系统当中可用临界资源的个数为1),只允许一个进程访问临界资源,是互斥信号量(不能同时被占有)(互斥时,初值为1)

    当value=0时,系统当中可用临界资源的个数为0;系统当中等待临界资源的进程个数为0


    展开全文
  • 整型信号量机制中,信号量被定义为一个整形变量。除初始化外,仅能通过两个标准的原子操作Wait(S)和Signal(S)来访问。其通常分别被称为P、V操作。 描述如下: P操作:S=S-1;如果S小于0,则进程进入等待状态...
    在整型信号量机制中,信号量被定义为一个整形变量。除初始化外,仅能通过两个标准的原子操作Wait(S)和Signal(S)来访问。其通常分别被称为P、V操作。
    

    描述如下:

    P操作:S=S-1;如果S小于0,则进程进入等待状态,否则继续执行。

    V操作:S=S+1;如果S>=0,则唤醒等待队列中的一个等待进程。

    信号量有其自身的物理含义:当S>0时,其值表示要管理的某类资源的数量;当S<0时,它的绝对值表示在相关队列中等待的进程个数。

     

    进程的同步

    一般来说,一个进程相对与另一个进程的运行速度是不确定的,也就是说,进程是在异步环境下运行的,每个进程都以各自独立的、不可预知的速度向前推进。但是,相互合作的进程需要在某些确定的点上协调他们的工作,当一个进程到达了这些点后,除非另一个进程已经完成了某些操作,否则就不得不停下来等待这些操作结束。这就是进程的同步。

     

    进程的互斥

    在多道程序系统中,各进程可以共享各类资源,但有些资源一次只能供一个进程使用,这种资源称为临界资源。

    对临界区的管理原则:有空则进,无空则等,有限等待,让权等待。

     

    进程互斥的情况,信号量初值是1;而同步的情况,信号量初值是0.

    在解决具体问题时,面对各种并发进程,首先应该分析它们之间哪些是互斥关系,哪些是同步关系,由此而确定应该设置哪些信号量及它们的初值。

    如果所设置的信号量,每个相关进程即对它施行P操作,也对它施行V操作,则称其为共用信号量。用于互斥的都是公用信号量。

    若设置的信号量,只有一个进程能对它施行P操作,其他进程只能对它施行V操作,则称其为那一个进程的私用信号量。用于同步或资源分配管理的信号量都是私用信号量。

     

    展开全文
  • 整型信号量与记录型信号量

    千次阅读 2015-08-15 21:47:00
    信号量机构是一种功能较强的机制,可用来解决互斥与同步的问题,它只能被两个标准的原语wait(S)和signal(S)来访问,也可以记为“P操作”和“V操作”。 原语是指完成某种功能且不被分割不被中断执行的操作序列,通常...
    信号量机构是一种功能较强的机制,可用来解决互斥与同步的问题,它只能被两个标准的原语wait(S)和signal(S)来访问,也可以记为“P操作”和“V操作”。

    原语是指完成某种功能且不被分割不被中断执行的操作序列,通常可由硬件来实现完成不被分割执行特性的功能。如前述的“Test-and-Set”和“Swap”指令,就是由硬件实现的原子操作。原语功能的不被中断执行特性在单处理机时可由软件通过屏蔽中断方法实现。

    原语之所以不能被中断执行,是因为原语对变量的操作过程如果被打断,可能会去运行另一个对同一变量的操作过程,从而出现临界段问题。如果能够找到一种解决临界段问题的元方法,就可以实现对共享变量操作的原子性。

    整型信号量

    整型信号量被定义为一个用于表示资源数目的整型量S,wait和signal操作可描述为:
    1. wait(S){
    2. while (S<=0);
    3. S=S-1;
    4. }
    5. signal(S){
    6. S=S+1;
    7. }
    wait(S){
        while (S<=0);
        S=S-1;
    }
    signal(S){
        S=S+1;
    }
    wait操作中,只要信号量S<=0,就会不断地测试。因此,该机制并未遵循“让权等待” 的准则,而是使进程处于“忙等”的状态。

    记录型信号量

    记录型信号量是不存在“忙等”现象的进程同步机制。除了需要一个用于代表资源数目的整型变量value外,再增加一个进程链表L,用于链接所有等待该资源的进程,记录型信号量是由于釆用了记录型的数据结构得名。记录型信号量可描述为:
    1. typedef struct{
    2. int value;
    3. structprocess *L;
    4. } semaphore;
    typedef struct{
        int value;
        struct process *L;
    } semaphore;
    相应的wait(S)和signal(S)的操作如下:
    1. void wait (semaphoreS) { //相当于申请资源
    2. S.value--;
    3. if(S.value<0) {
    4. add this process toS.L;
    5. block(S.L);
    6. }
    7. }
    void wait (semaphore S) { //相当于申请资源
        S.value--;
        if(S.value<0) {
            add this process to S.L;
            block(S.L);
        }
    }
    wait操作,S.value--,表示进程请求一个该类资源,当S.value<0时,表示该类资源已分配完毕,因此进程应调用block原语,进行自我阻塞,放弃处理机,并插入到该类资源的等待队列S.L中,可见该机制遵循了“让权等待”的准则。
    1. void signal (semaphoreS) { //相当于释放资源
    2. S.value++;
    3. if(S.value<=0){
    4. remove a process P fromS.L;
    5. wakeup(P);
    6. }
    7. }
    void signal (semaphore S) {  //相当于释放资源
        S.value++;
        if(S.value<=0){
            remove a process P from S.L;
            wakeup(P);
        }
    }
    signal操作,表示进程释放一个资源,使系统中可供分配的该类资源数增1,故S.value++。若加1后仍是S.value<=0,则表示在S.L中仍有等待该资源的进程被阻塞,故还应调用wakeup 原语,将S.L中的第一个等待进程唤醒。

    利用信号量实现同步

    信号量机构能用于解决进程间各种同步问题。设S为实现进程P1、P2同步的公共信号量,初值为0。进程P2中的语句y要使用进程P1中语句x的运行结果,所以只有当语句x执行完成之后语句y才可以执行。其实现进程同步的算法如下:
    1. semaphoreS = 0; //初始化信号量
    2. P1 ( ) {
    3. // …
    4. x; //语句x
    5. V(S); //告诉进程P2,语句乂已经完成
    6. }
    7. P2(){
    8. // …
    9. P(S) ; //检查语句x是否运行完成
    10. y; // 检查无误,运行y语句
    11. // …
    12. }
    semaphore S = 0;  //初始化信号量
    P1 ( ) {
        // …
        x;  //语句x
        V(S);  //告诉进程P2,语句乂已经完成
    }
    P2()){
        // …
        P(S) ;  //检查语句x是否运行完成
        y;  // 检查无误,运行y语句
        // …
    }

    利用信号量实现进程互斥

    信号量机构也能很方便地解决进程互斥问题。设S为实现进程Pl、P2互斥的信号量,由于每次只允许一个进程进入临界区,所以S的初值应为1(即可用资源数为1)。只需把临界区置于P(S)和V(S)之间,即可实现两进程对临界资源的互斥访问。其算法如下:
    1. semaphoreS = 1; //初化信号量
    2. P1 ( ) {
    3. // …
    4. P(S); // 准备开始访问临界资源,加锁
    5. // 进程P1的临界区
    6. V(S); // 访问结束,解锁
    7. // …
    8. }
    9. P2() {
    10. // …
    11. P(S); //准备开始访问临界资源,加锁
    12. // 进程P2的临界区;
    13. V(S); // 访问结束,解锁
    14. // …
    15. }
    semaphore S = 1;  //初化信号量
    P1 ( ) {
        // …
        P(S);  // 准备开始访问临界资源,加锁
        // 进程P1的临界区
        V(S);  // 访问结束,解锁
        // …
    }
    P2() {
        // …
        P(S); //准备开始访问临界资源,加锁
        // 进程P2的临界区;
        V(S);  // 访问结束,解锁
        // …
    }
    互斥的实现是不同进程对同一信号量进行P、V操作,一个进程在成功地对信号量执行了 P操作后进入临界区,并在退出临界区后,由该进程本身对该信号量执行V操作,表示当前没有进程进入临界区,可以让其他进程进入。

    利用信号量实现前驱关系

    信号量也可以用来描述程序之间或者语句之间的前驱关系。图2-8给出了一个前驱图,其中S1, S2, S3, …, S6是最简单的程序段(只有一条语句)。为使各程序段能正确执行,应设置若干个初始值为“0”的信号量。例如,为保证S1 -> S2、 S1 -> S3的前驱关系,应分别设置信号量a1、a2。同样,为了保证 S2 -> S4、S2 ->S5、S3 -> S6、S4 -> S6、S5 -> S6,应设置信号量bl、b2、c、d、e。 


    图2-8 前驱图举例

    实现算法如下:
    1. semaphoreal=a2=bl=b2=c=d=e=0; //初始化信号量
    2. S1() {
    3. // …
    4. V(al); V(a2) ; //S1已经运行完成
    5. }
    6. S2() {
    7. P(a1); //检查S1是否运行完成
    8. // …
    9. V(bl); V(b2); // S2已经运行完成
    10. }
    11. S3() {
    12. P(a2); //检查S1是否已经运行完成
    13. // …
    14. V(c); //S3已经运行完成
    15. }
    16. S4() {
    17. P(b1); //检查S2是否已经运行完成
    18. // …
    19. V(d); //S4已经运行完成
    20. }
    21. S5() {
    22. P(b2); //检查S2是否已经运行完成
    23. // …
    24. V(e); // S5已经运行完成
    25. }
    26. S6() {
    27. P(c); //检查S3是否已经运行完成
    28. P(d); //检查S4是否已经运行完成
    29. P(e); //检查S5是否已经运行完成
    30. // …;
    31. }
    semaphore  al=a2=bl=b2=c=d=e=0;  //初始化信号量
    S1() {
        // …
        V(al);  V(a2) ;  //S1已经运行完成
    }
    S2() {
        P(a1);  //检查S1是否运行完成
        // …
        V(bl); V(b2); // S2已经运行完成
    }
    S3() {
        P(a2);  //检查S1是否已经运行完成
        // …
        V(c);  //S3已经运行完成
    }
    S4() {
        P(b1);  //检查S2是否已经运行完成
        // …
        V(d);  //S4已经运行完成
    }
    S5() {
        P(b2);  //检查S2是否已经运行完成
        // …
        V(e);  // S5已经运行完成
    }
    S6() {
        P(c);  //检查S3是否已经运行完成
        P(d);  //检查S4是否已经运行完成
        P(e);  //检查S5是否已经运行完成
        // …;
    }

    分析进程同步和互斥问题的方法步骤

    1) 关系分析。找出问题中的进程数,并且分析它们之间的同步和互斥关系。同步、互斥、前驱关系直接按照上面例子中的经典范式改写。

    2) 整理思路。找出解决问题的关键点,并且根据做过的题目找出解决的思路。根据进程的操作流程确定P操作、V操作的大致顺序。

    3) 设置信号量。根据上面两步,设置需要的信号量,确定初值,完善整理。
    说明:本文非原创,原始链接已不可查。





    转载于:https://www.cnblogs.com/fengkang1008/p/4733197.html

    展开全文
  • 整型信号量 记录型信号量 利用信号量实现同步 利用信号量实现进程互斥 利用信号量实现前驱关系 分析进程同步和互斥问题的方法步骤 信号量机构是一种功能较强的机制,可用来解决互斥与同步的问题,它只能被两个...
  • 名词解释:PV操作:执行一次p操作意味着请求分配一个单位资源,因此s的值-1,当s时,表示已经没有可用资源,进程阻塞,请求者必须等待别的进程释放该类资源,才能继续运行下去,所以当s时...1.利用信号量形成互斥 ……
  • 信号量机制

    2021-05-01 20:28:08
    信号量机制――整型信号量3. 信号量机制――记录型信号量知识回顾与重要考点 知识总览 1. 信号量机制 2. 信号量机制――整型信号量 3. 信号量机制――记录型信号量 知识回顾与重要考点 ...
  • 2.3.4 信号量机制

    2020-09-19 16:35:55
    目录思维导图整型信号量记录型信号量 思维导图 整型信号量 记录型信号量 重点记忆: P 申请资源,V 释放资源。 整型信号量: 当资源不够时会一直的循环等待,陷入忙等状态。 记录型信号量: 当资源不够时会进入...
  • 进程同步之信号量

    2019-07-13 16:27:48
    目录 1.信号量机制 2.整型信号量 3.记录型信号量 1.信号量机制 2.整型信号量 3.记录型信号量
  • 信号量

    2020-06-25 12:37:45
    文章目录信号量机制整型信号量记录型信号量信号量机制实现各种操作进程互斥进程同步前驱关系 信号量机制 用户进程可以通过操作系统提供的一对原语来对信号量进行操作,从而很方便的实现了进程互斥、进程同步。 信号...
  • 进程——信号量机制

    2018-11-19 19:49:48
    1) 整型信号量 1.信号量定义为一个整型量; 2.根据初始情况赋相应的值; 3.仅能通过两个原子操作来访问。 2)记录型信号量 整型信号量符合“有限等待”原则 signal释放资源后,当CPU被分配给等待进程后,等待进程...
  • 信号量原理

    2020-09-12 20:18:54
    整型信号量用于描述临界资源的个数。 s=10; 表示一个初始资源数量为10的信号量 wait(s) { while (s <= 0); s --; } signal(s) { s ++; } 缺点:违背“让权等待”的同步原则,由于当信号量所表示的资源数目&...
  • 2.3.4信号量机制

    2020-11-20 16:41:15
    2.3.4信号量机制(重要) 知识总览 1.整型信号量 2.记录型信号量 例子 3.总结
  • 1、整型信号量 1)信号量定义为一个整型量; 2)根据初始情况赋相应的值; 3)仅能通过两个原子操作来访问。 整型信号量符合“有限等待”原则 signal释放资源后,当CPU被分配给等待进程后,等待进程仍可继续执行,...
  • 四种信号量

    2021-06-02 20:19:46
    传送门1、整型信号量2、记录型信号量3、AND型信号量4、信号量集5、信号量实现互斥 说在前:①信号量机制是对具体物理资源的抽象②同类资源的个数用>0的信号量值来表示③0或1的则为临界资源 1、整型信号量 1.1 ...
  • 文章目录计算机操作系统之信号量机制整型信号量记录型信号量AND型信号量信号量集特殊情况 整型信号量整型信号量定义为一个用于表示资源数目的整型量S, 它与一般的整型量不同,除初始化外,仅通过两个标准的原子...
  • 极简学习信号量

    2019-12-12 14:38:54
    参考 《王道-操纵系统》 概述 信号量机制用于解决同步和互斥的问题,它通过两个...整型信号量是将信号量定义为整型 S wait(S) { // 如果资源数小于 0 则陷入忙等 while(S<=0); S=S-1; } signal(S) { S=S+1; }...
  • 一、信号量机制 二、整型信号量 三、记录型信号量 四、信号量机制实现进程互斥 五、信号量机制实现进程同步 六、信号量机制实现前驱关系 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 520
精华内容 208
关键字:

整型信号量