【操作系统】互斥：软件解决方法

最新推荐文章于 2023-04-16 23:20:54 发布
最新推荐文章于 2023-04-16 23:20:54 发布
阅读量918 收藏 2
点赞数 2
分类专栏： 操作系统 文章标签： 操作系统 多线程 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tzs1328540878/article/details/115037052
版权

互斥：软件解决方法

算法一

算法思路

预留一个全局内存区域，并标记为turn。进程（P0或P1）想进入它的临界区执行时，要先检查turn的内容。若turn的值等于进程号，则该进程可以进入它的临界区；否则该进程被强制等待。等待进程重复地读取turn的值。直到被允许进入临界区。这一过程称为忙等待（busy waiting） 或 自旋等待（spin waiting），进程在获得临界区的访问权并完成访问后，必须为另一个进程更新turn的值。

P0 :

while(turn != 0) {/* busy waiting */}
/* critical section */
turn = 1;

P1 :

while(turn != 1) {/* busy waiting */}
/* critical section */
turn = 0;
缺陷
  1. 进程必须严格交替（P0临界区执行完后才会更新turn值，使得P1跳出忙等待状态，同理P0也需等待P1临界区执行完）使用它们的临界区，因此执行的步调由两个进程较慢的进程决定。
    例如：若P0在1小时内仅使用临界区1次，而P1要以1000次/小时的速率使用临界区，则P1就必须适应P0的节奏。
BUG
  1. 若一个进程终止，则另一个进程就会被永久阻塞。无论进程是在临界区内终止还是在临界区之外终止，都会发生这种情况。
    例如：P0在执行到第二行代码（临界区内）时终止，此时turn值为0且此后不会被更新，因此P1将永久处于忙等待状态；P0在执行到第三行代码（临界区外）时终止，此时turn值为1，于是P1进入临界区，执行完后便将turn值置为0，而P0进程因为终止便不会再更新turn值，因此P1将永久处于忙等待状态。

算法二

算法一仅由一个共享的仲裁变量去实现进程间的互斥，因此进程之间必须严格交替执行，进程之间的依赖关系过强

算法二为每一个进程都配备了专门的”钥匙“，这里定义一个bool数组flag，flag[0]与P0关联，flag[1]与P1关联，每个进程可检查但不能改变另一个进程的flag值

算法思路

一个进程要进入临界区时，它会周期性地检查另一个进程的flag，直到其值为false，这表明另一个进程不在临界区内。检查进程立即设置自己的flag为true，进入自己的临界区。离开临界区时，将自己的flag设置为false。

P0 :

while(flag[1]) {/* busy waiting */}
flag[0] = true;
/* critical section */
flag[0] = false;

P1 :

while(flag[0]) {/* busy waiting */}
flag[1] = true;
/* critical section */
flag[1] = false;
进步
  1. 若一个进程在临界区外终止，包括设置flag代码时，则另一个进程不会被阻塞。
    例如：当P1在执行完第4行代码后终止，此后flag[1]将一直保持false，因此P0将永远不会进入忙等待状态即说明其不会被阻塞
BUG
  1. 若一个进程在临界区内，或在进入临界区之前已将flag设置为true时终止，则另一个进程就会永久阻塞
  2. 没有保证互斥！！
    例如：P1执行完第4行代码后，于是P0跳出忙等待状态，但P0还未来得及执行第二行代码（将flag[0]设置为true）P1便又进入了临界区，随后P0也进入临界区，便产生了访问冲突

下面采用Java多线程编程模拟算法二并验证BUG-2

package TEST;

public class Multithreading {
    public static void main(String[] args) {
        Process p0 = new Process("P0", 0, 0);
        Process p1 = new Process("P1", 1, 1);
        p0.start();
        p1.start();
    }
}
class Process extends Thread {
    private static int var;
    private int var_right;
    private static boolean[] flag = new boolean[2];
    private String name;
    private int cnt_test = 100;
    private int No;
    private int No_other;

    public Process(String name, int No, int var_right) {
        super();
        this.name = name;
        this.No = No;
        this.var_right = var_right;
        this.No_other = (No + 1) % 2;
    }

    public void run() {
        for(int i = 0; i < cnt_test; i++) {
            while(flag[No_other]) { /* busy waiting */ }
            flag[No] = true;
            /*--- critical section begin---*/
            var = var_right;
            System.out.println(this.name + ":" + (var == var_right? var : "##"));
            /*--- critical section end---*/
            flag[No] = false;
        }
    }
}

两个线程任务是，将公共变量var赋值为本线程对应正确的值var_right，并输出当前var的值，若两个线程保证互斥则var总是等于var_right（Condition ‘var == var_right’ is always ‘true’）即不会输出##

运行结果如下：

P0:0
P1:##
P0:0
P1:1
P0:0
P1:##
P0:0
P1:##
P0:0
P0:0
P0:0
P1:##
P1:##
P0:0
P1:1
P1:1
P0:##
P1:1
P1:1
P1:1
P0:##
P0:##
P1:1
P0:0
P1:1
P1:##
P0:0
P1:##
P0:0
P1:1
P1:##
P0:0
P1:1
P0:##
P1:1
P0:##
P1:1
P1:##
P0:0
P0:0
P1:##
P0:0
P1:1
P1:##
P0:0
P0:0
P1:##
P0:0
P1:1
P1:##
P0:0
P1:##
P0:0
P1:1
P1:##
P0:0
P1:##
P0:0
P1:1
P0:0
P1:1
P1:##
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P1:1
P0:0
P1:1
P0:0
P0:0
P1:1
P1:1
P1:1
P0:0
P1:##
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:##
P0:0
P1:1
P1:##
P0:0
P1:1
P1:##
P0:0
P1:1
P1:##
P0:0
P1:1
P1:1
P1:##
P0:0
P1:1
P1:1
P0:0
P1:##
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:##
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P1:1
P0:##
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:1
P1:##
P0:0
P1:1
P1:##
P0:0
P1:1
P1:1
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0
P0:0

Process finished with exit code 0

可见采用算法二两个线程之间发生了不少次的访问冲突（输出##）

算法三

算法二由于执行速率不匹配的原因，导致两个进程同时处在临界区的位置，所以算法二的方案失败

算法三通过简单地交换两条语句来解决这一问题

算法思路

将控制其他进程持续忙等待的语句提到了检查flag值之前，确保了同一时刻只有一个进程进入临界区

P0 :

flag[0] = true;
while(flag[1]) {/* busy waiting */}
/* critical section */
flag[0] = false;

P1 :

flag[1] = true;
while(flag[0]) {/* busy waiting */}
/* critical section */
flag[1] = false;
进步
  1. 解决算法二造成的访问冲突问题，确保了互斥性
BUG
  1. 与算法二一样，某一进程在临界区内或在设置flag为true时终止，会引起其他进程永久阻塞
  2. 若每个进程在执行while语句前都将flag设置为true，则每个进程都会认为另一个进程已经进入临界区，进而引发死锁
    例如：P0执行完第一行代码后还未来得及执行while语句，P1也执行完了第一行代码，此时flag[0]与flag[1]的值都为true，因此两个进程都无法跳出忙等待的状态，从而造成死锁

下面采用Java多线程编程模拟算法三并验证BUG-2

package TEST;

public class Multithreading {
    public static void main(String[] args) {
        Process p0 = new Process("P0", 0, 0);
        Process p1 = new Process("P1", 1, 1);
        p0.start();
        p1.start();
    }
}
class Process extends Thread {
    private static int cnt_busy_wait = 0;
    private static int var;
    private int var_right;
    private static boolean[] flag = new boolean[2];
    private String name;
    private int cnt_test = 100;
    private int No;
    private int No_other;

    public Process(String name, int No, int var_right) {
        super();
        this.name = name;
        this.No = No;
        this.var_right = var_right;
        this.No_other = (No + 1) % 2;
    }

    public void run() {
        for(int i = 0; i < cnt_test; i++) {
            flag[No] = true;
            while(flag[No_other]) {
                /* busy waiting */
                System.out.println(this.name + " BusyWaiting: " + (++cnt_busy_wait));
                if(cnt_busy_wait > 999) return;
            }
            /*--- critical section begin---*/
            var = var_right;
            System.out.println(this.name + ":" + (var == var_right? var : "##"));
            /*--- critical section end---*/
            flag[No] = false;
        }
    }
}

运行结果如下：

P0:0
P1 BusyWaiting: 1
P1 BusyWaiting: 3
P1 BusyWaiting: 4
P1 BusyWaiting: 5
P0 BusyWaiting: 2
P0 BusyWaiting: 7
P0 BusyWaiting: 8
P0 BusyWaiting: 9
P0 BusyWaiting: 10
P1 BusyWaiting: 6
P1 BusyWaiting: 12
P1 BusyWaiting: 13
P0 BusyWaiting: 11

 ... ...

P1 BusyWaiting: 995
P1 BusyWaiting: 996
P1 BusyWaiting: 997
P1 BusyWaiting: 998
P1 BusyWaiting: 999
P1 BusyWaiting: 1000
P0 BusyWaiting: 967

Process finished with exit code 0

可见结果只被正确输出了一次，此后两线程皆处在忙等待状态，形成死锁

算法四

算法三中，一个进程在设置其状态时是不知道另一个进程的状态的。由于每一个进程坚持要进入临界区，导致死锁发生

算法四在算法三的基础上引入**“谦让”**的机制，在忙等待中随时重设flag，一定程度上避免了死锁发生

算法思路

当出现死锁情况时（两者都进入忙等待状态），P0进程将flag[0]置为false并在该状态延迟1秒，P1便可在这1秒之内跳出忙等待状态，从而避免了死锁的情况

P0 :

flag[0] = true;
while(flag[1])
{
    flag[0] = false;
    delay(1); // dalay 1 sec
    flag[0] = true;
}
/* critical section */
flag[0] = false;

P1 :

flag[1] = true;
while(flag[0])
{
    flag[1] = false;
    delay(1); // dalay 1 sec
    flag[1] = true;
}
/* critical section */
flag[1] = false;
进步
  1. 一定程度的避免了死锁的出现
缺陷
  1. 当两个进程自上而下的语句几乎同时被执行时，则两者都不会进入临界区。严格来说，这不是死锁，因为两个进程执行速率的相对变化会打破这种状况，允许其中一个进程进入临界区，这种状态称为活锁（livelock）（尽管该场景不会维持很长时间，但仍然是一种有可能发生的情形）

Dekker 算法

算法四可能会出现 “互相谦让” 的情况

Dekker算法通过turn变量表示哪个进程有权进入它的临界区，避免了**“互相谦让”**的情况

算法思路

当P0要进入它的临界区时，将其flag设置为true，然后检查P1的flag。若为false，P0可以立即进入它的临界区；否则，P0要检查turn，若发现turn为0，则P0要持续周期性地检查P1的flag。而P1需要延期执行并将flag设置为false，让P0执行。P0完成临界区执行后，将其flag设置为false以释放临界区，并将turn设置为1，把权力转交给P1

bool flag[2];
int turn;
void P0()
{
    while (true)
    {
        flag[0] = true;
        while (flag[1])
        {
            if (turn == 1)
            {
                flag[0] = false;
                while(turn == 1) { /* busy waiting */ }
                flag[0] = true;
            }
        }
        /* critical section */
        turn = 1;
        flag[0] = false;
    }
}
void P1()
{
    while (true)
    {
        flag[1] = true;
        while (flag[0])
        {
            if (turn == 0)
            {
                flag[1] = false;
                while (turn == 0) { /* busy waiting */ }
                flag[1] = true;
            }
        }
        /* critical section */
        turn = 0;
        flag[1] = false;
    }
}
int main()
{
    flag[0] = false;
    flag[1] = false;
    turn = 1;
    parbegin(P0, P1); // concurrent execution
    return 0;
}

Peterson 算法

Dekker 算法解决了互斥问题，但复杂的程序很难实现且其正确性也很难证明。Peterson提出了一个简单且精致的算法。和前面一样，全局数组变量flag表明每个互斥进程的位置，全局变量turn解决同时发生的冲突。

bool flag[2];
int turn;
void P0()
{
    while(true)
    {
        flag[0] = true;
        turn = 1;
        while(flag[1] && turn == 1) {/* busy waiting */}
        /* critical section */
        flag[0] = false;
    }
}
void P1()
{
    while(true)
    {
        flag[1] = true;
        turn = 0;
        while(flag[0] && turn == 0) {/* busy waiting */}
        /* critical section */
        flag[1] = false;
    }
}
int main()
{
    flag[0] = false;
    flag[1] = false;
    parbegin(P0, P1); // concurrent execution
    return 0;
}

最后两种正确算法相关内容（验证、说明等）待更新… …

曝雨
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
操作系统（8）进程--同步互斥介绍；同步问题的三种解决方案：禁用硬件中断、基于软件、更高级抽象
lililuni的博客
11-06 2786
1. 背景 同步互斥是操作系统协调进程之间动作和相互关系中的机制 并发进程的正确性 1 进程并发运行的好处 共享资源 加速:I/O操作和CPU计算可以重叠，程序可分为多个模块在多个处理器上并行执行 模块化:将大程序分解成小程序，使系统易于复用和扩展。 原子性操作 2 2. 同步问题的一个例子 本节用一个简单的生活问题来理解同步。（具体分析过程详见视频：同步问题） 下图中，如果A和B的...
操作系统实验-线程的互斥（实验五）
最新发布
05-11
### 操作系统实验-线程的互斥 #### 实验背景及目的 本实验报告由新疆师范大学计算机科学技术学院软件工程2106班的方瀚霖同学撰写，旨在通过实践操作来加深对线程互斥的理解。实验的主要目标是使学生能够理解线程...
Dekker算法是用软件的方法来解决2个进程间的同步互斥问题的
09-30
Dekker算法是用软件的方法来解决2个进程间的同步互斥问题的伪码描述
进程互斥的软件实现方法
LOOKTOMMER的博客
12-04 685
进程互斥遵守的原则 空闲让进：临界区空闲时，应允许一个进程访问。 忙则等待：临界区正在被访问时，其他试图访问的进程需要等待。 有限等待：要在有限时间内进入临界区，包装不会饥饿。 让权等待：进不来临界区的进程，要释放处理机，防止忙等 单标志法 算法思想 两个进程在访问完临界区后会把使用临界区的权限交给另一个进程。也就是说每个进程进入临界区的权限只能被另一个进程赋予。 int turn = 0; // turn 表示当前允许进入临界区的进程号 P0进程: while(turn !=...
操作系统 进程互斥--软件方法实现
0bug0warning的博客
10-10 1781
进程互斥- -软件方法实现 下面来介绍一下进程的概念。动态分配共享资源给正在执行的程序。一般来说每个软件都有自己的进程。例如qq，浏览器，word等。那么当这些进程共享资源时，就有可能产生互斥。 先来说下软件方式解决资源互斥。 所谓软件方法实现。就是自己编写代码来实现对进程的控制。 我们先要明白进程的临界区。访问临界资源的代码成为临界区。 比如下面的代码。 int flag[2]={0,0}; ...
王道 —— 进程互斥的软件实现方法
然后就去远行
09-20 1005
1、进程互斥的软件实现方法 单标志法 双标志法 双标志后检查 Peterson算法 2、单标志法 算法思想：两个进程在访问完临界区后会把使用临界区的权限转交给另一个进程，也就是说每个进程进入临界区的权限只能被另一个进程赋予； 通过代码来分析，在系统中会设置一个turn的变量： int turn = 0; //表示当前允许进入临界区的进程号； 默认turn的初始值为0，刚开始可以由0号进程P0P_0P0​进入临界区进行访问； P0P_0P0​和P1P_1P1​对临界区进行访问的代码分别是： # p0
操作系统课设-进程互斥与调度
11-21
操作系统是管理计算机硬件资源并提供服务的软件，它使得多个进程可以并发执行，从而提高系统的利用率和效率。在这个操作系统课程设计中，学生们被要求深入理解并发执行的原理，并通过编程实践来解决进程间的资源竞争...
操作系统课件：Lecture7 进程同步与互斥实现方法.ppt
05-08
操作系统中的进程同步与互斥是确保多...综上所述，进程同步与互斥的实现涉及到操作系统核心的并发控制机制，通过软件和硬件方法保证并发执行的正确性和效率。理解并熟练运用这些机制对于设计和分析多进程系统至关重要。
东北大学软件学院操作系统实验
05-07
根据给定的信息，我们可以深入探讨操作系统实验中关于进程与线程同步互斥的关键知识点，特别是以生产者-消费者问题为例。 ### 操作系统实验：进程/线程的同步与互斥 #### 实验目的 本实验旨在加深学生对进程与...
嵌入式系统及应用：操作系统3-互斥.ppt
07-12
解决互斥问题的方法主要有软件方法和硬件方法。软件方法通常通过自旋锁、信号量等机制实现，而硬件方法则依赖于处理器提供的原语或指令。信号量是一种常用的同步机制，它是一个整数值，可以表示资源的可用数量或者...
操作系统----资源共享互斥问题
06-01
运用儿子与女儿吃桔子和苹果来说明资源的共享与互斥问题。父亲放水果，儿子吃苹果，女儿吃桔子。
互斥：软件方法 Dekker互斥算法和Peterson互斥算法详解
Law of Conservation of Eudaemonia
12-22 1642
2.13 互斥 要求 空闲让进：若空闲，申请即进 忙则等待：只允许临界区存在一个进程，若忙碌，区外等待 有限等待：进程等待的时间是有限的，不会造成死锁、饥饿 让权等待：进程不能在临界区长时间阻塞等待某事件 以上类比生活中任何公共资源都可，如公用电话 2.13.1 互斥：软件方法 思路 在进入区设置标志来判断是否有进程在临界区 若临界区已有进程，则循环等待 进程离开临界区后在退出区修改标志 第一代：轮换使用临界区 每个进入临界区的进程的权限只能被另一个进程赋予 int turn=0; //进程P0
操作系统——18.进程互斥的软件实现方法
m0_52096593的博客
03-06 1234
首先，我们来看一下这节的大体框架理解各个算法的思想、原理结合上小节学习的“实现互斥的四个逻辑部分”，重点理解各算法在进入区、退出区都做了什么分析各算法存在的缺陷（结合“实现互斥要遵循的四个原则”进行分析）
小白莲的操作系统day05-2.3(01-05)
qq_42577508的博客
04-25 251
文章目录进程同步、进程互斥知识总览什么是进程同步什么是进程互斥知识回顾与重要考点进程互斥的软件实现方法（重点）知识总览如果没有注意进程互斥单标志法双标志先检查法双标志后检查法Peterson算法知识回顾与重要考点进程互斥的硬件实现方法知识总览中断屏蔽方法TestAndSet指令Swap指令知识回顾与重要考点信号量机制知识总览信号量机制--整型信号量信号量机制--记录型信号量（重点）知识回顾与重要考...
2.12、进程互斥的软件实现方法
qq_67720621的博客
02-13 308
前一个算法的问题是先 “检查” 后 “上锁” ，但是这两个操作又无法一气呵成，因此导致了两个进程同时进入临界区的问题。turn 表示当前允许进入临界区的进程号，而只有当前允许进入临界区的进程在访问了临界区之后，才会修改 turn 的值。想到了一种方法，如果双方都争着想进入临界区，那可以让进程尝试 “孔融让梨” ，主动让对方先使用临界区。算法思想：双标志后检查法中，两个进程都争着想进入临界区，但是谁也不让谁，最后谁都无法进入临界区。两个进程都争着想进入临界区，但是谁也不让谁，最后谁都无法进入临界区。
进程互斥的实现方式
weixin_53060535的博客
04-16 642
访问完临界区后每个进程进入临界区的权限只能被另一个进程赋予。
用信号量解决进程的同步与互斥探讨
shengxiaweizhi的专栏
05-25 1054
现代操作系统采用多道程序设计机制，多个进程可以并发执行，CPU在进程之间来回切换，共享某些资源，提高了资源的利用率，但这也使得处理并发执行的多个进程之间的冲突和相互制约关系成为了一道难题。如果对并发进程的调度不当，则可能会出现运行结果与切换时间有关的情况，令结果不可再现，影响系统的效率和正确性，严重时还会使系统直接崩溃。就比如你只有一台打印机，有两个进程都需要打印文件，如果直接让他们简单地并发访问
(C++)线程同步——互斥对象
qq_54169998的博客
09-13 840
临界资源是一次仅允许一个进程使用的共享资源。各进程采取互斥的方式，实现共享的资源称作临界资源。属于临界资源的硬件有，打印机，磁带机等；软件有消息队列，变量，数组，缓冲区等。诸进程间采取互斥方式，实现对这种资源的共享。
进程间通信(三)--严格轮换法
inspiredbh的博客
07-10 1765
while(true){ while(turn != 0);//循环等待 critical_region();//临界区 turn = 1; noncritical_region(); } while(true){ while(turn != 1);//循环等待 critical_region();//临界区 tur
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值