Multithreading

Topic Goals
To understand how multiple threads can execute in parallel To learn how to implement threads To understand race conditions and deadlocks To be able to avoid corruption of shared objects by using locks and conditions
CSE UOWD

CSCI 213: Multithreading Spring 2013

Process
Resources ownership
process includes a virtual address space to

hold the process image

Scheduling/execution
follows an execution path that may be

interleaved with other processes

These two characteristics are treated independently by the operating system

CSE UOWD

CSCI 213: Multithreading Spring 2013

Threads
Individual execution unit within a process Each thread has a control block, with a state (Ready/Running/Blocked), saved registers, instruction pointer Separate stack

CSE UOWD

CSCI 213: Multithreading Spring 2013

Benefits of Threads
Takes less time to create a new thread than a process Less time to terminate a thread than a process Less time to switch between two threads within the same process Since threads within the same process share memory and files, they can communicate with each other without invoking the kernel
CSE UOWD

CSCI 213: Multithreading Spring 2013

Types

CSE UOWD

CSCI 213: Multithreading Spring 2013

Examples
Foreground/Background
Backing up in background

Asynchronous Processing Faster Execution

Read one set of data while processing another

set

Organization
For a word processing program, may allow

one thread for each file being edited

CSE UOWD

CSCI 213: Multithreading Spring 2013

Block and Synchronization

Generally, a thread can block without blocking the remaining threads in the process
Allow the process to start two operations at

once, each thread blocks on the appropriate event

Must handle synchronization between threads

System calls or local subroutines Thread generally responsible for getting/

releasing locks, etc

CSE UOWD

CSCI 213: Multithreading Spring 2013

Threads Properties
Suspending a process involves suspending all threads of the process since all threads share the same address space Termination of a process, terminates all threads within the process

CSE UOWD

CSCI 213: Multithreading Spring 2013

Java Threads
A thread is a program unit that is executed independently of other parts of the program The Java Virtual Machine executes each thread in the program for a short amount of time This gives the impression of parallel execution

CSE UOWD

CSCI 213: Multithreading Spring 2013

10

Using a Thread
Develop 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 go here ... } }
CSE UOWD

CSCI 213: Multithreading Spring 2013

11

Running a Thread (2)

Create an object of your subclass
Runnable r = new MyRunnable();

Construct a Thread object from the runnable object

Thread t = new Thread(r);

Call the start method to start the thread

t.start();

CSE UOWD

CSCI 213: Multithreading Spring 2013

12

Example
A program to print a time stamp and Hello World once a second for ten seconds:
Fri Fri Fri Fri Fri Fri Fri Fri Fri
CSE UOWD

Apr Apr Apr Apr Apr Apr Apr Apr Apr

12 12 12 12 12 12 12 12 12

00:51:09 00:51:10 00:51:11 00:51:12 00:51:13 00:51:14 00:51:15 00:51:16 00:51:17

GST GST GST GST GST GST GST GST GST

2013 2013 2013 2013 2013 2013 2013 2013 2013

Hello, Hello, Hello, Hello, Hello, Hello, Hello, Hello, Hello,

World! World! World! World! World! World! World! World! World!

CSCI 213: Multithreading Spring 2013

13

GreetingRunnable
public class GreetingRunnable implements Runnable { public GreetingRunnable(String aGreeting) { greeting = aGreeting; } public void run() { // Task statements go here ... } // Fields used by the task statements private String greeting; }
CSE UOWD

CSCI 213: Multithreading Spring 2013

14

Print a time stamp Print the greeting Wait a second Loop

Thread Actions for GreetingRunnable

CSE UOWD

CSCI 213: Multithreading Spring 2013

15

GreetingRunnable
We can get the date and time by constructing a Date object
Date now = new Date();

To wait a second, use the sleep method of the Thread class

sleep(milliseconds)

A sleeping thread can generate an InterruptedException

Catch the exception Terminate the thread
CSE UOWD

CSCI 213: Multithreading Spring 2013

16

Generic run method

public void run() { try { // Task statements } catch (InterruptedException exception) { } // Clean up, if necessary }
CSCI 213: Multithreading Spring 2013

CSE UOWD

17

GreetingRunnable.java
01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22:
CSE UOWD

import java.util.Date; /** A runnable that repeatedly prints a greeting. */ public class GreetingRunnable implements Runnable { /** Constructs the runnable object. @param aGreeting: the greeting to display */ public GreetingRunnable(String aGreeting) { greeting = aGreeting; } public void run() { try { for (int i = 1; i <= REPETITIONS; i++) {
CSCI 213: Multithreading Spring 2013

18

GreetingRunnable.java (2)
23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: } Date now = new Date(); System.out.println(now + " " + greeting); Thread.sleep(DELAY); } } catch (InterruptedException exception) { } } private String greeting; static final int REPETITIONS = 10; static final int DELAY = 1000;

CSE UOWD

CSCI 213: Multithreading Spring 2013

19

To Start the Thread

Construct an object of your runnable class
Runnable t = new GreetingRunnable("Hello World");

Then construct a thread and call the start method

Thread t = new Thread(r); t.start();

CSE UOWD

CSCI 213: Multithreading Spring 2013

20

GreetingThreadRunner.java
01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: /** This program runs two greeting threads in parallel. */ public class GreetingThreadRunner { public static void main(String[] args) { GreetingRunnable r1 = new GreetingRunnable("Hello, World!"); GreetingRunnable r2 = new GreetingRunnable("Goodbye, World!"); Thread t1 = new Thread(r1); Thread t2 = new Thread(r2); t1.start(); t2.start(); } }

CSE UOWD

CSCI 213: Multithreading Spring 2013

21

Output
Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri Fri
CSE UOWD

Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr Apr

12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12

00:57:46 00:57:46 00:57:47 00:57:47 00:57:48 00:57:48 00:57:49 00:57:49 00:57:50 00:57:50 00:57:51 00:57:51 00:57:52 00:57:52 00:57:53 00:57:53 00:57:54 00:57:54 00:57:55 00:57:55

GST GST GST GST GST GST GST GST GST GST GST GST GST GST GST GST GST GST GST GST

2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013

Hello, World! Goodbye, World! Hello, World! Goodbye, World! Goodbye, World! Hello, World! Hello, World! Goodbye, World! Hello, World! Goodbye, World! Hello, World! Goodbye, World! Goodbye, World! Hello, World! Hello, World! Goodbye, World! Goodbye, World! Hello, World! Hello, World! Goodbye, World!
22

CSCI 213: Multithreading Spring 2013

Thread Scheduler
The 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
CSE UOWD

CSCI 213: Multithreading Spring 2013

23

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 field in the thread data
CSE UOWD

structure

CSCI 213: Multithreading Spring 2013

24

Terminating Threads (2)

The run method should check occasionally whether it has been interrupted
Use the interrupted method 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 }

CSE UOWD

CSCI 213: Multithreading Spring 2013

25

Terminating Threads (3)

The sleep method throws an InterruptedException when a sleeping thread is interrupted
Catch the exception Terminate the thread

CSE UOWD

public void run() { try { for (int i = 1; i <= REPETITIONS; i++) { // Do work } } catch (InterruptedException exception) { } // Clean up CSCI 213: Multithreading } Spring 2013

26

Terminating Threads (4)

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 threads attention

CSE UOWD

CSCI 213: Multithreading Spring 2013

27

Race Conditions
When threads share a common object, they can conflict with each other Sample program: multiple threads manipulate a bank account Here is the run method of DepositRunnable: public void run() { try { for (int i = 1; i <= count; i++) { account.deposit(amount); Thread.sleep(DELAY);
CSE UOWD

CSCI 213: Multithreading Spring 2013

28

Race Conditions (2)

} } catch (InterruptedException exception) { }

The WithdrawRunnable class is similar

CSE UOWD

CSCI 213: Multithreading Spring 2013

29

Sample Application
Create a BankAccount object Create two sets of threads:
Each thread in the first set repeatedly deposits $100 Each thread in the second set repeatedly withdraws $100

deposit and withdraw have been modified to print messages:

public void deposit(double amount) { System.out.print("Depositing " + amount); double newBalance = balance + amount; System.out.println(", new balance is " + newBalance); balance = newBalance; }

CSE UOWD

CSCI 213: Multithreading Spring 2013

30

10

Sample Application (2)

The result should be zero, but sometimes it is not Normally, the program output looks somewhat like this:
Depositing 100.0, new balance is 100.0 Withdrawing 100.0, new balance is 0.0 Depositing 100.0, new balance is 100.0 Depositing 100.0, new balance is 200.0 Withdrawing 100.0, new balance is 100.0 ... Withdrawing 100.0, new balance is 0.0

But sometimes you may notice messed-up output, like this:

Depositing 100.0Withdrawing 100.0, new balance is 100.0, new balance is -100.0
CSE UOWD

CSCI 213: Multithreading Spring 2013

31

1. A deposit thread executes the lines

Scenario to Explain Non-zero Result: Race Condition

System.out.print("Depositing " + amount); double newBalance = balance + amount;

The balance field is still 0, and the newBalance local variable is 100 2. The deposit thread reaches the end of its time slice and a withdraw thread gains control 3. The withdraw thread calls the withdraw method which withdraws $100 from the balance variable; it is now -100 4. The withdraw thread goes to sleep
CSE UOWD

CSCI 213: Multithreading Spring 2013

32

Scenario to Explain Non-zero Result: Race Condition (2)

The deposit thread regains control and picks up where it left off; it executes:
System.out.println(", new balance is " + newBalance); balance = newBalance;

The balance is now 100 instead of 0 because the deposit method used the OLD newBalance

CSE UOWD

CSCI 213: Multithreading Spring 2013

33

11

Corrupting the Contents of the balance Field

CSE UOWD

CSCI 213: Multithreading Spring 2013

34

Race Condition
Occurs if the effect of multiple threads on shared data depends on the order in which they are scheduled It is possible for a thread to reach the end of its time slice in the middle of a statement It may evaluate the right-hand side of an equation but not be able to store the result until its next turn
public void deposit(double amount) { balance = balance + amount; System.out.print("Depositing " + amount + ", new balance is " + balance); }

Race condition can still occur:

balance = the right-hand-side value
CSE UOWD

CSCI 213: Multithreading Spring 2013

35

Synchronizing Object Access

To solve problems such as the one just seen, use a lock object A lock object is used to control threads that manipulate shared resources In Java: Lock interface and several classes that implement it
ReentrantLock: most commonly used lock

class

CSE UOWD

CSCI 213: Multithreading Spring 2013

36

12

Synchronizing Object Access (2)

Typically, a lock object is added to a class whose methods access shared resources, like this:
public class BankAccount { public BankAccount() { balanceChangeLock = new ReentrantLock(); ... } ... private Lock balanceChangeLock; }

CSE UOWD

CSCI 213: Multithreading Spring 2013

37

Synchronizing Object Access (3)

Code that manipulates shared resource is surrounded by calls to lock and unlock:
balanceChangeLock.lock(); Code that manipulates the shared resource balanceChangeLock.unlock();

CSE UOWD

CSCI 213: Multithreading Spring 2013

38

Synchronizing Object Access (4)

If code between calls to lock and unlock throws an exception, call to unlock never happens To overcome this problem, place call to unlock into a finally clause:
public void deposit(double amount) { balanceChangeLock.lock(); try { System.out.print("Depositing " + amount); double newBalance = balance + amount; System.out.println(", new balance is " + newBalance); balance = newBalance; }
CSE UOWD

CSCI 213: Multithreading Spring 2013

39

13

Synchronizing Object Access (5)

finally { balanceChangeLock.unlock(); } }

CSE UOWD

CSCI 213: Multithreading Spring 2013

40

Synchronizing Object Access (6)

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
CSE UOWD

CSCI 213: Multithreading Spring 2013

41

Avoiding Deadlocks
A deadlock occurs if no thread can proceed because each thread is waiting for another to do some work first BankAccount example
public void withdraw(double amount) { balanceChangeLock.lock(); try { while (balance < amount) Wait for the balance to grow ... } finally { balanceChangeLock.unlock(); } }
CSE UOWD

CSCI 213: Multithreading Spring 2013

42

14

Avoiding Deadlocks (2)

How can we wait for the balance to grow? We cant simply call sleep inside withdraw method
thread will block all other threads that want to use
balanceChangeLock

(balance)

In particular, no other thread can successfully execute

deposit

Other threads will call deposit, but will be blocked until withdraw exits But withdraw doesnt exit until it has funds available DEADLOCK
CSE UOWD

CSCI 213: Multithreading Spring 2013

43

Condition Objects
To overcome problem, use a condition object Condition objects allow a thread to temporarily release a lock, and to regain the lock at a later time Each condition object belongs to a specific lock object

CSE UOWD

CSCI 213: Multithreading Spring 2013

44

Condition Objects (2)

You obtain a condition object with newCondition method
public class BankAccount { public BankAccount() { balanceChangeLock = new ReentrantLock(); sufficientFundsCondition = balanceChangeLock.newCondition(); ... } ... private Lock balanceChangeLock; private Condition sufficientFundsCondition; }

CSE UOWD

CSCI 213: Multithreading Spring 2013

45

15

Condition Objects (3)

It is customary to give the condition object a name that describes condition to test You need to implement an appropriate test

CSE UOWD

CSCI 213: Multithreading Spring 2013

46

Condition Objects (4)

As long as test is not fulfilled, call await on the condition object:
public void withdraw(double amount) { balanceChangeLock.lock(); try { while (balance < amount) sufficientFundsCondition.await(); ... } finally { balanceChangeLock.unlock(); } }
CSE UOWD

CSCI 213: Multithreading Spring 2013

47

Condition Objects (5)

Calling await
Makes current thread wait Allows another thread to acquire the lock object

To unblock, another thread must execute signalAll on the same condition object
sufficientFundsCondition.signalAll();

signalAll unblocks all threads waiting on the condition signal: randomly picks just one thread waiting on the object and unblocks it signal can be more efficient, but you need to know that every waiting thread can proceed Recommendation: always call signalAll
CSE UOWD

CSCI 213: Multithreading Spring 2013

48

16