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:

1 1 2 2 2 1 2 1 2 2 1 1 1 1 2 2 2 2 1 1

Step 2. Option 2 - ExecutorService. examplepublic 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 page Adds msg Y

Adds msg X upload

upload

Announcments

A

B

C

Y

Threads can be DangerousCode Example 1: One printer and two threads

class Printer { Printer() { } /** * Print a numbered line of the string 's' 40 times. * @param i line number * @param 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 continuedpublic 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 counterimport 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); // 1

11. localVar += 2;          // 2

12.   this.i   += 2;          // 3

13.  x        += 2;          // 4

14. lst.elementAt(2);       // 5

15.   Foo.NUMBER = 4;         // 6   

16.   localVar = Foo.NUMBER; // 7 17.  } }

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();

1.  Thread t1 = 

new Thread(new TaskA(o1));

15.   t1.start();   

1. //…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<Door> doors = new LinkedList<Door>();

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();

12.  

13.           Car c = new Car(e, doors, r);

14.  

15.           return c;

16.       }

17.}

1. public class ThreadNotConfinedExample

2.  {

3. //NotThreadConfined 4. public Car createCar(Engine e){

5.       List<Door> doors = new LinkedList<Door>;

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());

11.  

12.           Car c = new Car(e, doors, r);

13.  

14.           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<String> stooges =  new HashSet<String>();   

    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