Java Threads

Lilin Zhong

Java Threads1. New threads2. Threads in the running state3. Sleeping threads and

interruptions4. Concurrent access problems and

solutions

Java Threads5. Signaling with wait, notify, and

notifyAll6. When threads freeze: deadlock7. Scheduling: problems and

solutions8. The end of the thread

Why Thread? ThreadJava threadsExample: Stockbroker

StockbrokerDownload last stock pricesCheck prices for warningsAnalyze historical data for company X

Tim

e

1

2

31 2 3

New Threads

Public void run();

Process Threads

New ThreadCreating a thread by: 1. Extending the Thread class2. Implementing the Runnable

interface

Creating a Thread by Extending the Thread Class

Declaringpublic 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 Threads1. New threads2. Threads in the running state

Threads in the Running State

Execute run methods concurrently;Cooperate, share resources, compete;Take turns to run;Switch.

Java Threads1. New threads2. Threads in the running state3. Sleeping threads and

interruptions

Sleeping Threads and Interruptions

-Thread.sleep(long n);e.g. Thread.sleep(5*60*1000);-sleepingThread.interrupt();

Java Threads1. New threads2. Threads in the running state3. Sleeping threads and

interruptions4. 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.

VolatileVset get

1 V(1) copy

Tim

e

V(2) 2copyVV

1 2

public class transfer{private Object value;public set(value){ this.value=value; }public Object get(){ return value; }

}

setget

Volatile

VVTi

me 1

2

setget

V1 2

public class transfer{private volatile Object value;public set(value){ this.value=value; }public Object get(){ return value; }

}

set get

SynchronizedTi

me

Thread 1 Thread 2

Current Thread Waiting Thread

L1

L1

Synchronized block

Synchronizedpublic 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 Threads1. New threads2. Threads in the running state3. Sleeping threads and interruptions4. Concurrent access problems and

solutions5. Signaling with wait, notify, and

notifyAll

Signaling With Wait, Notify, and notifyAll

Using wait and notify by two interdependent threadsUsing 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 occurredvoid notifyAll() Notifies all the threads waiting for a

condition that the condition has occurred

Wait, Notifysynchronized(this){ try{ wait(); }catch(InterruptedException e){} }

synchronized(this){ notify();}

L1

Tim

e

Current ThreadWaiting Thread

L1

L1

NotifyAllPublic 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}

NotifyAllPublic synchronized Object read() throwsInterruptedException { while (item==null) wait(); Object myItem=item; item=null; notifyAll(); // multiple readers,

// notifyAll ensures writer notification return myItem; }}

Java Threads6. When threads freeze:

deadlock

When Threads Freeze: Deadlock

Tim

e

Thread 1 Thread 2

L1

Current ThreadWaiting Thread

L2

L1

L2

Blocks here waiting for L1

Blocks here waiting for L2

Java Threads6. When threads freeze: deadlock7. Scheduling: problems and

solutions

Scheduling: Problem and Solution

When does the current thread lose its turn at CPU: Yield()

Thread.yield(); //will give up the turn on the CPU

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 1 NORM_PRIORITY 5 MAX_PRIORITY 10

Java Threads6. When threads freeze: deadlock7. Scheduling: problems and

solutions8. The end of the thread

The End of The ThreadSystem.exit(n)Returning from run methodThrowing an unchecked exceptionBlocked by I/Oothers

SummaryHow 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.

SummaryHow 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 WongMultithreaded programming with Java technology, Bil Lewis & Daniel J. BergTeaching yourself Java 1.2 in 21 days, Laura Lemay & Rogers CadenheadJava How to program, third edition, Deitel & DeitelJava 2 certificate