Multithreading In Java

Multithreading
Parag Shah
Adaptive Software Solutions
http://www.adaptivelearningonline.net

Agenda
Multithreading concepts
Creating threads
Controlling threads
Thread states
Summary

Creating threads
Controlling threads
Thread states
Summary

Need for concurrency
Multi processing
Multi threading
Multi threading makes user interfaces more responsive
Multi threading makes better utilization of time when the program is blocking for IO

Creating Threads
A thread represents code that will be run concurrently with other code in the same process
Creating a thread
Use the Thread class
Use the Runnable interface
Pros and Cons
Extending thread is simpler
Implementing Runnable allows subclassing other classes

Creating Threads – Extending Thread
Extend java.lang.Thread
Implement the run method
See [SimpleThread.java]

Creating Threads – Implementing Runnable
Extend java.lang.Thread
Implement the run mthod
See [SimpleRunnable.java]
A Runnable cannot throw a checked exception

Thread Priorities
Priorities are between 1 – 10
Best to use the constants defined in Thread
MAX_PRIORITY
MIN_PRIORITY
NORM_PRIORITY
Uses of thread priority

States Of A Thread
A thread can be in any one of these 4 states
New: The thread object has been created but it has not been initialized
Runnable: The thread object is ready to run whenever the CPU gives it a time slot
Blocked: The thread could be run, but is currently not in a runnable state
Dead: The thread has terminated

Controlling Thread Behavior
Yielding
Sleeping
Setting Priorities
Joining

Controlling Thread Behavior Yielding
A thread can be made to yield when it comes to a point when the CPU can be relinquished to another thread
Yielding is done by calling the yield() method
A call to yield() is a hint to the underlying operating system. It does not guarantee that the CPU will be immediately given to another thread
See [SimpleYieldingThread.java]

Controlling Thread Behavior Sleeping
A thread can be put to sleep for xxx ms
Use the sleep(long x) call on the thread to put it to sleep for x ms
The thread is guaranteed to sleep for x ms
It may take more than that for the scheduler to give it control
It may be interrupted by another thread
See [SimpleThread.java]

Controlling Thread Behavior Priorities
Every thread can have a priority
Scheduler will choose thread with highest priority for running first
Exact mechanism of choosing the thread is indeterminate
JDK supports 10 priority levels
For portability it is best to use one of the predefined (MAX_PRIORITY, NORM_PRIORITY, MIN_PRIORITY) priority levels

Controlling Thread Behavior Joining Another Thread
Joining a thread is the process of suspending till the other thread completes execution
Join can be called with or without a timeout
Exercise SimpleJoiningThread.java

Some Deprecated Methods
Deprecated methods
suspend & resume
stop & destroy
These methods are deadlock prone
An alternate mechanism for stopping threads

Sharing Resources In A Multithreaded Environment
Multiple threads may try to access the same resource
The point at which a thread will be suspended and another will resume is indeterminate
A thread may not have finished totally processing a data structure before it is suspended.
Another thread accessing the same data structure may find it in an improper state

Controlling Access To Shared Resources
Put the shared resource in an object
Make all methods in the object which access the shared resource, synchronized
Every object has a lock (monitor)
Before a thread enters a synchronized method it must obtain the lock
The lock is released when the thread leaves the synchronized method
Only one thread can have a lock to an object at a time
Synchronize a critical section on an object

Atomic Operations
Atomic operations are those operations that are guaranteed to be completed before a context switch
Simple assignments and 'returning values' are some atomic operations
An exception is when dealing with double and long values
Be careful while omitting the synchronized keyword when multiple methods are accessing the shared resource

Thread Blocking
A thread can be blocked due to one of the following reasons
It is waiting for I/O
It has called its sleep(long ms)
It has called the wait method
The thread has called join on another thread
The thread has called a synchronized method/block on another object and the lock is unavailable

Using wait() and notify() with threads
sleep(long ms) does not release the locks held by that thread
Use wait() with notify() or notifyAll() instead
See [WaitNotifyThread.java]

Deadlock
What is deadlock
The dining philosophers problem
Conditions for a deadlock to occur
At least one resource used by threads is not shareable
At least one thread holds a resource and is waiting on another resource which is being held by another thread
A resource cannot be taken away from a thread
A circular wait happens

Threading In JDK 1.5
JDK 1.5 has increased support for threading
Has a new concurrency packages
java.util.concurrent
java.util.concurrent.atomic
java.util.concurrent.locks

Summary
It is important to understand when to use threads
Caution must be exercised while writing multi-threaded code
Thorough testing is recommended
It is important to understand which classes and methods should be made thread safe

Where to Get More Information
Bruce Eckel's – Thinking In Java
Taming Java Threads – Allen Holub

http://www.riskbuzz.aggile.net	254
http://www.slideshare.net	44

Multithreading In Java

by parag on Jan 15, 2007

Accessibility

Categories

Tags

Upload Details

Usage Rights

2 Embeds 298

Statistics

Multithreading In Java — Presentation Transcript