Principles of Software Development Concurrency CSCI 201 Principles of Software Development Jeffrey Miller, Ph.D. jeffrey.miller@usc.edu

Outline Synchronization USC CSCI 201L

Motivation for Synchronization Thread synchronization is used to coordinate the execution of dependent threads Sometimes we want to have some control over when threads execute or what code they are able to simultaneously access Shared resources pose potential problems to multi-threaded code since we don’t typically have control over when a thread will be switched into and out of the CPU USC CSCI 201L

Synchronization Program Analogy Assume I brought a piggy bank to class (shared resource) 100 students in the class have to deposit a penny into the piggy bank (independent threads) How many pennies should be in the bank at the end? Deposit 1¢ USC CSCI 201L

Synchronization Example #1 1 public class AddAPenny implements Runnable { 2 private static PiggyBank piggy = new PiggyBank(); 3 4 public void run() { 5 piggy.deposit(1); 6 } 7 8 public static void main(String [] args) { 9 for (int i=0; i < 100; i++) { 10 Thread t = new Thread(new AddAPenny()); 11 t.start(); 12 } 13 System.out.println("Balance = " + piggy.getBalance()); 14 } 15 } 16 17 class PiggyBank { 18 private int balance = 0; 19 public int getBalance() { 20 return balance; 21 } 22 public void deposit(int amount) { 23 int newBalance = balance + amount; 24 Thread.yield(); 25 balance = newBalance; 26 } 27 } 4 Executions The values are not close to 100 because of how soon the println executes after the threads are started. Another reason these values are not close to 100 because the CPU switches the threads out of the CPU before they are able to set the balance variable on line 29 That means that threads are overwriting the other threads USC CSCI 201L

Synchronization Example #2 1 import java.util.concurrent.ExecutorService; 2 import java.util.concurrent.Executors; 3 4 public class AddAPenny implements Runnable { 5 private static PiggyBank piggy = new PiggyBank(); 6 7 public void run() { 8 piggy.deposit(1); 9 } 10 11 public static void main(String [] args) { 12 ExecutorService executor = Executors.newCachedThreadPool(); 13 for (int i=0; i < 100; i++) { 14 executor.execute(new AddAPenny()); 15 } 16 executor.shutdown(); 17 // wait until all tasks are finished 18 while(!executor.isTerminated()) { 19 Thread.yield(); 20 } 21 22 System.out.println("Balance = " + piggy.getBalance()); 23 } 24 } 25 26 class PiggyBank { 27 private int balance = 0; 28 public int getBalance() { 29 return balance; 30 } 31 public void deposit(int amount) { 32 int newBalance = balance + amount; 33 Thread.yield(); 34 balance = newBalance; 35 } 36 } 4 Executions The ExecutorService ensures that all of the threads will complete execution before printing the balance This is what while(!executor.isTerminated()) does These values are not close to 100 because the CPU switches the threads out of the CPU before they are able to set the balance variable on line 29 That means that threads are overwriting the other threads These values are lower than the values on the previous slide (slightly) because there is a little more overhead with the ExecutorService USC CSCI 201L

Synchronization Example #3 1 import java.util.concurrent.ExecutorService; 2 import java.util.concurrent.Executors; 3 4 public class AddAPenny implements Runnable { 5 private static PiggyBank piggy = new PiggyBank(); 6 7 public void run() { 8 piggy.deposit(1); 9 } 10 11 public static void main(String [] args) { 12 ExecutorService executor = Executors.newCachedThreadPool(); 13 for (int i=0; i < 100; i++) { 14 executor.execute(new AddAPenny()); 15 } 16 executor.shutdown(); 17 // wait until all tasks are finished 18 while(!executor.isTerminated()) { 19 Thread.yield(); 20 } 21 22 System.out.println("Balance = " + piggy.getBalance()); 23 } 24 } 25 26 class PiggyBank { 27 private int balance = 0; 28 public int getBalance() { 29 return balance; 30 } 31 public void deposit(int amount) { 32 balance += amount; 33 } 34 } 4 Executions These outputs are closer to 100 (expected answer) because there is much less code in the deposit method, so fewer chances of being context switched out of the CPU USC CSCI 201L

Synchronization Overview The problems in the previous examples are based on the use of a shared variable across multiple threads (the PiggyBank object piggy) The OS switches threads out of the CPU at times unknown to us This seems to be happening inside the deposit(int) method after newBalance is set but before it is assigned back to balance This causes the old value of balance to be used in subsequent threads When we reduce the deposit(int) method to a single statement, we get higher values for balance because there are fewer locations at which the OS can switch the thread out of the CPU before setting the value of balance USC CSCI 201L

Race Conditions A race condition is a state where more than one thread is accessing the same variable and overwriting the other thread’s updates This is a common problem in multi-threaded programming A class is thread-safe if an object of the class does not cause a race condition in the presence of multiple threads The AddAPenny class in the previous examples is not thread-safe USC CSCI 201L

Critical Section To avoid race conditions, it is necessary to prevent more than one thread from simultaneously entering a certain part of the program This part of the program is called a critical section or critical region In the previous examples, the critical section would be the deposit(int) method in the PiggyBank class If only one thread at a time was able to access the deposit(int) method, we would not have a race condition on the shared variable balance Note that balance is shared in the static instance of PiggyBank 22 public void deposit(int amount) { 23 int newBalance = balance + amount; 24 Thread.yield(); 25 balance = newBalance; 36 } USC CSCI 201L