Peterson's solution for achieving mutual exclusion

#define FALSE 0
#define TRUE  1
#define N     2                      /* number of processes */

int turn;                            /* whose turn is it? */
int interested[N];                   /* all values initially 0 (FALSE)*/
void enter_region(int process)       /* process is 0 or 1 */
{
     int other;                      /* number of the other process */
     other = 1 - process;            /* the opposite of process */
     interested[process] = TRUE;     /* show that you are interested */
     turn = process;                 /* set flag */
     while (turn == process && interested[other] == TRUE) /* null statement */;
}
void leave_region(int process)       /* process: who is leaving */
{
     interested[process] = FALSE;    /* indicate departure from critical region */
}

Let us see how this solution works. 

Initially, neither process is in its critical region. Now process 0 calls enter_region. It indicates its interest by setting its array element and sets turn to 0. 

Since process 1 is not interested, enter_region returns immediately. If process 1 now calls enter_region, it will hang there until interested[0] goes to FALSE, 

an event that only happens when process 0 calls leave_region to exit the critical region.

 
Now consider the case that both processes call enter_region almost simultaneously. 
Both will store their process number in turn. Whichever store is done last is the one that counts; 
the first one is lost. Suppose that process 1 stores last, so turn is 1. 
When both processes come to the while statement, process 0 executes it zero times and enters its critical region. 
Process 1 loops and does not enter its critical region