Introduction to

Java threads
Threads in Programming Languages

 Several programming languages have

provided constructs/abstractions for writing
concurrent programs
 Modula, Ada, etc.
 Java does it like it does everything else, by
providing a Thread class
 You create a thread object
 Then you can start the thread
Extending the Thread class
 To create a thread, you can extend the
thread class and override its “run()” method

class MyThread extends Thread {

public void run() {
...
}
...
}

myThread t = new MyThread();

Example

public class MyThread extends Thread {

public void run() {
for (int i=0; i<10; i++) {
System.out.println(“Hello world
#“+i);
}
}
...
}

myThread t = new MyThread();

Spawning a thread
 To launch, or spawn, a thread, you just call
the thread’s start() method
 WARNING: Don’t call the run() method
directly to launch a thread
 If you call the run() method directly, then you just
call some method of some object, and the
method executes
 Fine, but probably not what you want
 The start() method, which you should not
override, does all the thread launching
 It launches a thread that starts its execution by calling
the run() method
Example
public class MyThread extends Thread {
public void run() {
for (int i=0; i<5; i++) {
System.out.println(“Hello world #“+i);
}
}
}

public class MyProgram {

public MyProgram() {
MyThread t = new MyThread();
t.start();
}
public static void main(String args[]) {
MyProgram p = new MyProgram();
}
}
What happens
 The previous program runs as a process
 Running inside the JVM
 In fact, the program runs as a single thread within a process
 When the start() method is called, the process creates a new
thread
 We now have two threads
 The “main”, “original” thread
 The newly created thread
 Both threads are running
 The main thread doesn’t do anything
 The new thread prints messages to screen and exits
 When both threads are finished, then the process terminates
Example
 The previous example wasn’t very interesting
because the main thread did nothing
 Admittedly, this example is not interesting
because the program doesn’t do anything useful,
but we’ll get there eventually
 In fact, we could have achieved the same
result with no thread at all
 So, let’s have the main thread to something
Example
public class myThread extends Thread {
public void run() {
for (int i=0; i<5; i++)
System.out.println(“Hello world #“+i);
}
}

public class MyProgram {

public MyProgram() {
MyThread t = new MyThread();
t.start();
for (int i=0; i<5; i++)
System.out.println(“foo”);
}
public static void main(String args[]) {
MyProgram p = new MyProgram();
}
}
What happens?
 Now we have the main threads printing to the
screen and the new thread printing to the
screen
 Question: what will the output be?
 Answer: Impossible to tell for sure
 If you know the implementation of the JVM on
your particular machine, then you can probably
tell
 But if you write this code to be run anywhere,
then you can’t expect to know what happens
 Let’s look at what happens
Example Execution

 with this JVM, the new thread finishes

executing before the main thread moves on
to doing its work
Is it really concurrent?
 One may wonder whether the execution is
really concurrent
 At least falsely concurrent
 This can be verified by having threads run for
longer
 In the output that follows the new thread
prints “.” and the main thread prints “#”
Example Execution #1
Example Execution #2
Non-deterministic Execution
 The previous example shows what’s difficult
about thread programming, an especially
thread debugging: it may be difficult to tell
what the execution will look like
 Somebody decides when a thread runs
 You run for a while
 Now you run for a while
 ...
 This decision process is called scheduling
 Let’s look a little bit at the Thread class to
understand this better
The Thread class
package java.lang;

public class Thread implements Runnable {

public void start();
public void run();

public boolean isAlive();

public Thread.State getState();

public static void sleep(long millis);

public static void sleep(long millis,
long nanos);

// A bunch of other things we’ll discuss later

...
}
The isAlive() Method
 When you spawn a thread you may not really know when or
how it is going to terminate
 It may be useful to know
 To see if the thread’s work is done for instance
 The isAlive() method returns true is the thread is running,
false otherwise
 Could be useful to restart a thread

if (!t.isAlive()) {
t.start();
}
The getState() method
 The possible thread states are
 NEW: A thread that hasn’t been started yet
 RUNNABLE: The thread can be run, and may be running
as we speak
 It may not because another runnable thread could be running
 BLOCKED: The thread is blocked on a monitor

 WAITING: The thread is waiting for another thread to do

something

 TIMED_WAITING: The thread is waiting for another thread

to do something, but will give up after a specified time out
 TERMINATED: The thread’s run method has returned
Thread Lifecycle: 4 states

RUNNABLE
BLOCKED/
NEW not WAITING/
running running TIMED_WAITING

TERMINATED
Thread Lifecycle: 4 states

RUNNABLE
start() BLOCKED/
NEW not WAITING/
running running TIMED_WAITING

TERMINATED
Thread Lifecycle: 4 states
sleep()
block on I/O
wait()

RUNNABLE
start() BLOCKED/
NEW not WAITING/
running running TIMED_WAITING

TERMINATED
Thread Lifecycle: 4 states
sleep()
block on I/O
wait()

RUNNABLE
start() BLOCKED/
NEW not WAITING/
running running TIMED_WAITING

time elapsed
I/O done
notify()

TERMINATED
Thread Lifecycle: 4 states
sleep()
block on I/O
wait()

RUNNABLE
start() BLOCKED/
NEW not WAITING/
running running TIMED_WAITING

run() method time elapsed

returns I/O done
notify()

TERMINATED
So what?
 At this point, it seems that we throw a bunch of threads in,
and we don’t really know what happens
 To some extent it’s true, but we have ways to have some
control
 In particular, what happens in the RUNNABLE state?

RUNNABLE

not
running running

 Can we control how multiple RUNNABLE threads become

running or not running?
The yield() method: example
public class MyThread extends Thread {
public void run() {
for (int i=0; i<5; i++) {
System.out.println(“Hello world #“+i);
 With the yield() }
Thread.yield();

method, a thread will }

pause and give other }

RUNNABLE threads public class MyProgram {

public MyProgram() {
the opportunity to MyThread t = new MyThread();
execute for a while t.start();
for (int i=0; i<5; i++) {
System.out.println(“foo”);
Thread.yield();
}
}
public static void main(String args[]) {
MyProgram p = new MyProgram();
}
}
Example Execution
 The use of yield made the
threads’ executions more
interleaved
 Switching between threads is
more frequent
 But it’s still not
deterministic!
 Programs should NEVER
rely on yield() for
correctness
 yield() is really a “hint” to the
JVM
Thread Priorities
 The Thread class has a setPriority() and a
getPriority() method
 A new Thread inherits the priority of the thread
that created it
 Thread priorities are integers ranging
between Thread.MIN_PRIORITY(1) and
Thread.MAX_PRIORITY(10)
, Thread.NORM_PRIORITY(5)
The higher the integer, the higher the priority
Thread Priorities and Scheduling
 Whenever there is a choice between multiple runnable
threads, the JVM picks the higher priority one
 High priority threads may yield to prevent starvation of low-
priority threads
 The JVM is preemptive
 If a higher priority thread is started, it gets to run
 Modern JVMs (post green threads) use time slicing
 Threads of the highest priorities get chosen in a round-robin
fashion
 The use of yield() isn’t required but, as we saw, it can increase
the frequency of switching between threads
 In spite of all this:
 The JVM can only influence the way in which threads are
scheduled
 Ultimately, the decision is left to the O/S
So what?

 It is important to know the basics of thread

scheduling to understand the behavior of
concurrent programs

 One should NEVER rely on scheduling

aspects to ensure correctness of the program
 Since scheduling depends on the JVM and on the
O/S, correctness due to scheduling is not
portable
The join() method
 The join() method causes a thread to wait for
another thread’s termination
 This is useful for “dispatching” work to a
worker thread and waiting for it to be done
 Let’s see it used on an example
The Runnable Interface
 What if you want to create a thread that extends
some other class?
 e.g., a multi-threaded applet is at the same time a Thread
and an Applet
 Java does not allow for double inheritance
 Which is why it has the concept of interfaces
 So another way to create a thread is to have
runnable objects
 It’s actually the most common approach
 Allows to add inheritance in a slightly easier way after the
fact
 Let’s see this on an example
Runnable Example
public class MyTask implements Runnable {
public void run() {
for (int i=0; i<5; i++)
System.out.println(“Hello world #“+i);
}
}

public class MyProgram {

public MyProgram() {
Thread t = new Thread(new MyTask());
t.start();
for (int i=0; i<5; i++)
System.out.println(“foo”);
}
public static void main(String args[]) {
MyProgram p = new MyProgram();
}
}
Conclusion

 Two ways to create threads

 extends Thread
 implements Runnable

 Thread Scheduling is complex, not fully

deterministic, and should not be counted on
to guarantee program correctness