## Race Conditions

### Definition - Two or more processes are reading or writing some shared data and the final result depends on who runs precisely when.

### Tanenbaum example (Printer daemon) - Process enters name of file in spooler dir - Printer daemon checks to see if file need printing - Prints and removes names from spooler dir - Spooler dir has 0 ... infinity - Two shared variables, output, point at file to be printed - in, points to free slot in spooler dir - Proc A and B queue file for printing - A reads in, stores slot 7 in variable - Clock interrupt occurs - B reads in, stores slot 7 in same variable - B writes to slot 7, updates in to slot 8 - A writes to slot 7, erasing what B put there, updates in to slot 8 - Spooler dir now in sync - B never receives output

### Golang example (Incrementing a counter) - Proc 1 read counter 0 - Yield thread 0 - Increment counter 1 - Proc 2 read counter 0 - Yield thread 0 - Increment counter 1 - Proc 1 write counter 1 - Proc 2 write counter 1 - Proc 1 read counter 1 - Yield thread 1 - Increment counter 2 - Proc 2 read counter 1 - Yield thread 1 - Increment counter 2

### Go-isms - go run -race main.go - Don't communicate by sharing memory, share memory by communicating - Passing on a channel the data structure or object.

### Avoiding Race Conditions - No two processes may be simultaneously inside their critical regions. - No assumptions may be made about speeds or the number of CPUs. - No process running outside its critical region may block any process. - No process should have to wait forever to enter its critical region.

### Mutal Exclusion - While a process is busy updating shared memory no other process will attempt to enter shared memory space. - Disabling interrupts (Single CPU) - This approach is generally unattractive because it is unwise to give user processes the power to turn off interrupts. - Lock variables - Test the lock - If 0 set to 1 - Before process can set 0 to 1, another process reads as 0 - The race now occurs if the second process modifies the lock just after the first process has finished its second check. - Busy Waiting - It should usually be avoided, since it wastes CPU time - Mutual Exclusion Algorithm: G. L. Peterson - Each process calls enter\_region - Wait, if necessary, until safe to enter shared memory region - Process calls leave\_region after done with shared memory

``` #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 * / } ```