Objectives

Java has a built-in multithreading model

learn when to use it

learn when not to use it

learn how to use it

Concepts of Concurrency

Multitasking, multithreading, oh my!

Concepts

Why go concurrent?

Concepts

Concurrency carries with it some costs

most systems have two characteristics:

small # of CPUs

large # of concurrent tasks to run

so we "task-switch"

task-switching carries overhead

for any collection of work "w", dividing it into "n" parts and running them simultaneously takes longer due to the task-switch time "q" ("quantum")

Concepts

So why do it?

"wait time"

while the CPU is waiting for a result, let other tasks run

"cancellation"/responsiveness

while a task is waiting for a result, keep the UI (or other foreground activities) responsive

segregation of work

some problems lend themselves naturally to being seen as separate-yet-connected sequences

"massively parallel" problems

shifts in hardware/CPU design

Java Threading

Walking and chewing gum at the same time

java.lang.Thread

java.lang.Thread: Java thread object

may or may not be backed by "real" thread

this is entirely up to the Java VM implementation; most are 1:1 ("native"), some are m:n, few are n:1 ("green")

fairly simple API model

java.lang.Thread

Creating new thread

either subclass Thread & override run()...

... or construct Thread & pass in a Runnable

of the two, the latter is far preferred

java.lang.Thread

Starting the thread

either way, call start() to begin the thread's processing

no guarantees regarding scheduling

java.lang.Thread


Thread t = new Thread(new Runnable() {
  public void run() {
    System.out.println("Howdy, new Thread!");
  }
};
Thread t2 = new Thread( () => System.out.println("Or lambda!") );
t.start();
t2.start();

java.lang.Thread

Foreground vs. background

JVM will not die until all foreground threads terminate

to set Thread to background status, setDaemon(true)

must be done before call to start()

java.lang.Thread

Thread priority determines scheduling

higher-priority thread gets first crack at CPU

Thread priorities range from 1 (MIN) to 10 (MAX)

default priority is 5 (NORM)

Threads inherit priority of parent Thread

manipulatable after start

java.lang.Thread

Thread lifecycle

Thread is either runnable or not-runnable

in other words, is Thread being scheduled?

runnable does not imply running

Thread could be blocked or waiting

not-runnable does not imply "dead"

Thread could be waiting to be started... or paused...

but once dead, Thread remains dead

java.lang.Thread

From the outside of the Thread...

... wait for it to finish using join()

... get stack trace (StackTraceElement)

... get name, state, priority, etc.

... suspend, resume, stop, destroy (deprecated!)

java.lang.Thread

Threads complete in one of several ways

simple completion

run() completes

voluntary suicide watch

track a variable for signal to complete

(but beware the thread cache!)

interruption

via Thread.interrupt() & InterruptedException

forced termination

via Thread.stop(), which is dangerous

stop() can take a Throwable to throw on Thread

java.lang.Thread

Exceptions & Threads

what happens if an exception is thrown inside Thread?

spawning Thread gets no signal

in JDK 5, can set unhandled exception handler

implement Thread.UncaughtExceptionHandler

pass in to setUncaughtExceptionHandler

java.lang.ThreadGroup

ThreadGroup was intended as administrative construct to manage groups of Threads

turned out to be pretty un-useful

turned out also to have some implementation "issues"

largely deprecated and not used

except for human logging/administrative purposes

java.util.concurrent.Callable

Callable provides result & exception API

Runnable cannot take parameters, returns void, cannot throw an exception

traditional workaround was to create a class that held fields as parameters, a field as the result, and caught checked exceptions & re-threw them unchecked

Callable should be refactored into place instead of Runnable in most situations

java.util.concurrent.Future

Future tracks pending results

allows developer to check results later, without worrying about complicated synchronization

get() returns value (blocking if incomplete)

cancel() attempts to cancel operation

isDone() returns true if complete (non-blocking)

Two subtypes of interest

FutureTask provides base implementation

Delayed indicates delay before execution

java.util.concurrent.Executor

Executor

created to decouple the launching of tasks from the management of Thread objects directly

execute() takes Runnable, executes it

actual behavior depends on Executor implementation

java.util.concurrent.ExecutorService

ExecutorService

generally a superior tool to use

assumes that the threads want to be tracked and massaged

submit() returns Future representing future results

shutdown() stops accepting new tasks

awaitTermination() blocks until all tasks complete

shutdownNow() terminates running tasks

Synchronization