Download Threads - IT Knowledge Base

Threads
Overview
Problem
Multiple tasks for computer
 Draw & display images on screen
 Check keyboard & mouse input
 Send & receive data on network
 Read & write files to disk
 Perform useful computation (editor, browser, game)
How does computer do everything at once?
 Multitasking
 Multiprocessing
Multitasking (Time-Sharing)

Multithreading allows two parts of the same program to run
concurrently

Marathon runners sometimes are faced with a dilemma when two major
races fall during the same week because they have to choose which race
to run in.

They probably wish there was a way a part of them could go to one
race and another part to the other race.

That can’t happen—that is, unless the runner is a Java program,
because two parts of the same Java program can run concurrently by
using multithreading.
Multitasking










Multitasking is performing two or more tasks at the same time.
Nearly all operating systems are capable of multitasking by using one of two
multitasking techniques:
process-based multitasking and
thread-based multitasking.
Process-based multitasking is running two programs concurrently.
Programmers refer to a program as a process.
Therefore, you could say that process-based multitasking is program-based
multitasking.
Thread-based multitasking is having a program perform two tasks at the same
time. For example, a word processing program can check the spelling of words
in a document while you write the document.
This is thread-based multitasking.
A good way to remember the difference between process-based multitasking
and thread-based multitasking is to think of process-based as working with
multiple programs and thread-based as working with parts of one program.








The objective of multitasking is to utilize the idle time of the CPU.
Think of the CPU as the engine of your car.
Your engine keeps running regardless of whether the car is moving.
Your objective is to keep your car moving as much as possible so you can get
the most miles from a gallon of gas.
An idling engine wastes gas.
The same concept applies to the CPU in your computer.
You want your CPU cycles to be processing instructions and data rather than
waiting for something to process.
A CPU cycle is somewhat similar to your engine running.
Overhead








Process-based multitasking has a larger overhead than thread-based
multitasking.
In process-based multitasking, each process requires its own address space in
memory.
The operating system requires a significant amount of CPU time to switch from
one process to another process.
Programmers call this context switching, where each process (program) is a
context.
Additional resources are needed for each process to communicate with each
other.
In comparison, the threads in thread-based multitasking share the same
address space in memory because they share the same program.
This also has an impact on context switching, because switching from one part
of the program to another happens within the same address space in memory.
Likewise, communication among parts of the program happens within the same
memory location.
Threads








A thread is part of a program that is running.
Thread-based multitasking has multiple threads running at the same
time (that is, multiple parts of a program running concurrently).
Each thread is a different path of execution.
Let’s return to the word processing program example to see how
threads are used.
Two parts of the word processor are of interest:
The first is the part of the program that receives characters from the
keyboard, saves them in memory, and displays them on the screen.
The second part is the portion of the program that checks spelling.
Each part is a thread that executes independently of each other, even
though they are part of the same program.








While one thread receives and processes characters entered into the
keyboard, the other thread sleeps.
That is, the other thread pauses until the CPU is idle.
The CPU is normally idle between keystrokes.
It is this time period when the spell checker thread awakens and
continues to check the spelling of the document.
The spell checker thread once again pauses when the next character is
entered into the keyboard.
The Java run-time environment manages threads, unlike in processbased multitasking where the operating system manages switching
between programs.
Threads are processed asynchronously.
This means that one thread can pause while other threads continue to
process.
Java Threads

Java threads are managed by the JVM

Java threads may be created by:


Extending Thread class
Implementing the Runnable interface
Defining and Starting a Thread





An application that creates an instance of Thread must provide the code
that will run in that thread.
There are two ways to do this:
Provide a Runnable object.
The Runnable interface defines a single method, run, meant to contain
the code executed in the thread.
The Runnable object is passed to the Thread constructor, as in the
HelloRunnable example:

An application can subclass Thread, providing its own implementation of run,
as in the HelloThread example:

The Thread class itself implements Runnable, though its run method does
nothing.

Notice that both examples invoke Thread.start in order to start the new thread.

Which of these idioms should you use?

The first idiom, which employs a Runnable object, is more general, because the
Runnable object can subclass a class other than Thread.

The second idiom is easier to use in simple applications, but is limited by the
fact that your task class must be a descendant of Thread.

The Thread class defines a number of methods useful for
thread management.

These include static methods, which provide information
about, or affect the status of, the thread invoking the
method.

The other methods are invoked from other threads
involved in managing the thread and Thread object.

We'll examine some of these methods in the following
sections.
public class Thread {
public Thread(Runnable R); // Thread ⇒ R.run()
public Thread(Runnable R, String name);
public void start(); // begin thread execution
...
}
More Thread Class Methods
public class Thread
{
public void run();
public void start();
public String getName();
public void interrupt();
public boolean isAlive();
public void join();
public void setDaemon(boolean on);
public void setName(String name);
public void setPriority(int level);
public int getPriority();
public static Thread currentThread();
public static void sleep(long milliseconds);
public static void yield();
}
Thread States







Java thread can be in one of these states:
New
– thread allocated & waiting for start()
Runnable
– thread can execute
Blocked
– thread waiting for event (I/O, etc.)
Terminated
– thread finished
Transitions between states caused by Invoking methods in class Thread
start(), yield(), sleep()
Other (external) events
Scheduler, I/O, returning from run()…
Java Thread States
Pausing Execution with Sleep



Thread.sleep causes the current thread to suspend execution for a specified
period.
This is an efficient means of making processor time available to the other
threads of an application or other applications that might be running on a
computer system.
The sleep method can also be used for pacing, and waiting for another thread
with duties that are understood to have time requirements.







Two overloaded versions of sleep are provided:
one that specifies the sleep time to the millisecond and
one that specifies the sleep time to the nanosecond.
However, these sleep times are not guaranteed to be
precise, because they are limited by the facilities provided
by the underlying OS.
Also, the sleep period can be terminated by interrupts, as
we'll see in a later section.
In any case, you cannot assume that invoking sleep will
suspend the thread for precisely the time period specified.
The SleepMessage example uses sleep to print messages
at four-second intervals:
Notice that main declares that it throws InterruptedException.
 This is an exception that sleep throws when another thread interrupts the
current thread while sleep is active.
 Since this application has not defined another thread to cause the interrupt, it
doesn't bother to catch InterruptedException.
 Example
Creating Multiple Thread

Example
isAlive() and join()






How can one thread know when another thread has ended?
Two ways to know this.
Call isAlive() on thread that returns true if the thread is still running false
otherwise.
Use join() that waits until the thread terminates.
It is also used to specify a maximum amount of time to wait for the specified
thread to terminate.
Example
Thread Priorities







Higher priority threads get more CPU time than lower priority threads.
public void setPriority(int level)
Level must be in between MIN_PRIORITY(1) & MAX_PRIORITY(10).
NORM_PRIORITY(5).
These are final variables of Thread class.
public int getPriority()
Example
Suspending, Resuming and Stopping Threads







Thread class defines suspend(), resume() and stop().
These cant be used now in java 2.0.
How to pause, restart and terminate the thread.
A thread is designed so that run() periodically checks to
determine whether that thread should be suspended,
resume or stop its own execution.
It can be done by a flag value that indicates the execution
state of the thread.
wait() and notify() can be used along with the flag.
Example
Synchronization








When two or more threads need access to a shared resource, they need
some way to ensure that the resource will be used by only one thread at
a time.
The process by which this is achieved is known as synchronization.
For this monitor (semaphore) is used.
A monitor is an object that is used as a mutually exclusive lock
(mutex).
Only one thread can own a monitor at a given time.
When a thread acquires a lock it is said to have entered the monitor.
All other threads attempting to enter the locked monitor will be
suspended until the first thread exits the monitor.
These other threads are said to be waiting for the monitor.
Using Synchronized Methods








All java objects have their own implicit monitor associated with them.
To enter an object’s monitor, just call a method that has been modified
with keyword synchronized.
Synchronized keyword guard the state from race condition (i.e. more
than one thread are racing each other to complete the task.)
Once a thread enters any synchronized method on an instance, no other
thread can enter any other synchronized method on the same instance.
However non-synchronized method can be callable on that instance.
Simple Example
Example without synchronized
Example by using synchronization
Inter threaded Communication










Inter process communication
It is done via wait(), notify(), and notifyAll() methods.
These methods are implemented as “final” in Object; so all classes have these
methods.
All three methods can be called only from within a synchronized method.
wait() tells the calling thread to give up the monitor and go to sleep until some
other thread enters the same monitor and calls notify().
notify() wakes up the first thread that called wait() on same object.
notifyAll() wakes up all the threads that called wait() on same object. The
highest priority thread will run first.
final void wait() throws InterruptedException
final void notify()
Example
final void notifyAll()