互斥算法

软件算法

• 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进入并发进队的j一定会与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的状态 保证循环可找到一个申请进程并退出

硬件算法

• 硬件提供test and set指令

int test_and_set (int &target)
{
   int temp=target
   *target=1
   return temp
}


//算法实现
waiting[i]=1 key=1
while(waiting[i]==1 and key==1)key=test_and_set(&lock)//执行进程执行完后让给i 或 没有进程正在使用临界区 则进入
waiting[i]=0
  //临界区
j=(i+1）%n
while(i!=j)and(!wait[j])
{
   j=（j+1）%n
}
if（i==j）lock=0     //没有其他进程申请 释放缓冲区
else waiting[j]=0    //下一个申请的进程停止等待 不释放缓冲区

• 硬件提供交换指令

void swap(int &a,&b)
{
   int temp;
   temp=*a; *a=*b; *b=temp;
}

//算法实现（满足有限等待性）
pi:
waiting[i]= 1 key=1
do swap(&lock,&key）while (key==1&&waiting[i]==1)
//临界区
j=(i+1)%n
while(waiting[j]==0) j=(j+1)%n
if(j!=i) waiting[j]=0
else lock=0
waiting[i]=0

多cpu环境

lock(bus)
操作公共变量
unlock(bus)