System Programming Practical Session 4: Concurrency / Safety

Threads Till now, no multithreading class Prog{ public static void main(String args []){ ……. func1(); func2(); }

Threads Step1. Implement the interface Runnable: interface Runnabe{ public void run(); } Step 2. option 1: Create Threads option 2: Use Executor

Step 1 Example class SimpleRunnable implements Runnable { private int m_number; public SimpleRunnable(int i) { this.m_number = i; } public void run() { for (int i = 0; i < 10; i++) { System.out.print(" " + m_number); }

Step 2. Option 1. example public class Threads01 { public static void main(String[] a) { SimpleRunnable r1 = new SimpleRunnable(1); Thread t1 = new Thread(r1); SimpleRunnable r2 = new SimpleRunnable(2); Thread t2 = new Thread(r2); t1.start(); t2.start(); } Output:

Step 2. Option 2 - ExecutorService. example public class Threads01e { public static void main(String[] a) { // Create an executor: ExecutorService e = Executors.newFixedThreadPool(3); // create several runnables, and execute them. for(int i=0;i<10;i++) { SimpleRunnable r = new SimpleRunnable(i); e.execute(r); } e.shutdown(); }

Threads can be Dangerous Example: Two teaching assistants and one electronic Announcements page. Time Announcments A B C TA1 downloads page TA2 downloads pageAdds msg Y Adds msg Xupload Announcments A B C Y

Threads can be Dangerous Code Example 1: One printer and two threads class Printer { Printer() { } /** * Print a numbered line of the string 's' 40 times. i line number s the string to concatenate */ public void printALine(int i, String s) { System.out.print(i + ") "); for (int j = 0; j < 40; j++) { System.out.print(s); } System.out.println(); }

Example 1 continued class SimpleAsynchronousTask implements Runnable { Printer m_p; String m_name; SimpleAsynchronousTask(String name, Printer p) { m_p = p; m_name = name; } public void run() { for (int i = 0; i<50; i++) { m_p.printALine(i, m_name); }

Example 1 continued public class Threads02 { static void main(String[] a) { Printer p = new Printer(); Thread t1 = new Thread(new SimpleAsynchronousTask("a", p) ); Thread t2 = new Thread(new SimpleAsynchronousTask("b", p) ); t1.start(); // prints some lines of aaaa t2.start(); // prints some lines of bbbb }

Example 2: Even counter import java.util.concurrent.*; class EvenTask implements Runnable { Even m_even; EvenTask(Even even) { m_even = even; } public void run() { for (int i = 0; i < 50; i++) { System.out.println(m_even.next()); } } } public class Threads03 { public static void main(String[] args) { ExecutorService e = Executors.newFixedThreadPool(10); Even ev = new Even(); for (int i=0; i<10; i++) { e.execute(new EvenTask(ev)); } e.shutdown(); } } class Even { private long n = 0; pre-condition: n is even public long next() { n++; try {Thread.sleep(30);} catch (InterruptedException e) { } n++; return n; post-condition : n is greater by two }

Solution (Trial) class EvenTask implements Runnable { Even m_even; EvenTask(Even even) { m_even = even; } public void run() { try { for (int i = 0; i < 50; i++) { System.out.println( m_even.next()); } } catch (NotEvenException e) { System.out.println("Exception in “ + Thread.currentThread().getName()); e.printStackTrace(System.out); } } } class Even { private long n = 0; pre-condition: n is even public long next() throws NotEvenException { if (n%2 != 0) { throw new NotEvenException( "PRE: n is not even!"); } n++; try {Thread.sleep(30);} catch (InterruptedException e) {} n++; if (n%2 != 0) { throw new NotEvenException( "POST: n is not even!"); } return n; } post-condition : n is greater in two } class NotEvenException extends Exception { public NotEvenException (String message){ super(message); } }

Safety Running several threads in parallel is not safe. Unpredictable results on shared resources. Design aproaches towards avoiding safety problems Thread confinement Immutability Locking / Synchronization

Shared Resources Shared resource - A resource that is visible to several threads. Objects that may be visible to several threads - Are not safe. Objectst that cannot be shared (local function variables) - Are safe.

1.class Foo{ 2. public static double NUMBER = 33.3; } 3.class ClassA { 4.public long i; 5.public Vector v; 6.public ClassA (){/* … */} 7.public void doSomething( long x, List lst){ 8. long localVar = 0; 9. Object o; 10. o = this.v.elementAt(2); // localVar += 2; // this.i += 2; // x += 2; // lst.elementAt(2); // Foo.NUMBER = 4; // localVar = Foo.NUMBER; // } } 1.class TaskA implements Runnable { 2. private ClassA a; 3. private List lst; 4. public long r; 5.// … some code …. 6. public void run(){ 7. this.r = 2; // 8 8. this.a.doSomething( 9, lst); // 9 8. } 9. } 10. class Main { 11. public static void main( String[] args){ 13. ClassA o1 = new ClassA(); 14. Thread t1 = new Thread(new TaskA(o1)); 15. t1.start(); 16. // … some code …. } }

Thread Confinement A resource that is used exclusively by one single thread is confined to the thread. If all the resources of a method are confined, then it is safe.

1.public class ThreadConfinedExample 2. { 3. //ThreadConfined 4. public Car createCar() { 5. Engine e = new FuelEngine(); 6. List doors = new LinkedList (); 7. doors.add(new FrontDoor()); 8. doors.add(new FrontDoor()); 9. doors.add(new BackDoor()); 10. doors.add(new BackDoor()); 11. Radio r = new AMFMRadio(); Car c = new Car(e, doors, r); return c; 16. } 17.}

1.public class ThreadNotConfinedExample 2. { 3. // NotThreadConfined 4. public Car createCar(Engine e){ 5. List doors = new LinkedList ; 6. doors.add(new FrontDoor()); 7 doors.add(new FrontDoor()); 8. doors.add(new BackDoor()); 9. doors.add(new BackDoor()); 10. Radio r = new AMFMRadio()); Car c = new Car(e, doors, r); return c; 15. } 16.}

Immutability An immutable object’s state cannot be changed after construction. Examples: String Integer

Immutability An object is immutable if: All primitive fields are final. All other fields are references to immutable objects. The object has been safely published: Reference to “this” hasn't escaped during construction. No thread has accessed the object before the construction completed.

‘this’ escape example Public class ClassA{ ………….. public void setB(ClassB objB) { … } ……… } Public class ClassB{ …………… public ClassB(ClassA objA){ //constructor …………… objA.setB(this); } …………… }

Immutability An object with references to mutable objects can still be immutable! A class will be immutable if all of the following are true: 1.All of its fields are final 2.The class is declared final 3.The “this” reference is not allowed to escape during construction 4.Any fields that contain references to mutable objects, such as arrays, collections, or mutable classes: Are private Are never returned or otherwise exposed to callers Are the only reference to the objects that they reference Do not change the state of the referenced objects after construction

public final class ThreeStooges { private final Set stooges = new HashSet (); public ThreeStooges() { stooges.add("Moe"); stooges.add("Larry"); stooges.add("Curly"); } public boolean isStooge(String name) { return stooges.contains(name); }

Summary The most useful policies for using and sharing objects in a concurrent program are: Thread-confined Shared read-only Shared thread-safe