Concurrent Programming CS 598 Class Notes

Lecture Notes for Concurrent Programming

1 July 2003 - Java Threads

Java Threads

Java Concurrency
Threads
Runnables
Thread Termination
Thread Control
Thread Status

Java Concurrency

Each Java thread is like a sequential Java program.
A collection of Java threads is a concurrent Java program.
There is no global state for a thread to access.
- A thread accesses (references to) class instances.
- Threads may share access to (references to) class instances.
The JVM is a weak concurrent system.
- Weak systems make fewer promises, less useful promises.
- Weak systems are easy to build, but hard to use.
- Weak systems allow much variation among implementations.
- Also, the JVM is not a well-defined weak system.

Threads

Like most things in Java, a thread is an instance of a class.
- The Thread class, which is rarely subclassed.
A Thread instance represents a generic execution engine.
- By default, threads do no useful computations.
Create a thread with new, like any Java class instance.
- A thread is dormant when created.
Calling t.start() starts thread t executing.
Thread t does work by calling t.run().
- Whatever goes on inside t.run() is the real work of the thread.
There are many other thread constructors, members and fields.

Runnables

The Runnable interface represents computations to be performed.
- Runnable instances don't have computational resources.

run() does the work.

When called, performs whatever computation is required.

public MyRunnable 
implements Runnable {
  public void run() {
    System.out.println("Hello world!");
    }
  }

Threads and Runnables

Threads and runnables are complimentary.
- Threads have the ability but don't have the knowledge.
- Runnables have the knowledge but don't have the ability.
The combination of Threads and Runnables leads to concurrent Java programs.
The Thread class implements the Runnable interface.
Runnables are defined in java.lang.Runnable
The thread-default Runnable implementation does nothing.

Thread and Runnable Example

Define a Runnable class, and create and instance of it.

class
HelloRunnable 
implements Runnable {

  public void
  run() {
    System.out.println("Hello world!");
    }
  }

HelloRunnable helloRunnable = new HelloRunnable();

Create a thread containing the runnable instance.
- Use the Thread(Runnable) constructor.
```
Thread helloThread = new Thread(helloRunnable);
```
Call the thread.
```
h elloThread.start()
```
See the complete code.

Just Threads

Because Thread implements Runnable, a Runnable instance isn't necessary.

Override the default Thread.run() to do the work.

class HelloThread extends Thread {

  public void 
  run() {
    System.out.println("Hello world!");
    }
  }

Create and call a thread instance.

HelloThread HelloThread = new HelloThread();
HelloThread.start();

Favor implementing Runnables over extending Threads.
- Different concepts should be keep different.
- Easier to reuse Runnables than Threads.
  - Runnables are simpler, have less overhead.
See the complete code.

Thread Termination

Thread t terminates when t.run() returns.
Once a thread terminates, it can't be restarted.
- start() throws an IllegalThreadStateException called on a terminated thread.
- t's runnable (if explicit) is another matter.
Threads are garbage collected, with all the problems that entails.
- Timeliness (finalization and all that).
- Forgotten and unneeded thread references.
Inducing premature termination is a tricky and delicate matter.
- Exceptions are not the answer.
- Better left to the Runnable implementation.

Thread Termination Methods

t.stop() asynchronously terminates thread t.
- The stopped thread has no opportunity to clean up.
- Locks held by the stopped thread are released.
- Depreciated as of Java 1.2.
t.destroy() immediately terminates thread t.
- The destroyed thread has no opportunity to clean up.
- Locks held by the destroyed thread are not released.
- Never implemented.
The ThreadDeath exception.
- Used by t.stop() to terminate t.
Don't use any of these.
- Make termination a synchronization condition in your Runnable.

Thread Control

Do not control threads directly; control the Runnables they execute.
Take mutual exclusion, for example.
- Mutual exclusion via maximum thread priority to get is a bad idea.
  - The JVM scheduler may ignore priority.
  - Coarse grained.
  - Difficult to enforce globally.
- Mutual exclusion via semaphores (or something) is a good idea.
  - Done in the Runnable with complete control.
  - Proper granularity.
  - Enforcement meshed with access.
Threads run asynchronously; their state is unknown.
- They may hold resources, be in a critical region.
- Disturbing a thread in a delicate state can lead to trouble.

Thread Control Methods

t.suspend() suspends thread t's execution.
- t may be in a critical region or hold locks.
- t.resume() continues t's execution.
- Both are depreciated; don't use them.
t.yield() cedes execution to some other thread.
- A hint only, the JVM may ignore it.
- Mostly useless; don't use it.
t.setPriority(int) sets thread t's priority to the given value.
- Another hint; the JFM may ignore it.
- t.setPriority(Thread.MAX_PRIORITY) does not implement atomicity.
- Priority is mostly useless; don't use it.
t.sleep(long) suspends thread t's execution for at least the given number of milliseconds.
- The delay may be longer; milliseconds may differ.

Thread Status

Thread status is tricky to deal with.
- Status is asynchronous, changing unpredictably.
- Thread t can easily interfere with its status.
Don't write code that depends on thread status.
- Concentrate instead on the task's status.
- Replace thread status with task synchronization.
Example - waiting for n threads to terminate.
- Waiting for each thread's termination status is a bad idea.
  - Other threads may steal the status.
  - Handling runaway threads difficult.
- Synchronizing on a shared counter is a good idea.
  - A specific class instance can't be intercepted.
  - Providing alternate behaviors, such as timeouts, is possible.
Status (thread name, in particular) is most useful when debugging.

Thread Status Methods

currentThread() returns a reference to the calling thread.
- But not the runnable.
t.join() blocks the calling thread until thread t terminates.
- There's no value passed between joining and joined thread.
t.isAlive() returns true iff thread t is alive.
- Mostly useless because it suffers from interference.
- On the other hand, once terminated, a thread stays terminated.
t.getName() returns thread t's print name.
- Set by t.setName(String) or by the Thread Thread(String).

Points to Remember

Threads are virtual machines; Runnables are the programs they run.
- Understand and exploit the differences.
Avoid subclassing Thread to eliminate Runnables.
- This confuses two concepts better kept separate.
There's a small number of useful methods in Thread and Runnable.
- start() will get you far.
Understand why you shouldn't use various unsafe methods.
- If you don't understand, you'll make the same mistakes.
Don't control threads, control tasks via Runnables.
- Greater control, and less contact with the weak JVM.

This page last modified on 1 July 2003.