Java Threads
Lilin Zhong
Java Threads
1.
2.
3.
4.
New threads
Threads in the running state
Sleeping threads and interruptions
Concurrent access problems and
solutions
Java Threads
5. Signaling with wait, notify, and notifyAll
6. When threads freeze: deadlock
7. Scheduling: problems and solutions
8. The end of the thread
Why Thread?
Thread
Java threads
Example: Stockbroker
Stockbroker
Download last stock prices
Check prices for warnings
Analyze historical data for company X
Time
1
2
3
1
2
3
New Threads
Process
Public void run();
Threads
New Thread
Creating a thread by:
1. Extending the Thread class
2. Implementing the Runnable
interface
Creating a Thread by
Extending the Thread Class
Declaring
public class MyThread extends Thread{
public void run(){
// Your instructions here
}
}
Instantiating
- MyThread testThread=new MyThread();
By Implementing the
Runnable Interface
Defining
- public class MyRunnable implements Runnable{
public void run(){
// Your instructions here}
}
Instantiating
- MyRunnable firstRunnable = new MyRunnable;
- Thread testThread = new Thread (firstRunnable);
Starting an Instance of a
Thread
testThread.start();
Java Threads
1. New threads
2. Threads in the running state
Threads in the Running State
Execute run methods concurrently;
Cooperate, share resources, compete;
Take turns to run;
Switch.
Java Threads
1. New threads
2. Threads in the running state
3. Sleeping threads and
interruptions
Sleeping Threads and
Interruptions
-Thread.sleep(long n);
e.g. Thread.sleep(5*60*1000);
-sleepingThread.interrupt();
Java Threads
1. New threads
2. Threads in the running state
3. Sleeping threads and interruptions
4. Concurrent access problems and
solutions
Concurrent Access Problems
and Solutions
- e.g. i++;
- bring “i” to register;
- add 1 to register;
- store register onto “i”.
ways to solve the problems:


Using volatile to transmit single variables
between two threads.
Using synchronized to transmit groups of
variables among multiple threads.
Volatile
set
1
get
V
2
Time
public class transfer{
private Object value;
public set(value){ this.value=value; }
public Object get(){ return value; }
}
1
set
V(1)
copy
V
V
copy
V(2)
get
2
Volatile
1
set
V
get
2
Time
public class transfer{
private volatile Object value;
public set(value){ this.value=value; }
public Object get(){ return value; }
}
1
set
V
V
get
2
Synchronized
Thread 1
Thread 2
L1
Time
Synchronized
block
L1
Current Thread
Waiting Thread
Synchronized
public class StatusInfo{
private float temperature, pressure, nitroConcentration;
public synchronized void update
(float temperature, float pressure, float nitroConcentration){
this.temperature=temperature;
this.pressure=pressure;
this.nitroConcentration=nitroConcentration;
}
public synchronized void analyze(){
if (isDangerousCombination
(temperature, pressure, nitroConcentration);
stopManufacture();
}
}
Java Threads
1.
2.
3.
4.
New threads
Threads in the running state
Sleeping threads and interruptions
Concurrent access problems and
solutions
5. Signaling with wait, notify, and
notifyAll
Signaling With Wait, Notify,
and notifyAll
Using wait and notify by two
interdependent threads
Using notifyAll when many threads may
be waiting
Signaling With Wait, Notify,
and notifyAll
void wait()

Waits for a condition to occur
void notify()

Notifies a thread that is waiting for a condition
that the condition has occurred
void notifyAll()

Notifies all the threads waiting for a condition that
the condition has occurred
Wait, Notify
synchronized(this){
notify();
}
L1
L1
Time
synchronized(this){
try{
wait();
}catch(InterruptedException e){}
}
L1
Current Thread
Waiting Thread
NotifyAll
Public class Multiplewriters{
private Object item;
public synchronized void write(Object o) throws
InterruptedException{
while (item!=null) wait();
item=o;
notify(); // single writer, notifying one reader
// is sufficient
}
NotifyAll
Public synchronized Object read() throws
InterruptedException {
while (item==null) wait();
Object myItem=item;
item=null;
notifyAll(); // multiple readers,
// notifyAll ensures writer notification
return myItem;
}
}
Java Threads
6. When threads freeze: deadlock
When Threads Freeze:
Deadlock
Thread 1
Thread 2
L1
Time
L2
L1
L2
Blocks here
waiting for L1
Blocks here
waiting for L2
Current Thread
Waiting Thread
Java Threads
6. When threads freeze: deadlock
7. Scheduling: problems and solutions
Scheduling: Problem and
Solution
When does the current thread lose its
turn at CPU:

Yield()
 Thread.yield();
CPU



//will give up the turn on the
Sleep, wait, or blocked by I/O
Priority
“time-slicing”
Scheduling: Problem and
Solution
Which thread will be the next to
execute?

Specify the priority of threads
 setPriority(int n) n=1 to 10

Main
5
 Static final ints:



MIN_PRIORITY
NORM_PRIORITY
MAX_PRIORITY
1
5
10
Java Threads
6. When threads freeze: deadlock
7. Scheduling: problems and solutions
8. The end of the thread
The End of The Thread
System.exit(n)
Returning from run method
Throwing an unchecked exception
Blocked by I/O
others
Summary
How create threads by extending Thread and
by implementing Runnable, and how to start
them.
How to share information effectively, threads
use synchronized blocks of code.
Summary
How to coordinate activity through time,
using wait/notify model.
What different thread states ( new, dead)
are, when threads go in and out of sleeping,
waiting, blocking on I/O, and acquiring lock
states.
Example: Neko
http://www.naviseek.com/book/java21/day10.shtml
Neko12.java
Neko.html
References:
Java Threads, 2nd Edition, Scott Oaks & Henry Wong
Multithreaded programming with Java technology, Bil
Lewis & Daniel J. Berg
Teaching yourself Java 1.2 in 21 days, Laura Lemay &
Rogers Cadenhead
Java How to program, third edition, Deitel & Deitel
Java 2 certificate