互斥算法

dekker算法

p0:
 flag[0]=1
 while(flag[1]==1){
     if(turn==1){
        flag[0]=0
        while(turn==1);
        flag[0]=1
     } 
 }
   //临界区
 turn=1
 flag[0]=0
----------------------
p1:
 flag[1]=1
 while(flag[0]==1){
     if(turn==0){
        flag[1]=0
        while(turn==0);
        flag[1]=1
     } 
 }
   //临界区
 turn=0
 flag[1]=0

Peterson算法

p0:
flag[0]=1
turn=1                             //先让给对方
while(flag[1]==1 and turn==1);     //如果对方又让给我 或者 对方没在用 进入临界区
  //临界区
flag[0]=0
----------------------
p0:
flag[1]=1
turn=0
while(flag[0]==1 and turn==0);
  //临界区
flag[1]=0

Lamport算法

pi:
choosing[i]=1
number[i]=max(number[1],number[2],...number[n])+1
choosing[i]=0
for j=0 in range n{
   while(choosing[j]==1);                              //核心步骤 保证并发进队一定会与i比较 没比较的choose一定大于i
   while(number[j]!=0 and {number[j],j}<{number[i],i});
} 
   //临界区
number[i]=0

Eisenberg/mcguire算法

pi:
DO{
 flag[i]=want_in
 j=turn
 while(j!=i){         //等待最靠近turn--优先级最高的申请进程 
    if(flag[i]!=idle)j=turn
    else j=(j+1)%n
 }
 flag[i]=in_cs        //先置位 后全局扫描 避免两个进程同时进入
 j=0
 while(j<n)and(j==i or flag[j]!=in_cs){
     j++
 }
}while(j!=n)
turn=i
   //临界区
j=(turn+1)%n          //退出后将turn给下一个请求进入的进程 保证算法公平性 
while(flag[j]==idle){
  j=（j+1）%n
}
turn=j
flag[i]=idle          //最后更改进程i的状态 保证循环可找到一个申请进程并退出