Practical Session 6

• Multitasking vs. multithreading• Threads• Concurrency vs. Parallelism• Java Threads• Thread confinement• Object/Class Immutability

Multitasking vs. Multithreading • Multitasking:– Running more than one process on same processor.– Uses context switching between different processes:

(context=CPU state=content of CPU registers + program counter)• Switching from process A to B:

– Context of process A is stored.– Context of process B is restored.

• Multithreading:– Running more than one thread under same process.– Has the ability of resource sharing – all threads can

access all resources of a process.

Threads

• Definition– A way to share a single CPU between multiple tasks.

• Benefits– Allows maintaining responsiveness of an application.

• HTTP Server waiting for requests– Enable cancellation of separate tasks– Some problems require parallelism

• Google’s Map/Reduce– Allows monitoring status of a resource (data base)– Allows taking advantage of multiple processors

Concurrency vs. Parallelism

• Concurrency:– Two tasks can start and compete for CPU resources• Two threads running on same processor• They “share” the processor.

• Parallelism– Two tasks that run at the same time in parallel.• They do not compete on process time.• Threads are executing simultaneously

Copyright © 2002, DeLorme

Concurrency vs. ParallelismCPU CPU1 CPU2

Java Threads• Done by implementing the interface

java.lang.Runnable.• java.lang.Runnable– Allows any class that implements it to operate as a

thread.– Requires one method to be implemented:

• public void run()– Implementation:

class <className> implements Runnable {public void run(){

//the “main” function of the thread}

}

How to Run Threads

• By implementing Runnable and wrapping it with a Thread instance.– takes a single Runnable object and executes it in a separate thread. – It is activated by calling start() • calls the Runnable run() method.

• By implementing Runnable and passing it to an Executor.• By extending the Thread class.

class SimpleRunnable implements Runnable { private String name;

SimpleRunnable(String name) {this.name = name;

} //prints name three time waits 0.1 second between each print public void run() {

for (int i = 0; i < 3; i++) {System.out.println("RUNNABLE:" + this.name);try {

Thread.sleep(100);//time in miliseconds} catch (Exception e) {

e.printStackTrace();}

} }}

Wrapped by a Thread- Threads01.java

public class Threads01 {//creates to simeRunnable threads and starts thempublic static void main(String[] a) {

SimpleRunnable r1 = new SimpleRunnable("r1");Thread t1 = new Thread(r1);

SimpleRunnable r2 = new SimpleRunnable("r2");Thread t2 = new Thread(r2);

t1.start();t2.start();

}}

The order of start does not guarantee the order of execution.

Runnable Executor• Used to run threads that implemented Runnable• Decouples task creating and task running:– Class does not have to be ran right after creation

• Creating the Executor:• ExecutorService e = Executors.newFixedThreadPool(<numberOfThreads>);

– numberOfThreads: maximal number of threads running at same time.• Executing the thread:

– e.execute(Runnable object);• Shutting down executor:

– e.shutdown()• Causes the executor not to accept any new threads, and close all threads when all submitted tasks are

done.

Using Executor - Threads01e.javaclass SimpleRunnable implements Runnable { private int m_number;

public SimpleRunnable(int i) { this.m_number = i; }

/** * Main lifecycle of the task. * Prints the task ID 10 times. */ public void run() { for (int i = 0; i < 10; i++) { System.out.print(" " + m_number); } }}

import java.util.concurrent.*;

public class Threads01e { public static void main(String[] a) { // Create an executor: ExecutorService e = Executors.newFixedThreadPool(3);

// create 10 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(); }}

Extending Java Threads

• Java.lang.Thread– Allows maximal threading functionality– Less common than Runnable, however much more powerful.– Requires one method to be implemented:

• public void run()

• Implementation:class <classname> extends Thread{

public void run(){//thread “main” function}

}

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.

Example – shared counterpublic class Counter{

private int fCounter;

public Counter(){fCounter = 0;

}

public void increment(){fCounter++;

}

public int getValue(){return fCounter;

}}

public class Incrementer implements Runnable { Counter fCounter;

Incrementer(Counter ctr) { fCounter = ctr; }

/** * Main lifecycle. * increment the counter 200 times then dies. */ public void run() { for (int i = 0; i<200; i++) { fCounter.increment(); } }}

public class Threads03{

// Demonstrating problems with access to a shared resource. public static void main(String[] a) { for (int i=1;i<10;i++){ // create our shared object

Counter ctr = new Counter();

Thread t1 = new Thread(new Incrementer(ctr));Thread t2 = new Thread(new Incrementer(ctr));

t1.start();t2.start();//wait until their job is donewhile (t1.isAlive() || t2.isAlive()); //wait until all done.

//print out result of attempt iSystem.out.println("Attempt " + i + ", total

value: " + ctr.getValue());}

} }}

Shared Resources and Safety

• Safety problems arise when multiple threads access the same resource.

• A shared resource is any object that is visible to several threads: – global (static) objects– non-primitive method parameters – class members.– Basically non-primitive variables.

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); localVar += 2; this.i += 2; x += 2; lst.elementAt(2); Foo.NUMBER = 4; localVar = Foo.NUMBER ; }}

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

Not safe - Accessing a public member variable.

Local variable - SafeNot safe - Accessing a public member variable.Primitive- Safe

Not Safe - Accessing a possible shared object (lst).Not Safe (static - never safe!)

Not Safe (static - never safe!)

Not safe - Accessing a public member variable.

Not Safe - The private member variable (lst) is exposed to class A.

Some Solutions

• 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, but cannot be modified by any thread. Shared read-only objects are immutable.

Solution 1 - Thread Confinement

• Problem is solved by not accessing the shared resources! By not having shared resources.

• Called thread confinement:– threads access local resources only.

• This way, no need to worry about thread safety since no thread can access any other thread’s variables.

Example//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; }

//NotThreadConfined// e is not confined to this method - it is visible from the outside 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; }

Solution 2 - Immutability

• An immutable object cannot be changed after construction.

• Solves thread safety problem by not allowing any variable modifications at all.

Immutable Class - conditions• All of its fields are final • The class is declared final (cannot be subclassed)• The this reference is not allowed to escape during construction.

(the object is not fully constructed!)For more info: http://www.ibm.com/developerworks/java/library/j-jtp0618/

• Any fields that contain references to mutable objects, such as arrays, collections, or mutable classes like Date: –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

/** * The constructed class is immutable even-though it consists of mutable objects. * The class is immutable due to its design, not just by using the final keyword. * class ThreeStooges is declared to be final, which means that it cannot have subclasses. */

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

} }

it won't change after construction, meaning it won't be assigned with another reference, but still the object stooges is mutable: its internal values may change