2.3 同步与互斥——王道操作系统笔记整理

最新推荐文章于 2024-05-25 16:48:57 发布
最新推荐文章于 2024-05-25 16:48:57 发布
阅读量1.3k 收藏 6
点赞数 1
分类专栏： 操作系统 文章标签： 计算机操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45729594/article/details/124351385
版权

2.3同步与互斥

下面的代码只是用于理解其中的逻辑，并不是计算机编译器中的代码就是这些代码。

重点

PV操作

管程

生产者消费者问题

多生产者和多消费者问题

问题

  • 为什么引入进程同步概念

    因为进程具有异步性（进程各自独立，以不可预知的速度推进）。为了协调进程之间的相互制约关系，引入了进程同步的概念。

  • 管程中的wait、singal 和 同步中的P V操作的区别

    x.wait:当x对应的条件不满足时，正在调用**管程的进程调用x.wait将自己插入x条件的等待队列，并释放管程。**此时其他进程可以使用该管程。

    x.signal: x对应的条件发生了变化，则调用x.signal，唤醒一个因x条件而阻塞的进程。

    条件变量和信号变量的比较

    相似点：条件变量的wait/signal操作类似于信号量的P/V操作，可以实现进程的阻塞唤醒。

    不同点：

    • 条件变量是没有值的，仅实现了”排队等待“功能；而信号量是”有值“的。
    • 信号量的值反映了剩余资源数，在管程中，剩余资源数用共享数据结构记录。

  • 管程的概念

    当共享资源用共享数据结构表示时，资源管理程序可用对该数据结构进行操作的一组过程来表示。把这样一组相关的数据结构和过程一并归为管程。

    Hansan为管程所下的定义是:“一个管程定义了一个数据结构和能为并发进程所执行（在该数据结构上）的一组操作，这组操作能同步进程和改变管程中的数据。”由定义可知，管程由以下部分组成:

    1. 局部于管程的共享变量说明。
    2. 该数据结构进行操作的一组过程。
    3. 对局部于管程的数据设置初始值的语句;
    4. 管程名称。

    管程的引入是为了解决临界区分散所带来的管理和控制问题。

术语

  • 临界资源 ：在一段时间内只允许一个进程访问的资源。
  • 临界区：进程访问临界资源的那段代码
  • 忙等待：进程因需要等待资源，同时又占用处理机

2.3.1 同步与互斥的基本概念

临界资源

在一段时间内只允许一个进程访问的资源。又称独占资源。

  1. 常见的临界资源：系统中的大多数物理设备：如打印机、磁带机。还有栈和变量、表格。
  2. 访问方式：互斥访问。
  3. 临界资源不能并发的被多个程序占用，其他资源可以。
临界区

临界区是进程访问临界资源的那段代码。《是代码，是代码，是代码》

  1. **进入区。**为了进入临界区使用临界资源，在进入区要检查可否进入临界区，若能进入临
    界区，则应设置正在访问临界区的标志，以阻止其他进程同时进入临界区。
  2. **临界区。**进程中访问临界资源的那段代码，又称临界段。
  3. **退出区。**将正在访问临界区的标志清除。
  4. 剩余区。代码中的其余部分。

注：主要是 进入区、临界区、退出区。

进入区和退出区 是负责实现互斥的代码段。

进程同步

在多道程序环境下，进程是并发执行的，不同进程之间存在着不同的相互制约关系。 我们把异步环境下的一组并发进程因直接制约而互相发送消息、进行互相合作、互相等待，使得各进程按一定的速度执行的过程称为进程间的同步。

因为进程具有异步性（进程各自独立，以不可预知的速度推进）。为了协调进程之间的相互制约关系，引入了进程同步的概念。

也称直接制约关系。

进程互斥

进程互斥是多道程序系统中进程间存在的一种源于资源共享的制约关系，主要是由被共享资源的使用性质所决定的。、

禁止两个进程同时进入临界区。

也称间接制约关系。

需要遵循以下机制：

  • 空闲让进 ：临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区。
  • 忙则等待：当已有进程进入临界区时，其他试图进入临界区的进程必须等待。
  • 有限等待：对请求访问的进程，应保证能在有限时间进入临界区。
  • 让权等待：当进程不能进入临界区时，应立即释放处理器，防止进程忙等待。

2.3.2 实现临界区互斥的基本方法

软件实现方法

算法1：单标志法
思想：

该算法设置一个公用整型变量turn，用于指示被允许进入临界区的进程编号，即若turn = 0，则允许P0,进程进入临界区。

该算法可确保每次只允许一个进程进入临界区。但两个进程必须交替进入临界区、若某个进程不再进入临界区，则另一个进程也将无法进入临界区（违背“空闲让进")，造成资源利用不充分。
P0顺利进入临界区并从临界区离开，则此时临界区是空闲的，但P并没有进入临界区的打算，turn = 1一直成立，P0就无法再次进入临界区.（一直被while死循环困住:)。

缺点
  • 违背“空闲让进
  • 会造成死循环
代码
      int turn = 0;//公共整形变量
/*  p0 */
      while (turn != 0);
      //临界区
      turn =1;
      //剩余区


/*  p1*/
      while (turn != 1);
      //临界区
      turn =0;
      //剩余区
算法2：双标志法先检查
思想

该算法的基本思想是在每个进程访问临界区资源之前，先查临界资源是否正被访间，若正被访间，该进程需等待，否则，进程才进入自己的临界区。

为此，设置一个数据 flag[i]，如：

  • 第 i个元素值为FALSE，表示Pi进程未进入临界区
  • 值为TRUE．表示Рi进程进入临界区。
优点
  • 不用交替进入，可连续使用
缺点
  • 可能同时进入临界区，违背“忙则等待”

进入区的检查和修改操作不能一次进行，如果是源语即可避免这个问题。

代码
//        int flag[i] ;
//        Pi进程
        while (flag[j]);//进入区
        flag[i] = TRUE;//进入区
        //临界区
        flag[i] = FALSE;  //退出区
        //剩余区

//        Pj进程
        while (flag[i]);//进入区
        flag[j] = TRUE;//进入区
        //临界区
        flag[j] = FALSE;  //退出区
        //剩余区
算法3：双标志法后检查
思想

算法二先检测对方的进程状态标志，再置自已的标志
在检测和放置中可插入另一个进程到达时的检测操作，会造成两个进程在分别检时进入临界区。

为此，算法三先将自已的标志设置为 TRUE．再检测对方的状态，若对方标志为TRUE，则进程等待，否则进入临界区.。

优点

解决了 忙则等待问题。

缺点
  • 违背 “空闲让进”
  • 违背“有限等待”
  • 会导致“饥饿”现象，即二者互相谦让（设置自己的状态后，检查对方的状态，如果对方状态为TRUE，则一直循环等待）
代码
//        Pi进程
        flag[i] = TRUE;//进入区
        while (flag[j]);//进入区
        //临界区
        flag[i] = FALSE;  //退出区
        //剩余区

//        Pj进程
        flag[j] = TRUE;//进入区
        while (flag[i]);//进入区
        //临界区
        flag[j] = FALSE;  //退出区
        //剩余区
算法4：Peterson`s Algorithm
思想

为了防止两个进程为进入临界区而无限期等待，又设置了变量 turn，每个进程在先设置自己的标志后再设置 turn标志。这时，再同时检测进程状态标志和允许进入标志，以便保证两个进程同时要求进入临界区时，只允一个进程进入临界区。

具体如下:考虑进程Pi，一旦.设置flag[i] =true，就表示它想要进入临界x，同时turm=j,此时若进程Рj已在临界区中，符合进程Pi的 while循环条件，则Pi不能进入临界区,若pj不想要进入临界区，即 flag[j]= false，循环条件不符合，则Pi可以顺利进入,反之亦然。

本算法的基本思想是算法一和算法三的结合。利用flag 解决临界资源的互斥访问，而利用turn解决“饥饿”现象。

优点

遵循了：

  • 空闲让进
  • 忙则等待
  • 有限等待

利用flag 解决临界资源的互斥访问，而利用turn解决“饥饿”现象。

缺点
  • 违背了让权等待原则
代码
//        Pi进程
        flag[i] = TRUE;//进入区
        turn = j;//进入区
        while (flag[j] && turn == j);//进入区
        //临界区
        flag[i] = FALSE;  //退出区
        //剩余区

//        Pj进程
        flag[j] = TRUE;//进入区
        turn = i;//进入区
        while (flag[i] && turn == i);//进入区
        //临界区
        flag[j] = FALSE;  //退出区
        //剩余区
四种方法的对比
比较1.单标志法2.双标志法先检查3.双标志后检查4.peterson`s Algorithm
解决使用公共变量的方法解决互斥访问解决“交替进入问题”解决“同时进入”（忙则等待）问题解决互斥和“饥饿”问题
缺点违背“空闲让进”违背“忙则等待”违背“空闲让进”和”有限等待“，会产生饥饿现象违背“让权等待”

硬件实现方法

计算机提供了特殊的硬件允许对一个字中的内容进行检测和修正，或对两个字的内容进行交换等。通过硬件支持实现临界段问题的方法称为低级方法，或称元方法。

后面习题里有对PV操作的描述为 低级进程通信源语

中断屏蔽方法

利用“开/关中断指令”实现

优点

简单、高效
缺点：不适用于多处理机；由于开关中断权限很大，只适合操作系统的内核进程，不适用于用户进程；违背让权等待原则。

硬件指令方法
TestAndSet指令（TS、TestAndSetLock、TSL）

TSL指令使用硬件实现，执行过程中不允许被中断

优点

实现简单；适用于多处理机环境

缺点

违背让权等待原则

TestAndSet实现逻辑
//布尔型共享变量lock表示当前临界区是否被加锁
//true表示已加锁
bool TestAndSet(bool *lock){
	bool old = *lock;   //old用于存放lock原来的值
	*lock = true;     //无论之前是否已加锁，都将lock设为true
	return old;	// 返回old原来的值
}
TSL实现互斥
while(TestAndSet(&lock)){	//检查并上锁
	//临界区代码
	lock = false;	//解锁
	//剩余区代码
}
Swap指令

Swap指令使用硬件实现，执行过程中不允被中断。

优点

实现简单；适用于多处理机环境

缺点

违背让权等待原则

实现逻辑
Swap(bool *a, bool *b){
	bool temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
实现互斥
bool key = true;
while(key==true){
	Swap(&lock,&key);
}
//临界区代码
lock = false;
//剩余区代码
硬件方法的缺点

适用于任意数目的进程，而不管是单处理机还是多处理机:简单、容易验证其正确性。

可以支持进程内有多个临界区，只需为每个临界区设立一个布尔变量。

硬件方法的缺点

进程等待进入临界区时要耗费处理机时间，不能实现让权等待。

从程中随机选择个进入临界区，有的进程可能一直选不上，从而导致“饥饿”现象。

2.3.3 互斥锁

解决临界区最简单的工具就是互斥锁( mutex lock )。一个进程在进入临界区时应获得退出临界区时释放锁。

函数 acquire()获得锁，而函数release()释放锁。

每个互斥锁有一个布尔变量 available，表示锁是否可用。如果锁是可用的，调用acqirue成功，且锁不再可用。当一个进程试图获取不可用的锁时，会被阻塞，直到锁被释放。

acquire(){
    while(!available);//忙等待
    available = false;//获取锁
}
release(){
    available = true;//释放锁
}
  1. acquire()或release()的执行必须是原子操作，因此互斥锁通常采用硬件机制来实现。
  2. 互斥锁的主要缺点是忙等待。
  3. 互斥用于多处理器系统，一个线程可以在一个处理器上等待，不影响其他线程的执行。

2.3.4 信号量——重点

信号量机制是一种功能较强的机制，可用来解决互斥与同步问题，它只能被两个标准wait(S)和l signal(S)访间，也可记为“Р操作”和“V操作”。

原语 是指完成某种功能且不被分割、不被中断执行的操作序列，通常可由硬件来实现

1.整型信号量

整型信号量被定义为一个用于表示资源数目的整型量S， wait和 signal 操作可描述为

wait(S){
    while(S<0);//忙等待 -- 违背了 ”让权等待“
    S=S-1;
}
signal(S){
    S=S+1;
}
2.记录型信号量

记球型信号量机制是一种不存在“忙等”现象的进程同步机制。

除了需要一个用于代表资源数目的整型变量value外，再增加一个进程链表L，用于链接所有等待该资源的进程。记录型信号量得名于采用了记录型的数据结构。

记录型信号量可描述为

typedef struct{
    int value;//代表资源数目
    struct process *L;//等待队列
} semaphore;

wait(S) 和 signal(S) 如下

void wait(semaphore S){//相当于申请资源
    S.value --;// 申请现有资源
    if(S.value < 0){
        //把该进程加入到S.L 等待队列里
        block(S.L);//使进程 从运行态 进入 阻塞态；放弃处理机，并插入到等待队列
        //这句说明 其遵循了“让权等待”
    } 
}

void signal(semaphore S){//相当于释放资源
    S.value ++;//释放占有的资源
    if(S.value <= 0){//如果 等待队列里有等待的进程，则取出队首的进程
        wakeup(P);
    }
}
3.利用信号量实现同步

信号量机制能用于解决进程间的各种同步问题。设S为实现进程Р1，P2同步的公共信号量，初值为0。进程P:中的语句y 要使用进程P，中语句x的运行结果，所以只有当语句x执行完成之后语句y才可以执行。其实现进程同步的算法如下:

同步的信号量不一定是0，根据情况需要用户可自己确定。

semaphore S=0;//初始化信号量
P1(){
    x;//语句x
    V(S);//告诉P2 ，x已经完成
    ...
}
P2(){
    ...
    P(S);//检查x是否已经完成
    y;//检查无误运行y语句
    ...
}
4.利用信号量实现进程互斥

设S为实现进程P1，P2互斥的信号量，。**由于每次只允许一个进程进入临界区，所以初始值S设为1。**只需把临界区置于P(S)和V(S)之间，即可实现两个进程对临界资源的互斥访问。

算法如下：

互斥信号量的初识值一般为1，不会改变。

semaphore S = 1;
P1(){
    ...
    P(S);//加锁
    //p1临界区
    V(S);//解锁
}
P2(){
    ...
    P(S);//加锁
    //p2临界区
    V(S);//解锁
}
  • 不同的临界资源需要设置不同的互斥信号量
  • PV操作必须成对出现
5.利用信号量实现前驱关系

信号量也可用描述程序之间的前驱关系。图2.10给出了一个前驱图,具中S1,S2,S3,…,S。是最简单的程序段(只有-条语句)。为使各程序段能止佣执行,应设置若干初始值为“0”的信号量。例如，为保证S1→Sz,S1→S:的前驱关系，应分别设置信号量al, a2。同样，为保让S2→S4, S2→S5, S3→S6, S4→S6, S5→S6，应设置信号量bl, b2,c,d, e。

在这里插入图片描述

semphore a1=a2=b1=b2=c=d=e=0;//初始化信号量
S1(){
    ...;
    V(a1);
    V(a2);//S1已经运行完成
}
S2(){
    P(a1);//检查S1是否运行完成
    ...;
    V(b1);
    V(b2);//S2已经运行完成
}
S3(){
    P(b1);//检查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是否运行完成
}
6.分析进程同步和互斥问题的方法步骤

  1. 关系分析。

    找出进程数，并分析之间的同步和互斥关系。

  2. 整理思路。

    根据进程的流程确定P操作、V操作的大致顺序。

  3. 设置信号量

    根据上面两步，设置需要的信号量，确定初值，完善整理。

2.3.5 管程

管程的引入是为了解决临界区分散所带来的管理和控制问题。在没有管程之前，对临界区的访问分散在各个进程之中，不易发现和纠正分散在用户程序中的不正确使用P,V操作等问题。管程将这些分散在各进程中的临界区集中起来，并加以控制和管理，管程一次只允许一个进程进入.管程内，从而既便于系统管理共享资源，又能保证互斥。

信号量机制中：编写程序困难，易出错。所以产生了进程同步工具——管程。管程的特性保证了进程互斥，无须程序员自己实现互斥，从而降低了死锁发生的可能性，同时管程提供了条件变量可以让程序员灵活地实现进程同步。

利用共享数据结构抽象地表示系统中的共享资源，而把对该数据结构实施的操作定义为一组过程。进程对共享资源的申请、释放等操作，都通过这组过程来实现，这组过程还可以根据资源情况，或接受或阻塞进程的访问，确保每次仅有一个进程使用共享资源，这样就可以统一管理对共享资源的所有访问，实现进程互斥。这个代表共享资源的数据结构，以及由对该共享数据结构实施操作的一组过程所组成的资源管理程序，称为“管程”（monitor）。

管程由4部分组成：

  • 管程的名称
  • 局部于管程内部的共享数据结构说明。
  • 对该数据结构进行操作的一组过程（或函数）。
  • 对局部于管程内部的共享数据设置初始值的语句。

描述举例如下：

monistor Demo{//1，定义一个名称为Demo的管程
    // 2. 定义共享数据结构，对应系统中的某种共享资源
    共享数据结构S;
    // 4. 对共享数据结构初始化的语句
    init_code(){
        S=5;//初始资源为5
    }
    //3. 过程 1
    take_away(){
        对共享数据x的一系列处理;
        S--；//可用资源减一
        ...;
    }
    // 过程2 :归还一个资源
    give_back(){
        对共享数据结构x的一系列处理;
        S++;//可用的资源+1
    }
    
}
  • 管程把对共享资源的操作封装起来
  • 每次仅允许一个进程进入管程，从而实现进程互斥
条件变量

当一个进程进入管程后被阻塞，且到阻塞的原因解除时，在此期间，如果该进程不释放管程,那么其他进程无法进入管程。为此，将阻基原因定义为条件变量condition
通常,**一个进程被阻塞的原因可以有多个，因此在管程中设置了多个条件变量。**每个条件变量保存了一个等待队列,用于记录因该条件变量而阻塞的所有进程，对条件变量只能进行两种操作
即wait和 signal。

x.wait:当x对应的条件不满足时，正在调用**管程的进程调用x.wait将自己插入x条件的等待队列，并释放管程。**此时其他进程可以使用该管程。

x.signal: x对应的条件发生了变化，则调用x.signal，唤醒一个因x条件而阻塞的进程。

在这里插入图片描述
条件变量和信号变量的比较

相似点：条件变量的wait/signal操作类似于信号量的P/V操作，可以实现进程的阻塞唤醒。

不同点：

  • 条件变量是没有值的，仅实现了”排队等待“功能；而信号量是”有值“的。
  • 信号量的值反映了剩余资源数，在管程中，剩余资源数用共享数据结构记录。

错题

在这里插入图片描述

2.3.6 经典同步问题

1.生产者消费者问题

问题描述

一组生产者进程和一组消费者进程共享一个初始为空、大小为 n 的缓冲区，只有缓冲区没满时，生产者才把消息放入缓冲区，否则必须等待；只有缓冲区不空时，消费者才能从中读取消息，否则必须等待。由于缓冲区是临界资源，它只允许一个生产者放入消息，或一个消费者从中取出消息。

分析

  1. 关系分析：
    生产者和消费者对缓冲区的访问属于互斥关系，而针对**“消息”则生产者和消费者属于协作关系**，只有生产者生产了消息，消费者才能使用消息，因此又是同步关系。
  2. 思路整理：
    两组进程存在互斥和同步关系，也就是要解决互斥和同步PV的操作的位置。
  3. 信号量设置：
    设置一个 mutex 为互斥信号量，用于控制互斥访问缓冲池，初值设为 1；信号量 full 用于记录当前缓冲池中的“满”缓冲区数，初值为 0；信号量 empty 用于记录当前缓冲池中“空”的缓冲区数，初值为 n；

进程描述如下：

seamphore mutex=1;    //临界区互斥信号量
seamphore empty=n;  //空闲缓冲区
seamphore full=0;    // 缓冲区初始化为空
producer(){                // 生产者进程
	while(1){
		produce an item in nextp;   // 生产数据
		P(empty);（用什么，p一下）// 获取空缓冲区单元
		P(mutex);（互斥夹紧）  // 进入临界区
		add nextp to buffer;  （行为）//将数据放入缓冲区
		V(mutex);（互斥夹紧）  // 离开临界区，释放互斥信号量
		V(full);（提供什么，V一下）//满缓冲区数加1
	}
}
consumer(){      //消费者进程
	while(1){
		P(full);    //获取满缓冲区单元
		P(mutex);  //进入临界区
		remove an item from buffer;  // 从缓冲区取出数据
		V(mutex);    // 离开临界区，释放互斥信号量
		V(empty);    // 空缓冲区数加 1
		consume the item;   //消费数据
	}
}

注意：

  • 加锁信号量的顺序不能打乱，否则容易出现死锁

    首先P获取资源，最后临界区的前一行使用P(mutex)对临界区的访问互斥，如果P(mutex)在申请资源的前面，可能会导致死锁。

  • 释放资源的顺序没有严格的要求。

多生产者和多消费者问题

问题描述

桌子上有一个盘子，每次只能向其中放入一个水果。爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，儿子专吃盘子中的橘子，女儿专等吃盘子中的苹果。只有盘子为空时，爸爸或妈妈才可以向盘子中放一个水果；仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取出。

分析

  1. 关系分析
    爸爸和妈妈是互斥关系，爸爸和女儿、妈妈和儿子是同步关系，而且这两对进程必须连起来，儿子和女儿之间没有互斥和同步关系，因为他们是选择条件执行。
  2. 思路整理
    这里一共由4个进程，可抽象为两个生产者和两个消费者被连接到大小为1的缓冲区上。
  3. 信号设置
    信号量 plate 表示互斥信号量，用于确定是否可以往盘子中放水果，初值为 1 表示允许放入一个；信号量 apple 表示盘中是否还有苹果，初值为 0表示没有不许取；orange 表示盘中是否有橘子，初值同样为 0，orange=1 表示盘子中由橘子允许取。

代码如下：

semapore plate=1,apple=0,orange=0;
dad(){
	while(1){
		prepare an apple;
		P(plate);   //互斥向盘中取、放水果
		put the apple on the plate;  //向盘中放苹果
		V(apple);   // 允许取苹果
	}
}
mom(){
	while(1){
		prepare an orange;
		P(plate);
		put the orange on the plate;
		V(orange);
	}
}
son(){
	while(1){
		P(orange);  //互斥从盘中取橘子
		take an orange from the plate;
		V(plate);  //允许向盘中放、取水果
		eat the orange;
	}
}
daughter(){
	while(1){
		P(apple);
		take an aplle from the plate;
		V(plate);
		eat the apple;
	}
}

注意：

因为盘子的数量为1 ，故去除对盘子的互斥之后依然可以互斥访问（不绝对）。盘子的容量大于1，必须要设置互斥信号量。

提供思路：

遇到类似生产者消费者问题时，仿照处理 同步与互斥的关系

2.读者写者问题

问题描述：

有读者和写者两组并发进程，共享一个文件，当两个或两个以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程同时访问共享数据时则可能导致数据不一致的错误，因此：
① 允许多个读者可以同时对文件执行读操作；
② 只允许一个写者往文件中写信息；
③ 任一写者在完成写操作之前不允许其他读者进程或写者工作；
④ 写者执行写操作前，应让已有的读者和写者全部退出。

分析

  1. 关系分析，读者和写者互斥的，写者和写者互斥，读者和读者之间不互斥。
  2. 思路整理：两个进程，读者和写者。由于写者和其他进程都互斥，因此可用互斥信号量的P操作、V操作解决；读者则较为复杂，与写者互斥的同时，又要与其他读者同步，需要一个计数器用于判断当前是否有读者读文件：当有读者时，写者不能写文件，此时读者一直占用文件直到退出，写者才可以写文件；同时，不同读者对计数器的访问也是互斥的。
  3. 信号量设置：设置 count 信号量为计数器，初值为 0；mutex 为互斥信号量，用于保护更新 count 变量时的互斥；互斥信号量 rw 用于保证读者和写者互斥访问。

第一种算法

	int count=0;//记录当前读者的数量 （确保读者退出）
	semaphore mutex=1;//用于保护更新count变量时的互斥（解决多读者访问）
	semaphore rw=1;//用于保证读者和写者互斥地访问文件
	writer(){
		while(1){
			P(rw);   // 互斥访问共享文件
			writing
			V(rw); // 释放共享文件
		}
	}
	reader(){
		while(1){
			P(mutex);   // 互斥访问 count 变量
			if(count==0)  // 当第一个读进程读共享文件时
				P(rw)  // 阻止写进程
			count++;
			V(mutex);   // 释放互斥变量 count
            
			reading;
            
			P(mutex); 
			count--;
			if(count==0)   // 当最后一个读进程读完共享文件
				V(rw);  // 允许写进程写
			V(mutex);
		}
	}

此种方式下，可能导致写进程长时间等待甚至出现“饿死”的情况。改变上面这种读进程优先，让写进程优先，需要再增加一个信号量，并在上面的 writer() 和 reader() 函数中各增加一对PV操作

第二种算法（读写公平法）

	int count=0;  //记录当前读者的数量 （确保读者退出）
	semaphore mutex=1; //用于保护更新count变量时的互斥（解决多读者访问）
	semaphore rw=1;  //用于保证读者和写者互斥地访问文件
	semaphore w=1; // 实现写者优先（解决写进程饥饿问题）
	writer(){
		while(1){
			P(w);  // 在无写进程请求时进入
			P(rw);   // 互斥访问共享文件
			writing
			V(rw); // 释放共享文件
			V(w);   // 恢复对共享文件的访问
		}
	}
	reader(){
		while(1){
			P(w);  
			P(mutex);   // 互斥访问 count 变量
			if(count==0)  // 当第一个读进程读共享文件时
				P(rw)  // 阻止写进程
			count++;
			V(mutex);   // 释放互斥变量 count
			V(w);
            
			reading;
            
			P(mutex); 
			count--;
			if(count==0)   // 当最后一个读进程读完共享文件
				V(rw);  // 允许写进程写
			V(mutex);
		}
	}

提供思路：

这里 对count变量的检查与赋值不能一气呵成导致一些错误，如果需要“一气呵成”自然想到使用 互斥信号量

这里解决 读读不互斥的问题，

同时提供一种类似多个读者的互斥的解决方案，即使用count进行解决，

  • 第一个进程：进行加锁

  • 最后一个进程：解锁

算法给出条件：

if(count==0)

3.哲学家进餐问题

问题描述

一张圆桌上坐着5名哲学家，每两名哲学家之间的桌子上摆着一根筷子，两根筷子之间是一碗米饭。哲学家倾注毕生精力于思考和进餐，哲学家思考时不影响其他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子——一根一根地拿起。若筷子已在他人手上，则需要等待。饥饿地哲学家只有同时拿到了两根筷子才能开始进餐，进餐完毕，放下筷子继续思考。

分析

  1. 关系分析：5 名哲学家与左右邻座对其中间的筷子的访问时互斥关系。
  2. 思路整理：显而易见，5 个哲学家对应5 个进程，问题解决的关键就是如何让一名哲学家拿到左右两根筷子而不造成死锁或饥饿现象。
    1. 解决方法有两个：
      1. 一是让他们同时拿两根筷子；
      2. 二是对每名哲学家的动作制定规则，避免饥饿或死锁现象的发生。
  3. 信号量设置：互斥信号量数组 chopstick[5]={1,1,1,1,1}，用于对 5 个筷子的互斥访问；哲学家编号顺序：0~4，哲学家 I 左边筷子的编号为 i，哲学家右边筷子的编号为(i+1)%5。

第一种算法（同时拿两根筷子）

	semaphore chopstick[5]={1,1,1,1,1};//定义信号量数组，并初始化i号哲学家的进程
	Pi(){
		do{
			P(chopstick[i]);  //取左边筷子
			P(chopstick[(i+1)%5]);// 取右边筷子
			eat;
			V(chopstick[i]);  //放回左边筷子
			V(chopstick[(i+1)%5]);// 放回右边筷子
			think;
		}while(1);
	}

此算法存在的问题就是，当5名哲学家都想要进餐并分别拿起左边的筷子时，所有的筷子将被拿光，等到他们再想拿起右边的筷子时，就会发生全被阻塞，出现死锁。

若要避免此种情况，可以增加限制条件(第二种方法)，如：

  • 至多允许4名哲学家同时进餐；
  • 仅当一名哲学家左右两边筷子都可以用时，才允许他抓起筷子；
  • 对哲学家顺序编号，奇数号哲学家先拿起左边筷子，然后拿起右边的，而偶数哲学家相反。

第二种算法（加限制条件）

	semaphore chopstick[5]={1,1,1,1,1};//定义信号量数组，并初始化i号哲学家的进程
	semaphore mutex=1;
	Pi(){
		do{
			P(mutex);  // 在取筷子前获得互斥量
			P(chopstick[i]);  //取左边筷子
			P(chopstick[(i+1)%5]);// 取右边筷子
			V(mutex);  // 释放取筷子的信号量
			eat;
			V(chopstick[i]);  //放回左边筷子
			V(chopstick[(i+1)%5]);// 放回右边筷子
			think;
		}while(1);
	}

提供思路：

当遇到类似哲学家问题时，首先可

  • 定义信号量数组

  • 增加限制条件，避免死锁问题

4.吸烟者问题

问题描述

假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但要卷起一支烟，抽烟者需要三种材料：烟草、纸和胶水。三个抽烟者中，第一个拥有烟草，第二个拥有纸，第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次将两种材料放到桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者一个信号告诉已完成，此时供应者就会将另外两种材料放到桌子上，循环反复如此。

分析

  1. 关系分析：供应者与三个抽烟者分别是同步关系。由于供应者无法同时满足两个或以上的抽烟者，三个抽烟者对抽烟这个动作互斥。
  2. 思路整理：显然有4个进程，供应者作为生产者向三个抽烟者提供材料。
  3. 信号量设置：信号量 offer1，offer2，offer3 分别表示烟草和纸组合的资源、烟草和胶水组合的资源、纸和胶水组合的资源，信号量 finish 用于互斥进行抽烟动作。

代码如下：

	int random;  // 存储随机数
	semaphore offer1=0;
	semaphore offer2=0;
	semaphore offer3=0;
	semaphore finish=0;
	process P1(){
		while(1){
			random=a random num;
			random=random%3;
			if(random==0)
				V(offer1);  // 提供烟草和纸
			else if(random==1)
				V(offer2);  // 提供烟草和胶水
			else
				V(offer3); //提供纸和胶水
			put on ;  // 将材料放在桌子上
			P(finish);
		}
	}
	process P2(){
		while(1){
			P(offer3);
			working;  // 拿起纸和胶水，卷成烟，抽掉
			V(finish);
		}
	}
	process P3(){
		while(1){
			P(offer2);
			working;  // 拿起烟草和胶水，卷成烟，抽掉
			V(finish);
		}
	}
	process P4(){
		while(1){
			P(offer1);
			working;  // 拿起纸和烟草，卷成烟，抽掉
			V(finish);
		}
	}

提供思路：

可以生产多个产品的单生产者问题提供思路

“轮流让各个吸烟者吸烟”，用整形变量i实现“轮流过程”

沐岚浩
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统实验（二）生产着消费者模型C++代码实现
Neymessi_JR的博客
07-09 836
问题描述：以生产者消费者模型为基础，创建一个控制台进程，在该进程中创建多个写者线程和多个读者线程（分别模拟生产者和消费者）。1. 写者线程写入数据，然后将数据放置在一个空缓冲区中供读者线程读取。2. 读者线程从缓冲区中获得数据，然后释放缓冲区。3. 当写者线程写入数据时，如果没有空缓冲区可用，那么写者线程必须等待读者线程释放出一个空缓冲区。4. 当读者线程读取数据时，如果没有满的缓冲区，那么读入线程将被阻塞，直到新的数据被写进去。本实验共有以下两个小部分组成：1、互斥信号量Mutex
进程同步互斥之生产者与消费者问题
jungleirim的博客
10-09 1386
生产者消费者问题是一个互斥、同步的综合问题。对于初学者来说最难的是发现题目中隐含的两对同步关系。有时候是消费者需要等待生产者生产，有时候是生产者要等待消费者消费，这是两个不同的“一前一后问题”，因此也需要设置两个同步信号量。
操作系统：进程同步与互斥及如何解决与消费者生成者，吸烟者，哲学家问题
weixin_43967582的博客
01-12 2864
一、进程同步、进程互斥 1.1 什么是进程同步 进程具有异步性的特征。异步性是指，各并发执行的进程以各自独立的、不可预知的速度向前推进。 看一个例子：进程通信——管道通信 读进程和写进程并发地运行，由于并发必然导致异步性，因此“写数据”和“读数据”两个操作执 行的先后顺序是不确定的。而实际应用中，又必须按照“写数据->读数据”的顺序来执行的。 如何解决这种异步问题，就是 “进程同步”所讨论的内容。 同步亦称直接制约关系，它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调它们
王道考研操作系统笔记
最新发布
m0_64282577的博客
05-25 958
操作系统复习详细笔记
操作系统 记录型信号量实现生产者消费者问题（完整代码）
m0_57089113的博客
11-26 2089
用信号量模拟生产者-消费者问题的过程。生产者和消费者两个线程共享同一个缓冲区，生产者不断向缓冲区中添加产品，消费者从缓冲区中消费产品。要保证缓冲区满了之后生产者不能再继续添加产品，需要等消费者至少消费一个产品之后生产者才能继续生产产品；缓冲区空了之后消费者不能再消费产品，需要等生产者至少生产一个产品之后消费者才能继续消费产品。向缓冲区中添加产品和从缓冲区消费产品需要互斥操作保持同步。生产者需要等待缓冲区有空间才能生产产品；消费者也不能在缓冲区为空时消费产品。这两个过程需要信号量来通知进行。
进程同步问题之生产者-消费者问题
liangcha_xyy的博客
03-17 2036
3.17
王道操作系统网课笔记合集
jtwqwq的博客
12-14 1585
学习自计算机科学单本&b站王道课程。
【王道考研-操作系统】进程管理（学习笔记）
wmh的博客
12-07 2858
程序：是静态的，就是个存放在磁盘里的可执行文件进程：是动态的，是程序的一次执行过程同一个程序多次执行会对应多个进程操作系统需要对各个并发运行的进程进行管理，但凡管理时所需要的信息，都会被放在PCB中。PCB是进程存在的唯一标志，当进程被创建时，操作系统为其创建PCB，当进程结束时，会回收其PCB。一个进程实体（进程映像）由PCB、程序段、数据段组成。进程是动态的，进程实体（进程映像）是静态的。进程实体反应了进程在某一时刻的状态，类似快照。进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位。动态
超详解“生产者消费者问题”【操作系统】
热门推荐
m0_59731459的博客
06-06 1万+
超详解“生产者消费者问题”【操作系统】
pv操作题目笔记
weixin_63233998的博客
10-23 2382
PV操作在进程同步中通常指的是信号量（Semaphore）操作。信号量是一种用于控制多个并发进程或线程之间的同步和互斥访问的同步工具。PV操作通常涉及两个基本操作：P操作（wait操作）和V操作（signal操作）。P操作（等待操作）：也称为减操作，用于获取或等待信号量。如果信号量的值大于0，则执行P操作将信号量的值减1，并允许进程继续执行。如果信号量的值已经为0，那么执行P操作的进程将被阻塞，直到有其他进程执行V操作来释放资源。V操作（释放操作）：也称为增操作，用于释放信号量。
生产者-消费者问题（操作系统）
公众号：风景邮递Yuan的博客
11-02 8611
一个生产者、一个消费者、一个缓冲区的问题； 一个生产者、一个消费者、n个缓冲区的问题； k个生产者、m个消费者、n个缓冲区的问题；
【操作系统】第九章——互斥与同步
欢迎来到我的世界
10-12 1389
引入临界区的概念，进而对于临界区加锁来实现进程/线程访问互斥，介绍了三种方式实现锁
操作系统 - 同步互斥
kiku
01-26 635
并发进程的正确性 独立进程 不和其他进程共享资源或状态 确定性 ==> 输入状态决定结果 可重现 ==> 能够重现起始条件 调度顺序不重要 并发进程 在多个进程间有资源共享 不确定性 不可重现 并发进程的正确性 执行过程是不确定性和不可重现的 程序错误可能是间歇性发生的 进程并发执行的好处 进程需要与计算机中的其他进程和设备进行协作 好处1：共享资源 多个用户使用同一台计算机 银行账号存款余额在多台ATM机操作 机器人上的嵌入式系统协调手臂和手的动作 好处2：加速 I/O操作
同步与互斥的基本原理
云（存储），松（耦合）
03-11 3398
在本科学习过《操作系统》的同志们都知道，现代操作系统提供了一个并发控制环境，即系统中同时活动着的多个不同的进程，这些进程共享同一个CPU、内存或 I/O设备。特别是对于Linux这种世界上最先进的操作系统来说，其多任务、多用户、分时实时混合的性质决定了多个进程在某种程度上彼此依赖或相互制约的关系，这些关系我们叫“并发关系”，按其性质可以分为同步（synchronization）和互斥（mutual
同步互斥发展历史算法
数据笔记
02-20 1348
1、单标志法：P0进程： P1进程：while（turn ！= 0）； while（turn ！= 1）；critical section critical sectionturn = 1； turn = 0；remainder section remainder section缺点：必须交替运行掌握软件实现互斥同步的发展过程2、双标志法先检查：第二章进程管理Pi进程： Pj进程：while（fl...
操作系统 --经典同步问题之生产者-消费者（六）
starchao
03-18 4153
一、生产者-消费者问题 问题描述： 一组生产者进程和一组消费者进程共享一个初始为空、大小为n的缓冲区 只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待 只有缓冲区不为空，消费者才能从中取出产品，否在必须等待 缓冲区是临界资源，各进程必须互斥地访问 问题分析： 1、关系分析 生产者和消费者对缓冲区的访问是互斥关系，同时生产者和消费者又是一个协作的关系，只有生产者生产之后...
操作系统进程同步问题大题
C_ChunJin的博客
12-06 5452
进程同步问题（主要是PV问题） 先了解基本概念 ​ 因为在多道环境下，进程之间是并发执行的，而程序之间为了抢夺各种资源，相互制约，如果不对这种制约加以协调，操作系统就很容易进入死锁状态，影响进程们的运行。所以我们需要引入进程同步的概念，来协调这种进程之间的制约关系。 临界资源 虽然系统中的资源可以给所有的进程共享，但是对于某些资源而言，同时只能提供给一个进程，这样的资源叫做临界资源，当临界资源已经被占用的时候，我们该如何协调想要访问这个资源的进程之间的关系呢？为此，我们将访问临界资源的过程分为了四个步骤
操作系统-------进程同步和互斥(例子：哲学家问题)
ZJE
09-21 5045
一，进程同步 进程异步：各自并发执行的进程由于各自是独立的，所以会以不可预知的速度先前推进，就是你不能提前预料到它们将来是怎么执行的。 进程同步：它是指为了完成某个任务而建立起的两个或多个进程，这些进程在完成任务时，需要协调它们之间的执行顺序。 例如：进程通信的管道通信： 读进程必须要等到写进程写满管道才能开始读，写进程也必须要等到读进程读完管道数据才能开始写。这就是进程同步的一个例子。 二，进程互斥 临界资源：我们把同一时间内只允许一个人进程使用的资源叫做临界资源。例如打印机，摄像头。
线程（进程）的同步与互斥实例
小张的专栏
09-20 3779
1.有一个队列，线程1负责从网络接收分组，并将收到的分组放到队列尾，然后再次从网络中接收下一个到达的分组，并进行同样的队列操作。线程2从此队列头中取出一个分组进行处理，处理完毕后，再次从队列中取出一个分组进行处理，处理完毕后再次从队列头取出下一个分组进行处理，两个线程都以无限循环的方式工作，因此该队列为临时资源，若队列不为空，线程2才应该开始循环处理，否则需要等待，显然如果线程2不停的检测队列是否...
进程同步与互斥：操作系统中的关键协作
操作系统通过两种主要的方式——直接作用（同步）和间接作用（互斥）来管理进程间的交互。 **直接作用（同步）**： 同步是指进程间有意识地安排的交互，目的是确保它们按照特定的时序关系执行。例如，司机P1和售票...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值