os

1. Bakery Algorithm
• The idea is similar to a line at the bakery
• A customer takes a number greater than
numbers of other customers
• Each of the threads gets a unique identifier

2. Bakery Algorithm
Thread i
flag[i]=true;
number[i] = max(number[0], …,number[n-1])+1;
while ($ k!= i
flag[k] && (number[i],i) > (number[k],k)) {};
critical section
flag[i] = false;

3. Bakery Algorithm
flag[i]=true;
number[i] = max(number[0], …,number[n-1])+1;
while ($ k!= i
flag[k] && (number[i],i) > (number[k],k)) {};
critical section
flag[i] = false;
Doorway

4. Bakery Algorithm
flag[i]=true;
number[i] = max(number[0], …,number[n-1])+1;
while ($ k!= i
flag[k] && (number[i],i) > (number[k],k)) {};
critical section
flag[i] = false;
I’m interested

5. Bakery Algorithm
flag[i]=true;
number[i] = max(number[0], …,number[n-1])+1;
while ($ k!= i
flag[k] && (number[i],i) > (number[k],k)) {};
critical section
flag[i] = false;
Take an number
numbers are always increasing!

6. Bakery Algorithm
flag[i]=true;
number[i] = max(number[0], …,number[n-1])+1;
while ($ k!= i
flag[k] && (number[i],i) > (number[k],k)) {};
critical section
flag[i] = false;
Someone is interested

7. Bakery Algorithm
flag[i]=true;
number[i] = max(number[0], …,number[n-1])+1;
while ($ k!= i
flag[k] && (number[i],i) > (number[k],k)) {};
critical section
flag[i] = false;
There is someone with a lower
number and identifier.
pair (a,b) > (c,d) if a>c, or a=c and b>d
(lexicographic order)

8. Deadlock freedom
• The bakery algorithm is deadlock free
• Some waiting thread A has a unique least
(number[A],A) pair, and that thread can enter
the critical section

9. FIFO
• The bakery algorithm is first-come-first-served
• If DA  DB then A’s number is earlier
– writeA(number[A])  readB(number[A]) 
writeB(number[B])  readB(flag[A])
• So B is locked out while flag[A] is true
flag[i]=true;
number[i] = max(number[0], …,number[n-1])+1;
while ($ k!= i
flag[k] && (number[i],i) > (number[k],k)) {};
critical section
flag[i] = false;