threads
Download
Skip this Video
Download Presentation
Threads

Loading in 2 Seconds...

play fullscreen
1 / 28

Threads - PowerPoint PPT Presentation


  • 164 Views
  • Uploaded on

Threads. A thread is single sequence of executable statements within a program eg.) a typical application is a thread, with the flow of control beginning with the first statement in the main method

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Threads' - nenet


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
threads
Threads
  • A thread is single sequence of executable statements within a program
  • eg.) a typical application is a thread, with

the flow of control beginning with the first statement in the main method

Although there are control structures and method invocations involved, you can trace the sequential flow of execution from one statement to the next.

threads2
Threads
  • Java supports concurrent processes (multi-thread programs)
  • Single CPU handles this by alternating its resources between threads (managed by JVM and operating system)
  • The JVM is itself a multithreaded program (the garbage collector is a thread, which reclaims memory taken up by objects that are not being used)
steps to writing a thread class
Steps to Writing a Thread Class
  • Implement a class that extends the Thread class
  • You will inherit a start() method and a run() method
  • Override the run() method and place the code for your task into the run() method of your class
  • A code in your run() method will be executed in a new Thread once an object of this type has been instantiated, and the start() method has been called.
  • Do NOT call the run method directly, this will not start a new thread……
slide4
Example:

public class NumberThread extends Thread {

private int num;

private int total;

public NumberThread(int n, int ttl) {

num = n;

total = ttl;

}

//this code will run in it’s own thread

//when ‘started’

public void run(){

for (int count = 0; count < total; count++)

System.out.println(num);

}

}

slide5
public class Numbers {

public static void main (String[] args){

NumberThread numOne, numTwo, numThree;

numOne = new NumberThread(11,10);

numTwo = new NumberThread(22,10);

numThree = new NumberThread(33,10);

numOne.start();

numTwo.start();

numThree.start();

}

}

slide6
You can convert any class to a Thread by having that class implement the Runnable interface…and then using the Thread constructor: Thread (Runnable r)

If our NumberThread class implemented Runnable,

we would start our Thread in this manner:

NumberThread num1 = new NumberThread(20,15);

Thread th1 = new Thread (num1);

th1.start();

stopping a thread
Stopping a Thread
  • To stop a thread, you must interrupt it.

public static void main (String[] args){

NumberThread numOne, numTwo, numThree;

numOne = new NumberThread(11,10);

numTwo = new NumberThread(22,10);

numThree = new NumberThread(33,10);

numOne.start();

numTwo.start();

numThree.start();

…….

numTwo.interrupt();

}

slide8
Thread code can check if it has been interrupted:

public class NumberThread extends Thread {

private int num;

private int total;

public NumberThread(int n, int ttl) {

num = n;

total = ttl;

}

public void run(){

int count = 0;

while (count < total & !isInterrupted())

System.out.println(num);

count++;

}

if (isInterrupted() )

//clean up

}

thread behavior
Thread Behavior

The Thread.sleep() method can halt a running thread for a given number of milliseconds, allowing other threads to run

  • The Thread.yield() method halts a running thread and allows that thread to be preempted by another, if the CPU so chooses
  • The Thread.sleep() method throws an InterruptedException if the thread is interrupted while it is sleeping (InterruptedException is a checked exception)
  • Signatures for sleep method

static void Thread.sleep(long milli)

static void Thread.sleep(long milli, long nano)

slide10
Sleep call must be used in a try block…

public class NumberThread extends Thread{

…..

public void run(){

try{

for (int count = 0; count < total; count++)

System.out.println(num);

Thread.sleep((long) Math.random() *1000);

}

catch (InterruptedException e) {

any code needed to clean up loose ends

}

}

slide11
The thread scheduler runs each thread for a short amount of time called a time slice
  • Then the scheduler picks another thread from those that are queued to be ready, or runnable. A thread is runnable if it is not asleep or blocked in some way
let s look at a larger application of threads
Let’s look at a larger application of threads..

Suppose a psychologist want to be able to conduct an experiment to measure user response to a visual cue.

An application is needed which can draw black dots a random positions on the screen, and, after a random time interval, begins drawing red dots. The test begins when the patient clicks on a Draw button. As soon as the red dots appear, the patient is to click on a Clear button, which clears the drawing area.

The program must provide how many red dots have appeared before the user clicked in order to measure the patient reaction time.

slide13
An object of type DotPanel draws dots on a panel when it’s draw method is called.

An object of type DotPanel clears the panel when it’s clear method is called.

The Stimuli class uses the DotPanel class to draw dots on a panel.

Run Stimuli.java with DotPanel.java.

What happens when the Clear button is pressed while the dots are being drawn??

slide14
That’s right. Nothing happens.

That is because the CPU is busy executing that for loop, and there is no chance for it to see a user action.

We can fix this by:

1.) executing the drawing in a separate thread

2.) allowing that new thread to sleep occasionally,

so the CPU will recognize user intervention

Take a look at DotPanel2.java and Simuli2.java

thread synchronization
Thread Synchronization
  • Threads are asynchronous .. That is, there is no guarantee about the order in which threads are executed, or when they might get pre-empted.
  • In many cases it is essential to be able to control the thread execution to some extent -- ie.) synchronize them.
slide16
Let’s code a small simulation of a bakery, which uses a Take-A-Number machine to manage a waiting line. Customers will take a number when they arrive, and the clerk announces who’s next by looking at the device. All this is happening at the same time.

Many cooperative applications are based on the producer/consumer model where two threads cooperate at producing and consuming a particular resource or piece of data. The producer thread creates some result or message, and the consumer result uses that result or message.

In our simulation, the customer is the producer, and the clerk is the consumer. The work cooperatively -- the customer generating

a range of numbers waiting to be served, while the clerk uses these numbers.

slide17
We will need 4 classes:

the Bakery class (our application)

the TakeANumber class (an object of this type is

shared by customers and the clerk)

the Customer class

the Clerk class

As mentioned before, the the customers and clerk work simultaneously, and so these objects should each run in their own thread.

slide18
This class must keep track of the next number given AND which customer is to be

served next. It is essential that only one customer be able to take a number at a time.

As many Customer objects will have access to this object,

how do we insure that only one take a number at a time??

class TakeANumber {

private int next = 0;

private int serving = 0;

public int getNum() {

next = next + 1;

return next;

}

public int nextCustomer () {

++serving;

return serving;

}

synchronized

When a synchronized method is called, a lock is placed on that object. While

the lock is in place, no other synchronized method can run in that object.

slide19
Customer thread should model the taking a number from the TakeANumber gadget.

(To keep this program simple we will just assume that after taking a number the customer prints it out.)

public class Customer extends Thread{

private int id; //to distinguish one customer from another

private static int number = 0; //initial customer id number

private TakeANumber takenum; //store reference to machine

public Customer (TakeANumber takeRef){

id = number;

number = number + 1;

takenum = takeRef;

}

public void run(){

try{

sleep( (int)(Math.random() * 1000)) ; //customer walks to machine

System.out.println((“Customer “+ id + “takes ticket “+takenum.getNum());

}

catch ( InterruptedException e) {}

}

}

slide20
The Clerk thread must simulate the behavior of serving the next customer. This thread will repeatedly get the nextCustomer and serve that customer.

( for simplicity we will print a message of who is being served)

public class Clerk extends Thread {

private TakeANumber takeref;

public Clerk (TakeANumber gadget) {

takeref = gadget;

}

public void run() {

while(true && !isInterrupted() ){

try{

sleep ( (int) (Math.random() * 50));

System.out.println(“Clerk serving” + takeref.nextCustomer());

} catch(InterruptedException e) { }

}

}

}

slide21
public class Bakery {

public static void main (String [] args) {

System.out.println(“Starting simulation”);

TakeANumber machine = new TakeANumber();

Clerk clerk = new Clerk(machine);

clerk.start();

for (int i = 1; i < = 5; i++){

Customer cust = new Customer(machine);

cust.start();

}

}

}

slide22
Let’s run this………………….

What happens???

The clerk is serving non-existent customers!!

slide23
How can we fix this??

The clerk is needs to check IF there are customers waiting before getting the next customer. The clerk thread is getting a lot more attention than the customer.

Let’s add a customerWaiting() method to the machine, which can correspond to the clerk looking to see if there are other customers..

slide24
public class Clerk extends Thread {

private TakeANumber takeref;

public Clerk (TakeANumber gadget) {

takeref = gadget;

}

public void run() {

while(true){

try{

sleep ( (int) (Math.random() * 50));

if (takeref.customerWaiting() )

System.out.println(“Clerk serving” + takeref.nextCustomer());

} catch(InterruptedException e) { break; }

}

}

}

Let’s see if this helps…………

slide25
What happened??????????

Maybe it worked fine. MAYBE it didn’t. It is is possible that a thread got pre-empted while executing:

System.out.println( “Customer “ + id +

“takes ticket “ + takeref.getNum() ):

in which case a customer being served is ‘bumped’ by another. We have forgotten that we are writing asynchronous code.

This is a CRITICAL SECTION of our application, and should not be interrupted when executing.

We can use synchronized methods to help..

slide26
Let’s put the I/O functionality in the machine, and have it

report what it does !!

class TakeANumber {

private int next = 0;

private int serving = 0;

public synchronized int getNum(int id) {

next = next + 1;

System.out.println(“Customer “ + id + “ takes ticket “ + next);

return next;

}

public synchronized int nextCustomer () {

++serving;

System.out.println(“Clerk serving “ + serving);

return serving;

}

public boolean customerWaiting() {

return next > serving;

}

slide27
One last modification…………..

The Clerk run method uses a busy waiting algorithm,

which is a terrible waste of CPU time!!

It would be better if the Clerk thread waited until

there was a customer, without using CPU time !!

Thread class methods will help:

wait() - puts a thread into waiting state

notify() - takes a thread out of waiting and

places it back into the waiting queue

slide28
If the clerk calls nextCustomer(), and there is NO customer waiting, then the clerk can wait.

public class TakeANumber {

private int next = 0;

private int serving = 0;

public synchronized int nextCustomer () {

try{

while( next <=serving)

wait(); //thread deactivated, object lock released

} catch (InterruptedException e){}

finally{

++serving;

System.out.println(“Clerk serving “ + serving);

return serving;

}

} //How will the Clerk thread by notified??

public synchronized int getNum(int id) {

next = next + 1;

System.out.println(“# “+ id +“ takes ticket “+ next);

notify(); //clerk waiting is activated

return next;

}

ad