UMass Lowell Computer Science 91.460

Java and Distributed Computing

Prof. Karen Daniels Fall, 2000

UMass Lowell Computer Science 91.460

Java and Distributed Computing

Prof. Karen Daniels Fall, 2000

Lecture 18Lecture 18Advanced Java ConceptsAdvanced Java Concepts

Threads and MultithreadingThreads and Multithreading[[Java 2: The Complete Reference: Java 2: The Complete Reference: Chapter 11]Chapter 11]

[[DeitelDeitel: Chapter 15]: Chapter 15]

FriFri. 10/27 – Mon. 10/30. 10/27 – Mon. 10/30

Homework StatusHomework Status

11 Fri, 9/8 9/15, 9/18 Fri, 9/8 9/15, 9/18 22 Fri, 9/15 Fri, 9/22 Fri, 9/15 Fri, 9/22 33 Fri, 9/22Fri, 9/22 Fri, 9/29 Fri, 9/29 44 Fri, 10/6Fri, 10/6 Fri, 10/13Fri, 10/13 55 Fri, 10/13Fri, 10/13 Fri, 10/20Fri, 10/2066 Fri, 10/20 Fri, 10/27Fri, 10/20 Fri, 10/27 77 Fri, 10/27 Fri, 11/3Fri, 10/27 Fri, 11/3

HW#HW# AssignedAssigned DueDue

GradedGraded

SubmittedSubmitted

PendingPending

Thread DemoThread Demo

““Nervous Text”Nervous Text”

Some DefinitionsSome Definitions

Multiprocessing - The simultaneous processing of Multiprocessing - The simultaneous processing of two or more portions of the same program on two two or more portions of the same program on two or more processing unitsor more processing units

Multiprogramming - The simultaneous processing Multiprogramming - The simultaneous processing of multiple programs (OS processes) on one or of multiple programs (OS processes) on one or more processing unitsmore processing units

Multitasking operating system - an OS that Multitasking operating system - an OS that supports multiprogrammingsupports multiprogramming

Multithreading ???Multithreading ???

MultithreadingMultithreading

The “simultaneous” * processing of two or more The “simultaneous” * processing of two or more portions (threads) of the same program (OS portions (threads) of the same program (OS process)process) Might take advantage of multiple CPUs when presentMight take advantage of multiple CPUs when present

A thread can be thought of as a light-weight A thread can be thought of as a light-weight process that you control (rather than the OS)process that you control (rather than the OS) Requires less overhead than full-fledged processesRequires less overhead than full-fledged processes Makes sharing resources (e.g., memory) easierMakes sharing resources (e.g., memory) easier

* Logical but not necessarily truly physical concurrency* Logical but not necessarily truly physical concurrency

Multithreading vs. MultiprogrammingMultithreading vs. Multiprogramming

Program 1Program 1

......

Program nProgram n

CPU 1CPU 1

CPU mCPU m

......

Program 1Program 1

......

Program nProgram n

Thread 1A Thread 1A Thread 1BThread 1B

Thread nA Thread nA Thread nB Thread nB Thread nC Thread nC

CPU 1CPU 1

CPU mCPU m

......

MultiprogrammingMultiprogramming

MultithreadingMultithreading

SourceSource: : Java 2 CertificationJava 2 Certification

Why Use Threads?Why Use Threads?

Can provide real or apparent speed up (e.g., start Can provide real or apparent speed up (e.g., start editing a large file before it is completely loaded editing a large file before it is completely loaded in memory)in memory)

Can support arbitrary service requests easilyCan support arbitrary service requests easily Can support shared use of a common resourceCan support shared use of a common resource Is (relatively) easy to do in Java in a (mostly) Is (relatively) easy to do in Java in a (mostly)

portable wayportable way General rule of thumb - if a piece of code takes a General rule of thumb - if a piece of code takes a

long time to run and is somewhat independent of long time to run and is somewhat independent of the rest of the program, put it in a threadthe rest of the program, put it in a thread

Thread StatesThread States

Born - created, needs to be startedBorn - created, needs to be started Ready (runnable) - eligible to be runReady (runnable) - eligible to be run Running - actually executingRunning - actually executing Waiting - asleep, blocked (for I/O), etc.Waiting - asleep, blocked (for I/O), etc. Dead - processing completed, “that’s all she wrote”Dead - processing completed, “that’s all she wrote”

ReadyReady

WaitingWaiting

RunningRunning DeadDeadBornBorn

This is a very simple example of a state diagram. State This is a very simple example of a state diagram. State transition diagrams with transition conditions labeling the transition diagrams with transition conditions labeling the arrows are helpful aids to designing good multithreaded code.arrows are helpful aids to designing good multithreaded code.

Life Cycle of a Java Thread(more detail)

Life Cycle of a Java Thread(more detail)

SourceSource:: Deitel & Deitel Deitel & Deitel

Thread SchedulingThread Scheduling

The JVM has to select which thread(s) to The JVM has to select which thread(s) to run (move from ready to running states) at run (move from ready to running states) at what timewhat time

Two kinds of scheduling:Two kinds of scheduling: Preemptive (UNIX)Preemptive (UNIX) Time slicing (Win32, Macintosh)Time slicing (Win32, Macintosh)

Preemptive SchedulingPreemptive Scheduling

The highest priority thread runs until The highest priority thread runs until It diesIt dies It “puts itself to sleep”It “puts itself to sleep” It is preempted by a higher priority threadIt is preempted by a higher priority thread

A higher-priority thread comes into existenceA higher-priority thread comes into existence A previous thread’s priority changesA previous thread’s priority changes

Preemptive scheduling is predictable, but can Preemptive scheduling is predictable, but can result in low-priority threads never runningresult in low-priority threads never running

Time SlicingTime Slicing

Threads execute for a specific slice of timeThreads execute for a specific slice of time Scheduler then decides whether to keep Scheduler then decides whether to keep

thread running or “give the CPU to” another thread running or “give the CPU to” another threadthread

Less predictable than preemptive Less predictable than preemptive scheduling, but can handle “selfish” threadsscheduling, but can handle “selfish” threads

SynchronizationSynchronization

The use of threads presents a need for The use of threads presents a need for coordinating their activitiescoordinating their activities

Synchronization is temporal coordination of Synchronization is temporal coordination of simultaneous activitiessimultaneous activities

Synchronization allows communication about Synchronization allows communication about things/events of mutual interest across threadsthings/events of mutual interest across threads

Synchronization is needed to support mutual Synchronization is needed to support mutual exclusionexclusion

Mutual ExclusionMutual Exclusion

Multiple threads present a potential pitfall - Multiple threads present a potential pitfall - simultaneous access to shared resourcessimultaneous access to shared resources Thread A want to read the value of a variable, Thread A want to read the value of a variable,

think about it for while, and then change itthink about it for while, and then change it After Thread A reads the value, but before it After Thread A reads the value, but before it

writes the new value, Thread B changes its writes the new value, Thread B changes its valuevalue

Thread B’s change gets lostThread B’s change gets lost

SemaphoresSemaphores

Semaphores are primitives that support mutual exclusionSemaphores are primitives that support mutual exclusion Allow multiple programs to read/write shared informationAllow multiple programs to read/write shared information Identify critical regions of code that need exclusive access Identify critical regions of code that need exclusive access

to a shared resourceto a shared resource Usage:Usage:

Process Process AA wants shared resource, tells that resource’s wants shared resource, tells that resource’s semaphore to waitsemaphore to wait

System suspends Process System suspends Process AA until resource is available until resource is available System then wakes up Process System then wakes up Process AA and gives it exclusive use of and gives it exclusive use of

the resourcethe resource When Process When Process AA is finished with the resource, tells the is finished with the resource, tells the

semaphore to proceed (releases the resource)semaphore to proceed (releases the resource)

Semaphores (continued)Semaphores (continued)

Semaphore mechanism uses:Semaphore mechanism uses: A sequencer S: integer variableA sequencer S: integer variable Atomic Wait operation P:Atomic Wait operation P:

P(S): Wait until S>0 and then S--P(S): Wait until S>0 and then S-- Atomic Signal operation V:Atomic Signal operation V:

V(S): S++V(S): S++ Allows a process to block itself to wait for an event and then Allows a process to block itself to wait for an event and then

be awakened by another process when the event occursbe awakened by another process when the event occurs To control access to a single resource, use binary semaphoreTo control access to a single resource, use binary semaphore

SourceSource: : Structured Concurrent Programming with Structured Concurrent Programming with Operating Systems ApplicationsOperating Systems Applications

The Monitor ConceptThe Monitor Concept

SourceSource:: Operating Systems: Operating Systems: Advanced ConceptsAdvanced Concepts

• Object-oriented: local data + Object-oriented: local data + “methods”“methods”• Scheduler controls order of Scheduler controls order of resource allocationresource allocation• Condition variables Condition variables determine can cause process to determine can cause process to blockblock• Guard allows only 1 process Guard allows only 1 process to execute in monitor at a timeto execute in monitor at a time• Monitor supports mutual Monitor supports mutual exclusion for each procedureexclusion for each procedure

Java’s Approach to ThreadsJava’s Approach to Threads

Java was designed with threads in mindJava was designed with threads in mind class class ThreadThread class class ObjectObject synchronizedsynchronized statements and methods statements and methods

uses uses MonitorMonitor concept from Operating Systems concept from Operating Systems

classclass ThreadGroup ThreadGroup

java.lang.Threadjava.lang.Thread

Implements the java.lang.Runnable interfaceImplements the java.lang.Runnable interface Basic methods:Basic methods:

runrun() - the thread’s execution entry point (invoked by () - the thread’s execution entry point (invoked by the JVM thread scheduler)the JVM thread scheduler)

startstart() - put the (new) thread in the ready state, then () - put the (new) thread in the ready state, then returns immediately to the launching threadreturns immediately to the launching thread

isAliveisAlive() - the thread has been started and is not dead() - the thread has been started and is not dead getNamegetName() - returns the thread’s name (has a JVM-() - returns the thread’s name (has a JVM-

assigned default or can be specified )assigned default or can be specified ) toStringtoString() - like () - like getNamegetName(), but includes the priority (), but includes the priority

and ThreadGroup nameand ThreadGroup name

java.lang.Thread (concluded)java.lang.Thread (concluded)

Basic methods (concluded):Basic methods (concluded): setPrioritysetPriority() - sets the thread’s (integer, 1 to 10) () - sets the thread’s (integer, 1 to 10)

prioritypriority currentThreadcurrentThread() - returns the current Thread (static)() - returns the current Thread (static) sleepsleep() - puts the (currentThread) thread to sleep for a () - puts the (currentThread) thread to sleep for a

specified time so that other (e.g., lower-priority) specified time so that other (e.g., lower-priority) threads can execute (static)threads can execute (static)

interruptinterrupt() - wakes up a thread() - wakes up a thread joinjoin() - the thread that invokes this on another thread () - the thread that invokes this on another thread

waits for the other thread to die before proceedingwaits for the other thread to die before proceeding

Thread Specification (1 of 3)Thread Specification (1 of 3)

public class Thread implements Runnable {public class Thread implements Runnable { public final static int MIN_PRIORITY = 1;public final static int MIN_PRIORITY = 1; public final static int MAX_PRIORITY = 10;public final static int MAX_PRIORITY = 10; public final static int NORM_PRIORITY = 5;public final static int NORM_PRIORITY = 5; public Thread();public Thread(); public Thread(String name);public Thread(String name); public Thread(Runnable runObject);public Thread(Runnable runObject); public Thread(Runnable runObject, String name);public Thread(Runnable runObject, String name); public Thread(ThreadGroup group, String name)public Thread(ThreadGroup group, String name) throws SecurityException, IllegalThreadStateException;throws SecurityException, IllegalThreadStateException; public Thread(ThreadGroup group, Runnable runObject)public Thread(ThreadGroup group, Runnable runObject) throws SecurityException, IllegalThreadStateException;throws SecurityException, IllegalThreadStateException; public Thread(ThreadGroup group, Runnable runObject, String name)public Thread(ThreadGroup group, Runnable runObject, String name) throws SecurityException, IllegalThreadStateException;throws SecurityException, IllegalThreadStateException;

Thread Specification (2 of 3)Thread Specification (2 of 3)

public String toString();public String toString(); public void checkAccess() throws SecurityException;public void checkAccess() throws SecurityException;

public void run();public void run(); public void start()public void start() throws IllegalThreadStateException;throws IllegalThreadStateException;

public final String getName();public final String getName(); public final void setName(String name)public final void setName(String name) throws SecurityException;throws SecurityException; public final ThreadGroup getThreadGroup();public final ThreadGroup getThreadGroup(); public final int getPriority();public final int getPriority(); public final void setPriority(int newPriority)public final void setPriority(int newPriority) throws SecurityException, IllegalArgumentException;throws SecurityException, IllegalArgumentException; public final boolean isDaemon();public final boolean isDaemon(); public final void setDaemon(boolean on) public final void setDaemon(boolean on)

throws SecurityException, IllegalThreadStateException;throws SecurityException, IllegalThreadStateException;

public final boolean isAlive();public final boolean isAlive();public int countStackFrames();public int countStackFrames();

Thread Specification (3 of 3)Thread Specification (3 of 3)

public final void join()public final void join() throws InterruptedException;throws InterruptedException; public final void join(long millis)public final void join(long millis) throws InterruptedException;throws InterruptedException; public final void join(long millis, int nanos)public final void join(long millis, int nanos) throws InterruptedException;throws InterruptedException; public void interrupt();public void interrupt(); public boolean isInterrupted();public boolean isInterrupted(); public static boolean interrupted();public static boolean interrupted(); public static Thread currentThread();public static Thread currentThread();

public static void dumpStack();public static void dumpStack(); public static void yield();public static void yield(); public static void sleep(long millis)public static void sleep(long millis) throws InterruptedException;throws InterruptedException; public static void sleep(long millis, int nanos)public static void sleep(long millis, int nanos) throws InterruptedException;throws InterruptedException; public void destroy(); }public void destroy(); }

Creating ThreadsCreating Threads

Option #1Option #1 Define a subclass of class Define a subclass of class ThreadThread Override the Override the runrun() method() method Create an instance of the subclassCreate an instance of the subclass Invoke the instance’s Invoke the instance’s startstart() method() method

Option #2Option #2 Define a class that implements the Define a class that implements the RunnableRunnable interface interface Implement the Implement the runrun() method() method Create an instance of the classCreate an instance of the class Pass the instance to the Thread class’ constructorPass the instance to the Thread class’ constructor Invoke the thread’s Invoke the thread’s startstart() method() method

Example of Creating a Thread:Option #1Example of Creating a Thread:Option #1

public class MyThread1 extends Thread {public class MyThread1 extends Thread {

public void run() { // do something useful }public void run() { // do something useful }

public static void main(String args[]) {public static void main(String args[]) {

MyThread1 myThread = new MyThread1( );MyThread1 myThread = new MyThread1( );

myThread.start();myThread.start();

} }

}} Option #1Define a subclass of class ThreadOverride the run() methodCreate an instance of the subclassInvoke the instance’s start() method

Example of Creating a Thread: Option #2Example of Creating a Thread: Option #2

public class MyThread2 implements Runnable {public class MyThread2 implements Runnable {

public void run( ) { // do something useful }public void run( ) { // do something useful }

public static void main(String args[]) {public static void main(String args[]) {

Thread myThread = new Thread(new MyThread2( ));Thread myThread = new Thread(new MyThread2( ));

myThread.start( );myThread.start( );

}}

}} Option #2Define a class that implements the Runnable interfaceImplement the run() methodCreate an instance of the classPass the instance to the Thread class’ constructorInvoke the thread’s start() method

Daemon ThreadsDaemon Threads

A utility thread for other threads (e.g., the garbage A utility thread for other threads (e.g., the garbage collector)collector)

Run in the backgroundRun in the background Their (live) existence does not prevent a program Their (live) existence does not prevent a program

from terminatingfrom terminating When the last non-daemon thread dies, the program When the last non-daemon thread dies, the program

exitsexits

Daemon status must be set before the thread startsDaemon status must be set before the thread starts

Running a ThreadRunning a Thread

JVM starts up, invokes some class’ main methodJVM starts up, invokes some class’ main method That class is started in a single, non-daemon threadThat class is started in a single, non-daemon thread

Eventually, a new thread gets created and its Eventually, a new thread gets created and its startstart() () method is invokedmethod is invoked Makes the thread readyMakes the thread ready

When selected by the JVM scheduler, the new thread’s When selected by the JVM scheduler, the new thread’s run method is invokedrun method is invoked Continues running until Continues running until runrun() returns, or aborts() returns, or aborts

Dead threads are eventually cleaned upDead threads are eventually cleaned up JVM continues until all non-daemon threads have JVM continues until all non-daemon threads have

stopped (died)stopped (died)

Making a Thread WaitMaking a Thread Wait

The currentThread can be put into a waiting state:The currentThread can be put into a waiting state: By invoking Thread.By invoking Thread.sleepsleep()() By performing an input/output requestBy performing an input/output request

The thread becomes ready when the I/O is finishedThe thread becomes ready when the I/O is finished

By invoking an Object’s By invoking an Object’s waitwait() method() method By the scheduler when a higher priority thread is By the scheduler when a higher priority thread is

selected to executeselected to execute E.g., the higher priority thread’s sleep period ends, its I/O E.g., the higher priority thread’s sleep period ends, its I/O

finishes, or it has been notified out of a wait invocationfinishes, or it has been notified out of a wait invocation

InterruptsInterrupts

A waiting Thread can be interrupted by A waiting Thread can be interrupted by explicitly invoking its explicitly invoking its interruptinterrupt() method() method

The interrupted thread moves from waiting The interrupted thread moves from waiting to ready stateto ready state

When selected for running, the interrupted When selected for running, the interrupted thread “jumps to” its InterruptedException thread “jumps to” its InterruptedException handlerhandler

Example of Handling an InterruptExample of Handling an Interrupt

public class MyThread extends Thread {public class MyThread extends Thread {......

void foo() {void foo() {

try {try {// do something// do something

sleep(10000);sleep(10000);

} catch (InterruptException x) {} catch (InterruptException x) {System.out.println(“Interrupted”);System.out.println(“Interrupted”);

}}

}}

}}

Thread SynchronizationThread Synchronization

An object with a An object with a synchronizedsynchronized method is a monitor method is a monitor e.g., public e.g., public synchronizedsynchronized void foo() { // do stuff } void foo() { // do stuff }

An object has a single lockAn object has a single lock The thread executing a The thread executing a synchronizedsynchronized method has that object’s method has that object’s

locklock Only one Only one synchronizedsynchronized method in a class can be active method in a class can be active

on an object at a timeon an object at a time All other threads that want to invoke any All other threads that want to invoke any synchronizedsynchronized method method

on that object must wait (there is only one lock for the entire on that object must wait (there is only one lock for the entire object)object)

When the synchronized method returns, the lock on that When the synchronized method returns, the lock on that object is releasedobject is released

Thread Synchronization (concluded)Thread Synchronization (concluded)

While executing a While executing a synchronizedsynchronized method, a thread might method, a thread might decide that it can’t proceed further and voluntarily give up decide that it can’t proceed further and voluntarily give up control by invoking the object’s control by invoking the object’s waitwait() method() method

When finished executing a When finished executing a synchronizedsynchronized method, a thread method, a thread can decide to invoke the object’s can decide to invoke the object’s notifynotify or or notifyAllnotifyAll method() to let other threads know that its donemethod() to let other threads know that its done

A thread that is waiting to get a lock on an object must A thread that is waiting to get a lock on an object must either be notified or interrupted (or it will wait forever)either be notified or interrupted (or it will wait forever)

Only call Only call waitwait(), (), notifynotify(), or (), or notifyAllnotifyAll() if you have a lock () if you have a lock on the object (e.g., are in a on the object (e.g., are in a synchronizedsynchronized method) method)

synchronized Static Methodssynchronized Static Methods

You can get a lock on a class (actually, the You can get a lock on a class (actually, the class’s Class object) by creating a class’s Class object) by creating a synchronizedsynchronized staticstatic method method

Only one thread can execute a (any) Only one thread can execute a (any) synchronizedsynchronized staticstatic method at a time method at a time

Synchronized BlocksSynchronized Blocks

Arbitrary code blocks (marked by braces { }) can Arbitrary code blocks (marked by braces { }) can be be synchronizedsynchronized

Syntax: Syntax: 1)1) synchronized synchronized (objectReference) { statements } (objectReference) { statements } 2)2) synchronized synchronized (className) { statements } (className) { statements }

The currentThread must have a lock on the object The currentThread must have a lock on the object (or class) before it can execute the statements(or class) before it can execute the statements

Can be used with any object/class, not just the one Can be used with any object/class, not just the one for the object/class of the method you’re infor the object/class of the method you’re in

class Object and Threadsclass Object and Threads

Class Class ObjectObject has three thread-related methods: has three thread-related methods: waitwait() - puts the running thread that invokes this () - puts the running thread that invokes this

method into a waiting statemethod into a waiting state notifynotify() - moves some other thread that is waiting on () - moves some other thread that is waiting on

that object into the ready statethat object into the ready state notifyAllnotifyAll() - moves all other threads that are waiting on () - moves all other threads that are waiting on

that object into the ready statethat object into the ready state

Every object has a Every object has a wait setwait set which is a list of which is a list of Threads that are waiting to get a lock on the objectThreads that are waiting to get a lock on the object

wait()wait()

May specify time period (or indefinite wait if 0 or May specify time period (or indefinite wait if 0 or none specified)none specified)

Must have a lock on the objectMust have a lock on the object Causes lock to be relinquishedCauses lock to be relinquished Puts the invoking thread into wait state until:Puts the invoking thread into wait state until:

Some other thread invokes notify (and this thread Some other thread invokes notify (and this thread happens to get picked) or notifyAllhappens to get picked) or notifyAll

Some other thread interrupts itSome other thread interrupts it The specified time period has elapsedThe specified time period has elapsed

It then goes into the ready (runnable) stateIt then goes into the ready (runnable) state

notify()notify()

Must have a lock on the objectMust have a lock on the object The invoking thread states its willingness to The invoking thread states its willingness to

relinquish its lock on the objectrelinquish its lock on the object Moves an arbitrary thread (at the discretion Moves an arbitrary thread (at the discretion

of the implementation) that is waiting on of the implementation) that is waiting on that lock from the waiting to the ready statethat lock from the waiting to the ready state The selected thread has no special priority in The selected thread has no special priority in

getting the lockgetting the lock

notifyAll()notifyAll()

Must have a lock on the objectMust have a lock on the object The invoking thread states its willingness to The invoking thread states its willingness to

relinquish its lock on the objectrelinquish its lock on the object Moves all threads that are waiting on that Moves all threads that are waiting on that

lock from the waiting to the ready statelock from the waiting to the ready state The threads have no special priority in getting The threads have no special priority in getting

the lockthe lock

java.lang.ThreadGroup java.lang.ThreadGroup

Every Thread belongs to exactly one ThreadGroupEvery Thread belongs to exactly one ThreadGroup There’s a default “system” ThreadGroupThere’s a default “system” ThreadGroup Can interrupt all Threads in a ThreadGroupCan interrupt all Threads in a ThreadGroup Can notifyAll Threads in a ThreadGroupCan notifyAll Threads in a ThreadGroup Can get/set the maxPriority of the Threads in a ThreadGroupCan get/set the maxPriority of the Threads in a ThreadGroup Can be a daemon ThreadGroup (Threads created by Can be a daemon ThreadGroup (Threads created by

referencing a daemon ThreadGrop in their constructor referencing a daemon ThreadGrop in their constructor become daemon Threads)become daemon Threads)

ThreadGroups can be hierarchical (can have one ThreadGroups can be hierarchical (can have one parent)parent) An invocation on the parent ThreadGroup is also called on An invocation on the parent ThreadGroup is also called on

all of its childrenall of its children

An Aside - the Class classAn Aside - the Class class

Objects of this class, called class Objects of this class, called class descriptors, are automatically created by the descriptors, are automatically created by the JVM when a class (or interface) is loadedJVM when a class (or interface) is loaded Accessed by an Object’s getClass methodAccessed by an Object’s getClass method Can get the class’s name, superclass, interfacesCan get the class’s name, superclass, interfaces Can create instances of the class (in lieu of Can create instances of the class (in lieu of

using the class’ constructors)using the class’ constructors) Can be locked for thread synchronization Can be locked for thread synchronization

purposespurposes