System Programming. Practical Session 4: Threads and Concurrency / Safety

Transcription

1 System Programming Practical Session 4: Threads and Concurrency / Safety

2 Using Threads - All the computer programs you've seen so far were sequential only one thing was performed at any given time - Sometimes it is desirable to do several things simultaneously (when?) Multitasking vs. Multithreading - If the tasks to be performed are not related in any way, using a different process for each task is a good solution - If the tasks are somewhat related, and need to share data between them, it is beneficial to put them inside the same process, so they can share resources. This is achieved using Threads - Several Threads can run simultaneously on a single process, sharing its resources. Special care should be taken when using those shared resources

3 How to use Threads in Java In order to run a task in parallel, two steps should be taken: 1. Define the task: - Defining the task is done by implementing the Runnable interface: class SomeClass implements Runnable { public void run() { some code Ask "someone" to run it: - Option 1: Use Executor - Option 2: Create Threads

4 Step 1 - (Define the task) example (code of PS4 on SPL site): 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);

5 Step 2 - (Run the task) - example 1 (Use Executor): 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++) { System.out.println("creating a new task: " + i + " "); SimpleRunnable r = new SimpleRunnable(i); e.execute(r); e.shutdown(); // this causes the executor not to accept any // more tasks, and to kill all of its threads // when all the submitted tasks are done. What will this code print?

6 Step 2 - (Run the task) - example 2 (Create Threads): 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();

7 Threads can be Dangerous - Having things run "at the same time, in the same place", can be dangerous. - The two tasks can interfere with each other, and unexpected results might occur. - Printer example - Even example

8 Printer example class Printer { Printer() { 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(); 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); public class Threads02 { public 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

9 Even example class Even { private long n = 0; public long next() { n++; class EvenTask implements Runnable { Even m_even; EvenTask(Even even) { m_even = even; try {Thread.sleep(30); catch (InterruptedException e) { n++; return n; public void run() { for (int i = 0; i < 50; i++) { System.out.println(m_even.next()); public class Threads03 { /** * Demonstrating the failing of the pre/post conditions of Even. */ 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();

10 Even 2 - example class Even { private long n = 0; public long next() throws NotEvenException { if (n%2!= 0) { throw new NotEvenException("PRE:not even"); n++; try {Thread.sleep(30); Catch (InterruptedException e) { n++; if (n%2!= 0) { throw new NotEvenException("POST:not even"); return n; public class Threads04 { /** * Demonstrating the failing of the pre/post conditions of Even. */ 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();

11 Safety Running several threads in parallel is not safe. Unpredictable results on shared resources.

12 Design approaches towards avoiding safety problems Thread confinement Immutability Locking / Synchronization

13 Shared Resources A shared resource is any object that is visible to several threads. This includes: global (static) objects, non-primitive method parameters and class members, but not local function variables. Objects that may be visible to several threads - Are not safe. Objects that cannot be shared (local function variables) - Are safe.

14 class Foo{ public static double NUMBER = 33.3; class ClassA { public long i; public Vector v; public ClassA (){/* */ public void dosomething(long x, List lst){ long localvar = 0; Object o; o = this.v.elementat(2); // 1 localvar += 2; // 2 this.i += 2; // 3 x += 2; // 4 lst.elementat(2); // 5 Foo.NUMBER = 4; // 6 localvar = Foo.NUMBER; // 7

15 class TaskA implements Runnable { private ClassA a; private List lst; public long r; // some code. public void run(){ this.r = 2; // 8 this.a.dosomething(9,lst); // 9 class Main { public static void main(string[] args){ ClassA o1 = new ClassA(); Thread t1 = new Thread(new TaskA(o1)); t1.start(); // some code.

16 class Foo{ public static double NUMBER = 33.3; class ClassA { public long i; public Vector v; public ClassA (){/* */ public void dosomething(long x, List lst){ long localvar = 0; Object o; o = this.v.elementat(2); // 1 - Accessing a public member variable. localvar += 2; // 2 this.i += 2; // 3 - Accessing a public member variable. x += 2; // 4 lst.elementat(2); // 5 - Accessing a possible shared object (lst). Foo.NUMBER = 4; // 6 - (never safe!) localvar = Foo.NUMBER; // 7 - (never safe!)

17 class TaskA implements Runnable { private ClassA a; private List lst; public long r; // some code. public void run(){ this.r = 2; // 8 - Accessing a public member variable. this.a.dosomething(9,lst);// 9 - The private member variable (lst) is exposed to class A. class Main { public static void main(string[] args){ ClassA o1 = new ClassA(); Thread t1 = new Thread(new TaskA(o1)); t1.start(); // some code.

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

19 createcar() method is confined, and so the method is safe to use in a multi-threaded situation public class ThreadConfinedExample { //ThreadConfined public Car createcar() { Engine e = new FuelEngine(); List<Door> doors = new LinkedList<Door>(); doors.add(new FrontDoor()); doors.add(new FrontDoor()); doors.add(new BackDoor()); doors.add(new BackDoor()); Radio r = new AMFMRadio(); Car c = new Car(e, doors, r); return c;

20 Why is this createcar(engine e) method not safe? public class ThreadNotConfinedExample { //NotThreadConfined public Car createcar(engine e){ List<Door> doors = new LinkedList<Door>; doors.add(new FrontDoor()); doors.add(new FrontDoor()); doors.add(new BackDoor()); doors.add(new BackDoor()); Radio r = new AMFMRadio()); Car c = new Car(e, doors, r); return c;

21 Immutability An immutable object s state cannot be changed after construction. Thus, it can be safely used as a read-only object by multiple threads Examples (classes in Java that are immutable): String Integer

22 mutable class (not safe - why?) immutable class public class Colors { private int c1; private String name; final public class Colors { //final class final private int c1; //final, private fields final private String name; public Colors(int c1, String name) { this.c1 = c1; this.name = name; public Colors(int c1, String name) { this.c1 = c1; //primitive this.name = name; //String is immutable public int getcolor() { return c1; public int getcolor() { return c1; public String getname() { return name; public String getname() { return name; public void change(int c1, String name) { this.c1 = c2; this.name = name; public Colors change(int newc, String newname) { Return new Colors(newC, newname);

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

24 this escape example Public class ClassA {... public void setb(classb objb) { Public class ClassB {... //constructor public ClassB(ClassA obja){... obja.setb(this);...

25 Immutability - It is not always possible to make all your fields immutable, but, you can still get the immutability effect! 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

26 Example: immutable class, that consists of mutable objects //The class is immutable due to its design, not just by using the final keyword. //After the class instance is constructed, it becomes read-only by design public final class ThreeStooges { //final class can't have subclasses private final Set<String> stooges = new HashSet<String>(); //final here means it won't be assigned with another reference public ThreeStooges() { stooges.add("moe"); //but still the object stooges is mutable: //its internal values may change stooges.add("larry"); stooges.add("curly"); public boolean isstooge(string name) { return stooges.contains(name);

27 Summary The most useful policies for using and sharing objects in a concurrent program are: Thread-confined - A thread-confined object is owned exclusively by and confined to one thread, and can be modified only by the thread that owns it Shared read-only - A shared read-only object can be accessed concurrently by multiple threads without additional synchronization, but cannot be modified by any thread. Shared readonly objects are immutable. Shared thread-safe - A thread-safe object performs synchronization internally, so multiple threads can freely access it through its public interface without further synchronization.

28 System Programming Practical Session 5: Synchronization

29 Synchronization A mechanism allowing safely accessing shared resources. A thread accessing a synchronized method locks the object. The object cannot be accessed by other threads while it is locked.

30 Synchronization Class Even{ private long n = 0; public long next(){ n++; n++; return n;

31 Synchronization Synchronize a method: - The object on which it is invoked acts as the synchronization "key". - The key is acquired when entering the method, and is released one leaving it. Who is the key? Class Even{ private long n = 0; public synchronized long next(){ n++; n++; return n;

32 Synchronizing a block In this case, you have to implicitly specify the synchronization object Who is the key? public int foo() { // do something safe synchronized(this) { // do something return 9;

33 - The word "synchronized" doesn't automatically make the code thread safe - Good programming uses the minimal amount of Synchronization

34 Solution to safety problem Printer Example (from practical session 1) Where do we synchronize? class Printer { Printer() { /** i line number s the string to concatenate 40 times */ 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();

35 public class GoodSynchronization{ public 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 class SimpleAsynchronousTask implements Runnable { Printer m_p; String m_name; public 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);

36 class Printer { Printer() { /** i line number s the string to concatenate 40 times */ public synchronized void printaline(int i, String s) { System.out.print(i + ") "); for (int j = 0; j < 40; j++) { System.out.print(s); System.out.println();

37 Wrong solution #1 Why? public class BadSynchronization2 { public static void main(string[] a) { Printer p1 = new Printer(); Printer p2 = new Printer(); Thread t1 = new Thread( new SimpleAsynchronousTask("a", p1) ); Thread t2 = new Thread( new SimpleAsynchronousTask("b", p2) ); t1.start(); // prints some lines of aaaa t2.start(); // prints some lines of bbbb class SimpleAsynchronousTask implements Runnable {...the same like GoodSynchronization.java class Printer {...the same like GoodSynchronization.java

38 Wrong solution #2 (no printer object) Why? class BadSynchronization { public static void main(string[] a) { Thread t1 = new Thread( new SimpleAsynchronousTask("a") ); Thread t2 = new Thread( new SimpleAsynchronousTask("b") ); t1.start(); // prints some lines of aaaa t2.start(); // prints some lines of bbbb class SimpleAsynchronousTask implements Runnable {...the same like GoodSynchronization.java public synchronized void printaline(int i, String s) { System.out.print(i + ") "); for (int j = 0; j < 40; j++) System.out.print(s); System.out.println();

39 Summary The most useful policies for using and sharing objects in a concurrent program are: Thread-confined - A thread-confined object is owned exclusively by and confined to one thread, and can be modified only by the thread that owns it Shared read-only - A shared read-only object can be accessed concurrently by multiple threads without additional synchronization, but cannot be modified by any thread. Shared readonly objects are immutable. Shared thread-safe - A thread-safe object performs synchronization internally, so multiple threads can freely access it through its public interface without further synchronization.