Dekker 算法

来源：互联网发布：网络机顶盒无电视猫编辑：程序博客网时间：2024/05/16 11:57

初步设想是这样的：
定义全局布尔变量 turn ，其值 0, 1 分别表示 P0 和 P1 进程占有了临界区。

对于 P0 进程：

?
1
2
3
4
5
6
7
8
9
10
bool turn; 
/* 对于 P0 进程 */
while(turn != 0) 
;   /*什么都不做,忙等待*/
  
/*********************/
/*  临界区代码    */
/*********************/
  
turn = 1;

对于 P1 进程：

?
1
2
3
4
5
6
7
8
9
10
bool turn; 
/* 对于 P0 进程 */
while(turn != 1) 
;   /*什么都不做,忙等待*/
  
/*********************/
/*  临界区代码    */
/*********************/
  
turn = 0;

从上面的设计中，可以看到存在两个问题：
1. 当 turn = 0 时，P1 是需要一直忙等待 turn = 1 时方可进入临界区。如果 P0 在 turn = 0 时一直没有进入临界区，那么 P1 的等待就是白等！
2. 如果任何一个进程在自己的临界区代码里失败(如死循环)或在临界代码外失败了，那么另外一个进程将永远无法进入自己的临界区！

下面对上面的设计进行改进：
使用全局共享数组 flag 标志临界区的状态：
当 flag[0] 或 flag[1] 为 ture 时，表示 P0 或 P1 在使用临界区；
当 flag[0] 或 flag[1] 为 false 时，表示 P0 或 P1 不使用临界区。

此时对于 P0 进程：

bool flag[2];while (flag[1]);  /*什么都不做,忙等待*/flag[0]=1;/*********************//*  临界区代码    *//*********************/flag[0]=0;

此时对于 P1 进程：

bool flag[2];while (flag[0]);  /*什么都不做,忙等待*/flag[1]=1;/*********************//*  临界区代码    *//*********************/flag[1]=0;

从上面的设计中可以看到，如果 P0 在临界区里死了，P1 仍然会忙等待无法进入临界区代码。但如果假设 P0 永不会死在临界区中，那么就不会出现像第一种情况里有一个进程进行“无辜”等待的情况。也就是说，P0 或 P1 是看对方的情况来访问临界区的，而不是看第三者(第一种情况中的 turn 变量)的脸色访问临界区的。但是这里，仍然存在一个问题，如果 flag[0] == flag[1] == false 时会出现什么情况？这时候，P0 和 P1 都有可能进入临界区。假设某时刻，CPU 将时间片分给了 P0，于是 P0 在 while 中判断 flag[0] 为 false 而往下走，这时 CPU 刚好又将时间片分给了 P1，于是 P1 也能顺利的进入临界区。这种情况违背了互斥和忙则等待的原则。

针对上面的改进再做修正：
由于上面有可能同时检测到 flag[0]=flag[1]=0 而两个进程同时进入临界区的情况。所以在此考虑将“先检测临界区状态(检查flag[0]或flag[1]标志)改为”先设置标志位“，也就是说，P0 和 P1 谁要是想访问临界区，谁就先举手声明一下自己这一意愿。这种做法，用代码表示如下：

对于 P0 进程：

?
1
2
3
4
5
6
7
8
bool flag[2]; 
flag[0] = true;  /* 我要访问临界区，先告知大家一下*/
while(flag[1])  /* 看看 P1 有没有在临界区中，有的话我就等等 */
; 
/*********************/
/*  临界区代码    */
/*********************/
flag[0] = false;          /*访问完了*/

对于 P1 进程：

?
1
2
3
4
5
6
7
8
bool flag[2]; 
flag[1] = true;  /* 我要访问临界区，先告知大家一下*/
while(flag[0])  /* 看看 P0 有没有在临界区中，有的话我就等等 */
; 
/*********************/
/*  临界区代码    */
/*********************/
flag[1] = false;          /*访问完了*/

但是这么一来，又有个问题了。比如当 P0 声明完自己要访问临界区后(flag[0] = true)，时间片轮转到 P1，这时 P1 也进行了声明，然后到 P0 运行时，发现 P1 已经用了临界区，自己就进行忙等待，同理 P1 也会因此进入忙等待。在这种情况下，发生了死锁，结果是两人都无法进入临界区。

综合上面所出的问题，进行最终的改进，得到了成功的 Dekker 算法，以 P0 的执行流程为例，得到流程图如下：

使用代码描述：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
        boolflag[2]; 
        flag[0] =false; 
        flag[1] =false; 
  
  
        boolturn = 0; 
  
  
        flag[0] =true; 
        while(flag[1]) { 
                if(turn) { 
                        flag[0] =false; 
                        while(turn); 
                        flag[0] =true; 
                }
        }
        /* critical section code */
        ...
          
        turn = 1;
        flag[0] =false; 
  
  
        /* remainder section */

代码说明：

第 9 行，P0 宣称自己要进入临界区了。
第 10 行，虽然 P0 已经宣布自己要进入临界区，但这还不够，因为 P1 可能也已经宣布。
第 11 行，两人都宣布要进入临界区，那要看谁已经进入。不管谁先进入临界区了它都要对 turn 进行相应设置，P0 退出临界区时使 turn=1 以表明 P1 对临界区可用了； P1 退出临界区时使 turn=0 以表明 P0 对临界区可用了。
第 12 行，发现 P1 进入，P0 就暂时宣布自己不想进入临界区。
第 13 行，一直在侦测 P1 是不是从临界区出来了，如果没出来，那么 P0 就忙等待。
第 14 行，P1 已经从临界区出来，P0 可以再次宣称自己要进入临界区。注意，这里仍然要返回到第 10 行的循环再次判断一下 P1 是否又宣称自己进入临界区且又占据了临界区资源。如果 P1 已经完全退出的话，那 P0 就安心的进入临界区。
第 20 行，P0 从临界区出来后，要标志一下 trun，以表明自己从临界区出来了。
第 21 行，表明自己暂时不想再进去临界区。
第 24 行，做其余的代码功能。

P1 的代码和 P0 是同理的，P1 进程代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
          flag[1] =true; 
        while(flag[0]) { 
                if(turn != 1) { 
                        flag[1] =false; 
                        while(turn != 1); 
                        flag[1] =true; 
                }
        }
        /* critical section code */
        ...
          
        turn = 0;
        flag[1] =false; 
  
  
        /* remainder section */