Perteson互斥算法的理解

引用自 计算机系统 核心概念及软硬件实现

第一次尝试实现互斥

#尝试编程实现互斥

#进程1
do
    while (turn != 1)
        ; //nothing
    cirtical section
    turn = 2;
    remainder section
while ( ! done1);

#进程2
do
    while (turn != 2)
        ; //nothing
    critical section
    turn = 1;
    remainder section
while (! done2);

此算法保证了互斥,但要求进程严格交替执行do循环,存在问题:如果一直想执行进程1而不执行进程2,那么此实现时无法做到的

第二次尝试实现互斥

#编程实现互斥的另一次尝试

#进程1
do
    enter1 = TRUE;
    while (enter2)
        ; //nothing
    critical section
    enter1 = FALSE;
    remainder section
while (! done1);

#进程2
do
    enter2 = TRUE;
    while (enter1)
        ; //nothing
    critical section
    enter2 = FALSE;
    remainder section
while (! done2);

此算法保证了互斥,也能够实现:某一进程多次执行而另一线程不被执行。
但,此算法有死锁:进程1设置enter1为TRUE后,调度进程2,进程2设置enter2为TRUE,然后进程2判断while (enter1),此循环耗尽时间片(进程2无法进入临界区、后续执行代码),调度进程1,进程1判定while (enter2)条件也成立,循环而无法进入临界区、执行后续代码,死锁形成。

Perterson互斥算法

#Perterson互斥算法

#进程1
do
    enter1 = TRUE;
    turn = 2;
    while (enter2 && (turn == 2))
        ; //nothing
    critical section
    enter1 = FALSE;
    remainder section
while (! dine1);

#进程2
do
    enter2 = TRUE;
    turn = 1;
    while (enter1 && (turn == 1))
        ; //nothing
    critical section
    enter2 = FALSE;
    remainder section
while (! done2);

直接理解Peterson算法,可能略显晦涩,不好区分enter和turn的含义,梳理Peterson算法的逻辑含义。

怎么理解Perterson算法呢?我们给出一个与上述算法类似的编码实现,对比方便理解:

#Perterson算法的类比编码实现

/*此实现直观地结合了“第一次尝试实现互斥”和“第二次尝试实现互斥”*/

#进程1
do
    enter1 = TRUE;
    while (enter2 && (turn == 2))
        ; //nothing
    critical section
    enter1 = FALSE;
    turn = 2;
    remainder section
while ( !done1);

#进程2
do
    enter2 = TRUE;
    while (enter1 && (turn == 1))
        ; //nothing
    critical section
    enter2 = FALSE;
    turn = 1;
    remainder section
while (! done2)

上面这个编码实现,结合了前两种编码实现方式(第一次尝试实现互斥、第二次尝试实现互斥),可以达到互斥、某一线程持续调度、无死锁的设计【不具体分析各场景,可参考计算机系统 核心概念及软硬件实现】。

我们的编码实现是什么含义呢?

  1. enter1 = TRUE表示进程1准备进入临界区,enter1 = FALSE;turn = 2表示进程1离开临界区,进程2可以进去临界区。
  2. 进程2在临界区中时,进程1无法进入临界区(while (enter2 && (turn == 2))。
  3. 进程1执行完毕临界区代码后,才允许进程2进入临界区(turn = 2)。

基于上面的理解,我们这样理解Peterson算法:

  1. enter理解为,进程有进入临界区的意图(enter1 = TRUE表示进程1有意图进入临界区);
  2. turn理解为,并发系统允许进入临界区的进程(turn = 1表示并发控制系统判定进程1可以进入临界区);
  3. 进程有进入临界区的意图,并且,系统允许其进入临界区的进程,才可以进入临界区(enter1 && (turn == 1));
  4. 对进程1,如果互斥的进程(进程2)满足上述第3点,那么进程1循环等待,以礼让进程2先进入临界区(while (enter2 && (turn == 2); //nothing)。
  5. 进程1是这样礼让进程2的,turn = 2,turn是可以理解为并发控制系统允许进入临界区的进程。

最后,比较我们编写的实现方式和Peterson算法,我们编写的方式虽然效果与Perterson算法相同,但有缺陷:

  1. 系统最初运行时,需要一个turn值,此turn值即并发系统允许运行的第一个进程(不具体分析场景),此设计可以理解为硬编码,人为干预并发系统调度,不好
  2. 进程离开临界区后修改turn值,这个turn值决定了下一次进程并发时哪一个进程可以继续执行,这就导致了,并发调度结果取决于上一次并发执行的顺序,每次并发调度不是独立的,不好

你可能感兴趣的:(Perteson互斥算法的理解)