1
11. Multithreaded Applications
3/10/2018
John Roberts
2
Overview
• What is a thread?
• Thread class
• Runnable interface
• Thread states
• Controlling threads
• Synchronization
3
What is a process?
• An instance of a computer program that is being
executed
• Contains the program code, and its current activity:
• Machine code
• Memory (includes code, process specific data, call
stack, and heap)
• State (content of registers, Program Counter, Stack
Pointer, etc.)
4
What is a thread?
• The smallest sequence of programmed instructions that
can be managed independently by a schedule (typically
part of the OS)
• Contained within a process
• A single path of execution within a process
• Shares resources within a process
• Processes have their own address space, threads
share their address space
5
Processes vs. Threads
• Threads are “lightweight processes”
• Communication between threads is accomplished by
accessing shared memory, processes must use relatively
more expensive IPC (files, sockets, pipes)
• Context switches between threads are cheaper
(processes must swap out a memory space, thread
memory space is shared)
6
Multithreading
Multiple threads running on multiple processors
Thread 1
Thread 2
Thread 3
Multiple threads sharing a single CPU
Thread 1
Thread 2
Thread 3
7
Overview
• What is a thread?
• Thread class
• Runnable interface
• Thread states
• Controlling threads
• Synchronization
8
Thread class
• Java docs
• To create a new thread of execution, we can subclass
Thread, and implement the run method
9
Objective
• Create and execute three threads
• One prints the letter a 100 times
• One prints the letter b 100 times
• One prints the numbers from 1 to 100
• Github
10
LetterThread
1 public class LetterThread extends Thread {
2 private char character;
3
4 public LetterThread( char character ) {
5 this.character = character;
6 }
7
8 public void run() {
9 for( int counter = 0; counter < 100; counter++ ) {
10 System.out.print( this.character + " " );
11 }
12 }
13 }
11
CounterThread
1 public class CounterThread extends Thread {
2 public void run() {
3 for( int counter = 1; counter <= 100; counter++ ) {
4 System.out.print( counter + " " );
5 }
6 }
7 }
12 What will this print out when I run it? When I run it again?
Client
(make command cleans, compiles, and runs)
1 public class Client {
2 public static void main( String[] args ) {
3 LetterThread a = new LetterThread( 'a' );
4 LetterThread b = new LetterThread( 'b' );
5 CounterThread c = new CounterThread();
6
7 a.start();
8 b.start();
9 c.start();
10 }
11 }
13
Overview
• What is a thread?
• Thread class
• Runnable interface
• Thread states
• Controlling threads
• Synchronization
14
Runnable Interface
• Java docs
• To create a new thread of execution, we can implement
the Runnable interface, and implement the run method
• Create a new Thread with the Runnable instance
15
Objective
• Create and execute three threads
• One prints the letter a 100 times
• One prints the letter b 100 times
• One prints the numbers from 1 to 100
• Github
16
extend Thread vs. implement Runnable
• Why would we want to do one over the other?
17 r is reused, so any state in r can be shared among the two threads
extend Thread vs. implement Runnable
running it
• Why would we want to do one over the other?
• You can only extend only one class, constraining your class
design (rooting the class hierarchy at Thread)
• Runnables can be shared among Threads, allowing us to
access common resources
CustomThread a = new CustomThread();
CustomThread b = new CustomThread();
CustomRunnable r = new CustomRunnable();
new Thread( r ).start();
new Thread( r ).start();
18 No difference between this and LetterThread
LetterRunnable
1 public class LetterRunnable implements Runnable {
2 private char character;
3
4 public LetterRunnable( char character ) {
5 this.character = character;
6 }
7
8 public void run() {
9 for( int counter = 0; counter < 100; counter++ ) {
10 System.out.print( this.character + " " );
11 }
12 }
13 }
19 No difference between this and CounterThread
CounterRunnable
1 public class CounterRunnable implements Runnable {
2 public void run() {
3 for( int counter = 1; counter <= 100; counter++ ) {
4 System.out.print( counter + " " );
5 }
6 }
7 }
20 Stylistically, I’m not a fan of the temp variables, this could be made
Client
more concise (YMMV):
1 public class Client {
2
3
public static void main( String[] args ) {
LetterRunnable a = new LetterRunnable( 'a' );
new Thread( new LetterRunnable( ‘a’) ).start();
4 LetterRunnable b = new LetterRunnable( 'b' );
5 CounterRunnable c = new CounterRunnable();
6
7 new Thread( a ).start();
8 new Thread( b ).start();
9 new Thread( c ).start();
10 }
11 }
21
Overview
• What is a thread?
• Thread class
• Runnable interface
• Thread states
• Controlling threads
• Synchronization
22
Thread States
Thread Created
ready stop finished
resume, notify,
start run or notifyAll
stop, or complete stop
new yield, or time
expired
suspend, sleep,
running blocked
or wait
23
Overview
• What is a thread?
• Thread class
• Runnable interface
• Thread states
• Controlling threads
• Synchronization
24 Note that Thread implements runnable (so both Threads and
Controlling Threads
Runnables are runnables)
• void run()
Invoked by the Java runtime system to execute the
thread. You must override this method and provide the
code you want your thread to execute (but you will not
invoke this method!)
• void start()
Starts the thread, which causes the run() method to be
invoked. Called by the runnable object in the client class.
25
Controlling Threads
• static void sleep( long milliseconds )
throws InterruptedException
Puts the runnable object to sleep (temporarily cease
execution) for a specified time in milliseconds
• public final void join() throws
InterruptedException
Allows one thread to wait for the completion of another
26
Overview
• What is a thread?
• Thread class
• Runnable interface
• Thread states
• Controlling threads
• Synchronization
27 Showing the possible case where thread execution switches at each
Synchronization
time step
• Shared resources could become corrupted if accessed
simultaneously by multiple threads
time balance thread A thread B
1 0 newBalance = bank.getBalance() +1
2 0 newBalance = bank.getBalance() +1
3 1 bank.setBalance( newBalance );
4 1 bank.setBalance( newBalance );
28
Piggy Bank
1 public class PiggyBank {
2 private int balance = 0;
3
4 public int getBalance() {
5 return this.balance;
6 }
7
8 public void setBalance( int newBalance ) {
9 this.balance = newBalance;
10 }
11 }
29 https://github.com/sfsu-csc-413-roberts/lecture-11/tree/master/piggy-
Add a Penny Thread, Unsynchronized
bank
1 public class AddAPennyThreadUnsynchronized extends Thread {
2
3
private PiggyBank bank; Arbitrary sleep to force interruption…
4 public AddAPennyThreadUnsynchronized( PiggyBank bank ) {
5 this.bank = bank;
6 }
7
8 public void run() {
9 int newBalance = bank.getBalance() + 1;
10
11 try {
12 Thread.sleep( 5 );
13 } catch( InterruptedException e ) {
14 System.out.println( "Interrupted" );
15 }
16
17 bank.setBalance( newBalance );
18 }
19 }
30
Synchronized Methods
• Java Tutorial
• To make a method synchronized, add the synchronized
keyword to its declaration:
public synchronized void someMethod() { /* … /* }
• When one thread is executing a synchronized method for
an object, all other threads that invoke synchronized
methods for the same object will block (suspend execution)
• Constructors can not be synchronized!
31
Locks
• Every object has an intrinsic lock associated with it
• Enforces exclusive access to an object’s state
• A thread that needs exclusive and consistent access to
an object’s state has to acquire the lock before
accessing them
• If another thread has already acquired the lock, then
the current thread must wait until the lock is released
• A thread releases the lock when done
32
Locks
• The intrinsic lock used with a synchronized method
controls only access to the current object
• We may also use the lock on the Class object associated
with the class, with a static synchronized method
declaration (see next slide)
33 Line 14 means that the *current thread* (main) should wait for
PiggyBank Driver
pennies[i] to complete - this line tells the current thread to wait until all
penny threads have completed execution.
1 public class PiggyBankDriver {
2 public static void main( String[] args ) throws InterruptedException {
3 final int count = 100;
4
5 PiggyBank bank = new PiggyBank();
6 Thread pennies[] = new Thread[ count ];
7
8 for( int i = 0; i < count; i++ ) {
9 pennies[ i ] = new AddAPennyThread( bank );
10 pennies[ i ].start();
11 }
12
13 for( int i = 0; i < count; i++ ) {
14 pennies[ i ].join();
15 }
16
17 System.out.println(
18 "After adding " + count + " pennies, balance is " + bank.getBalance()
19 );
20 }
21 }
34 https://github.com/sfsu-csc-413-roberts/lecture-11/tree/master/piggy-
Add a Penny Thread, with Synchronization
1 public class AddAPennyThreadSynchronized extends Thread {
bank-synchronized
static synchronized is using a lock obtained from the class - what
2 private PiggyBank bank;
3
4 public AddAPennyThreadSynchronized( PiggyBank bank ) {
5 this.bank = bank;
6
7
}
happens if we omit static (and change the run method accordingly)?
8 private static synchronized void addAPenny( PiggyBank bank ) {
9
10
11
int newBalance = bank.getBalance() + 1;
try {
Synchronization is happening on the thread, not on the PiggyBank
object! (We could change the implementation of PiggyBank for more
12 Thread.sleep( 5 );
13 } catch( InterruptedException e ) {
14 System.out.println( "Interrupted" );
15 }
16
17
18 }
bank.setBalance( newBalance ); intuitive access control…)
19
20 public void run() {
21 addAPenny( this.bank );
22 }
23 }
35 Guess which one is synchronized
Sample Outputs
ᐅ make
find . -type f -name '*.class' -delete
javac PiggyBankDriver.java; java PiggyBankDriver
After adding 100 pennies, balance is 1
ᐅ make
find . -type f -name '*.class' -delete
javac PiggyBankDriver.java; java PiggyBankDriver
After adding 100 pennies, balance is 2
ᐅ make
find . -type f -name '*.class' -delete
javac PiggyBankDriver.java; java PiggyBankDriver
After adding 100 pennies, balance is 100
