Concurrency (Threads)

Concurrency (Threads) Threads allow you to do tasks in parallel. In an unthreaded program, you code is executed procedurally from start to finish. In a threaded program, you can have multiple threads working concurrently.

Threads are short-lived Threads are like processes, only they're short-lived. How short-lived? • When run() method terminates or returns • The thread is interrupted • An exception is thrown inside run()

Process vs. Threads Process: A process runs independently and isolated of other processes. It cannot directly access shared data in other processes. The resources of the process are allocated to it via the operating system, e.g. memory and CPU time. Threads: threads are so-called lightweight processes which have their own call stack but can access shared data. Every thread has its own memory cache. If a thread reads shared data it stores this data in its own memory cache.

Concurrency (Threads) Concurrency is achieved through time-slicing. This is where the processor cycles through each active thread for an indeterminate period of time (the slice). This gives the illusion that there are multiple processes. With multi-core processors, this may mean, true multi-threading is possible, but NOT guaranteed

Amdahl's Law Concurrency promises to perform certain task faster as these tasks can be divided into subtasks and these subtasks can be executed in parallel. Of course the runtime is limited by parts of the task which can be performed in parallel. The theoretical possible performance gain can be calculated by Amdahl's Law. If F is the percentage of the program which can not run in parallel and N is the number of processes then the maximum performance gain is: 1/ (F+ ((1-F)/n)).

Issues in Concurrency A visibility problem occurs if one thread reads shared data which is later changed by other thread and if thread A does not see this change. A access problem occurs if several thread trying to access and change the same shared data at the same time.

Concurrency Failures Liveness failure: The program does not react anymore due to problems in the concurrent access of data, e.g. deadlocks. Safety failure: The program creates incorrect data.

Syncrhonized keyword that only a single thread can execute a block of code at the same time ensures that each thread entering a synchronized block of code sees the effects of all previous modifications that were guarded by the same lock

Volatile keyword If a variable is declared as volatile then it is guaranteed that any thread which reads the field will see the most recently written value. This is to guard against caching.

Thread Pools Thread Pools manage (and limit) the number of active threads. This tends to be more orderly and more efficient for scaled applications.

Synchronizing methods When multiple threads have access to the same object, it makes sense to synchronize those methods which are prone to concurrency errors. The bank account example.

Thread-safe collections //http://download.oracle.com/javase/6/docs/api/java/util/concurrent/package-summary.html

Running a Thread • Implement a class that implements the Runnable interface: public interface Runnable { void run(); } • Place the code for your task into the run method of your class: public class MyRunnable implements Runnable { public void run() { Task statements ... } }

Running a Thread • Create an object of your subclass: Runnable r = new MyRunnable(); • Construct a Threadobject from the runnable object: Thread t = new Thread(r); • Call the start method to start the thread: t.start();

Running Threads • sleep puts current thread to sleep for given number of milliseconds: Thread.sleep(milliseconds) • When a thread is interrupted, most common response is to terminate run

Genericrunmethod public void run() { try { Task statements } catch (InterruptedException exception) { } Clean up, if necessary}

ch20/greeting/GreetingRunnable.java 1 import java.util.Date; 2 3 /** 4 A runnable that repeatedly prints a greeting. 5 */ 6 publicclass GreetingRunner implements Runnable 7 { 8 privatestaticfinalint REPETITIONS = 10; 9 privatestaticfinalint DELAY = 1000; 10 11 private String strGreeting; 12 13 /** 14 Constructs the runnable object. 15 @param aGreeting the greeting to display 16 */ 17 public GreetingRunner(String strGreeting) 18 { 19 this.strGreeting = strGreeting; 20 } 21 Continued

To Start the Thread • Construct an object of your runnableclass: Runnable t = new GreetingRunnable("Hello World"); • Then construct a thread and call the start method: Thread t = new Thread(r); t.start();

Thread Scheduler • Thread scheduler: runs each thread for a short amount of time (a time slice) • Then the scheduler activates another thread • There will always be slight variations in running times - especially when calling operating system services (e.g. input and output) • There is no guarantee about the order in which threads are executed

Terminating Threads • A thread terminates when its run method terminates • Do not terminate a thread using the deprecated stop method • Instead, notify a thread that it should terminate: t.interrupt(); • interrupt does not cause the thread to terminate – it sets a boolean variable in the thread data structure

Terminating Threads • The run method should check occasionally whether it has been interrupted • Use the interruptedmethod • An interrupted thread should release resources, clean up, and exit: public void run() { for (int i = 1; i <= REPETITIONS && !Thread.interrupted(); i++) {Do work }Clean up }

Terminating Threads • Java does not force a thread to terminate when it is interrupted • It is entirely up to the thread what it does when it is interrupted • Interrupting is a general mechanism for getting the thread’s attention

Synchronizing Object Access • When a thread calls lock, it owns the lock until it calls unlock • A thread that calls lock while another thread owns the lock is temporarily deactivated • Thread scheduler periodically reactivates thread so it can try to acquire the lock • Eventually, waiting thread can acquire the lock

Concurrency (Threads)