2.3_2 进程互斥的软件实现方法

2.3_2 进程互斥的软件实现方法

进程互斥的软件实现方法 单标志法 双标志先检查 双标志后检查 Peterson算法

单标志法

这块儿代码是基于我看的B站视频改进的,我认为他的代码逻辑不很好理解,所以,可能不是很正确

java 复制代码
int turn = 0;	//turn表示当前允许进入临界区的进程号
while(true){
    //P0进程					   	   
    while(turn==0){					
        critical section;				
        turn = 1;						
        remainder section;				
    }
    
    //P1进程
    while(turn==1){
        critical section;
        turn = 0;
        remainder section;
    }
}

注意:上面P0和P1部分的代码是并发执行的

turn的初始值为0,刚开始只允许P0进程进入临界区。

P0进程的时间片结束后,turn变为1,此时只有P1进程可以访问临界区。

该算法可以实现同一时刻最多只允许一个进程访问临界区

主要问题:违背"空闲让进"原则

只能按P0→P1→P0→P1→ ...... 这样轮流访问。这种必须"轮流访问"带来的问题是,如果此时允许进入临界区的进程是P0,而P0一直不访问临界区,那么虽然此时临界区空闲,但是并不允许P1访问。

双标志法先检查

算法思想:

设置一个布尔型数组 flag[],数组中各个元素用来标记各进程是否处于临界区内,比如"flag[0]=ture"意味着0号进程P0现在正在临界区内。每个进程在进入临界区之前先检查当前有没有别的进程处于临界区内。如果没有,则把自身对应的标志flag[i]设为true,之后开始访问临界区。

java 复制代码
bool flag[2];
flag[0]=false;
flag[1]=false;

while(true){
    //P0进程
    while(flag[1]!=1){
        flag[0]=true;
        critical section;
        flag[0]=false;
        remainder section;
    }
    
    //P1进程
    while(flag[0]!=1){
        falg[1]=true;
        critical section;
        flag[1]=false;
        remainder section;
    }
}

注意:上面P0和P1部分的代码是并发执行的

主要问题 :如果按照7行、15行、8行、16行这样的顺序来执行的话,临界区会被P0和P1同时访问。违反"忙则等待"原则

问题在于,进入区的"检查"和"上锁"两个处理不是一气呵成的,"检查"后"上锁"前有可能发生进程切换。

双标志后检查

算法思想:双标志先检查法的改版。前一个算法的问题是先"检查"后"上锁",但是这两个操作又无法一气呵成,因此导致了两个进程同时进入临界区的问题。因此,人们又想到先"上锁"后"检查"的方法,来避免上述问题。

java 复制代码
bool flag[2];
flag[0]=false;
flag[1]=false;

while(true){
    
    //P0进程
    flag[0]=true;8
    while(flag[1]!=1){9
        critical section;
        flag[0]=false;
        remainder section;
    }
    
    //P1进程
    flag[1]=true;16
    while(flag[0]!=1){17
        critical section;
        flag[1]=false;
        remainder section;
    }
}

注意:上面P0和P1部分的代码是并发执行的

主要问题:如果按照8行、16行、9行、17行这样的顺序来执行,每个进程都发现对面上锁了,都无法访问。

因此,双标志后检查法虽然解决了"忙则等待"的问题,但是又违背了"空闲让进"和"有限等待"原则,会因各进程都长期无法访问临界资源而产生"饥饿"现象

Peterson算法

算法思想:结合双标志法、单标志法的思想。如果双方都争着想进入临界区,那可以让进程尝试"孔融让梨"(谦让)。做一个有礼貌的进程。

java 复制代码
bool flag[2];
int turn = 0;	//表示优先让哪个进程进入临界区

//P0进程
flag[0]=true;
turn=1;
while(flag[1] && turn==1);	//如果为真,则卡在这一步
critical section;
flag[0]=false;
remainder section;

//P1进程
flag[1]=true;
turn=0;
while(flag[0] && turn==0);	//如果为真,则卡在这一步
critical section;
flag[1]=false;
remainder section;

Peterson算法用软件方法解决了进程互斥问题,遵循了空闲忙进、忙则等待、有限等待三个原则 ,但是依然未遵循让权等待的原则。

即:如果一个进程一直进不了临界区,那么会一直被卡在while循环。但是自己还在CPU上运行,不断检查while循环的条件是否得到满足。虽然这个进程进不了临界区,但是依然占用CPU资源


知识回顾与重要考点

相关推荐
ZZZS0516几秒前
stack栈练习
c++·笔记·学习·算法·动态规划
hans汉斯26 分钟前
【人工智能与机器人研究】基于力传感器坐标系预标定的重力补偿算法
人工智能·算法·机器人·信号处理·深度神经网络
vortex52 小时前
算法设计与分析:分治、动态规划与贪心算法的异同与选择
算法·贪心算法·动态规划
前端拿破轮2 小时前
🤡🤡🤡面试官:就你这还每天刷leetcode?连四数相加和四数之和都分不清!
算法·leetcode·面试
泊浮目2 小时前
未来数据库硬件-计算篇
数据库·云计算·操作系统
地平线开发者3 小时前
征程 6|工具链量化简介与代码实操
算法·自动驾驶
DoraBigHead3 小时前
🧠 小哆啦解题记——谁偷改了狗狗的台词?
算法
Kaltistss3 小时前
240.搜索二维矩阵Ⅱ
线性代数·算法·矩阵
轻语呢喃3 小时前
每日LeetCode:合并两个有序数组
javascript·算法
大熊猫侯佩4 小时前
Swift 数学计算:用 Accelerate 框架让性能“加速吃鸡”
算法·swift