By : Prof.

Kumar Anand Singh

Kumar Anand Singh

 What is a Thread?
• Individual and separate unit of execution that is part of a
process
– multiple threads can work together to accomplish a common goal
• Video Game example
– one thread for graphics
– one thread for user interaction
– one thread for networking

Kumar Anand Singh

What is a Thread?

Video Game
Process

video networking

interaction

Kumar Anand Singh

Advantages
• easier to program
• 1 thread per task
• can provide better performance
• thread only runs when needed
• no polling to decide what to do
• multiple threads can share resources
• utilize multiple processors if available

Kumar Anand Singh

Disadvantage
• multiple threads can lead to deadlock
• much more on this later
• overhead of switching between threads

Kumar Anand Singh

How to create threads
• There are two ways of creating threads in Java:
1) Extend the “Thread” class
We can instantiate the class Thread as many times as desired to achieve multi-
threading.
2) Implement the “Runnable” interface
Since multiple inheritance is not allowed in Java, this method is used when the
program already extends another class (Ex. Applets)

Kumar Anand Singh

1) Extend the Thread class
• Create a subclass of java.lang.Thread:
public class MyThread extends Thread {
public void run() {
\\put code here
}
}
• Instantiate MyThread:
MyThread myTrd;
myTrd.start(); // calls run() in MyThread

Kumar Anand Singh

Methods in Class Thread
• Three primary methods to control a thread:
• public native synchronized void start() prepares a thread to run
• public void run() actually performs the work of the thread
• public final void stop() to terminate the thread. The thread also dies when run()
terminates.
• Other important methods in Thread include:
• suspend() and resume()
• sleep(mls) which causes the thread to temporarily stop execution for mls milliseconds
• yield() which causes the executing thread object to temporarily pause and allow other
threads to execute
• getName() and getPriority()

Kumar Anand Singh

Class Thread Priorities
• The class Thread has three fields:
• MAX_PRIORITY
• MIN_PRIORITY
• NORM_PRIORITY: the default priority assigned to a thread
• A new created thread has its priority initially set equal to the priority of
the creating thread.

Kumar Anand Singh

Ex1
class MyThread extends Thread { // the thread
public void run() {
System.out.println(" this thread is running ... ");
}
}

class ThreadEx1 { // a program that utilizes the thread

public static void main(String [] args ) {
MyThread t = new MyThread();
// due to extending the Thread class (above) we can call start()
// start() will invoke run(). start() is a predefined method in class Thread.
t.start();
}
}

Kumar Anand Singh

 Ex: 2 public class C extends Thread {
public class A extends Thread { String []name={"Anand", “Ravi", “Neha", “Nikita", “Devanshi",
public void run(){ “Marlin", “Siddharth"};
for(int i=0;i<7;i++){ public void run(){
System.out.println("Thread A "+i); for(int i=0;i<7;i++){
} System.out.println("Thread B "+name[i]);
System.out.println("Thread A exit"); }
} System.out.println("Thread B exit");
}
} }

public class Multi_Thread {

public class B extends Thread { public static void main(String[] args)throws
public void run(){ RuntimeException{
for(char c='a';c<'g';c++){ A a=new A(); B b=new B(); C c=new C();
System.out.println("Thread C "+c); a.start();
} b.start();
System.out.println("Thread C exit"); c.start();
} }
} }
Kumar Anand Singh
2) Creating a thread by using Runnable Interface
• Instantiate Thread and pass it “this” (the applet) as a parameter.
• Use the method start() to start running the instantiated thread.
• Place all the important code for the instantiated thread in the run()
method.
• Set the instantiated thread to “null” in the stop() method.

Kumar Anand Singh

Implement Runnable interface

• Create a class that implements Runnable:

public class MyThread extends Applet implements Runnable;

• Runnable is an interface in java.lang that contains only one method: run().

• Multiple inheritance is not allowed in Java, thus this method of creating

threads is used when MyThread already extends another class.

Kumar Anand Singh

Threads by implementing Runnable interface
class MyThread implements Runnable
{
.....
public void run()
{
// thread body of execution
}
}
• Creating Object:
MyThread myObject = new MyThread();
• Creating Thread Object:
Thread thr1 = new Thread( myObject );
• Start Execution:
thr1.start();

Kumar Anand Singh

Ex 1
class MyThread implements Runnable {
public void run() {
System.out.println(" this thread is running ... ");
}
} // end class MyThread

class ThreadEx2 {
public static void main(String [] args ) {
Thread t = new Thread(new MyThread());
// due to implementing the Runnable interface
// It can call start(), and this will call run().
t.start();
} // end main()
} // end class Thread

Kumar Anand Singh

Ex 2
public class B implements Runnable{
public class A implements Runnable{ String []name={"Anand", "Abhijit", "Lalita",
public void run(){ "Apurva","Meghna","Vishal","Alpesh"};
for(int i=0;i<7;i++){ public void run(){
System.out.println("Thread A "+i); for(int i=0;i<7;i++){
} System.out.println("Thread B "+name[i]);
System.out.println("Thread A exit"); }
} System.out.println("Thread B exit");
} }
}
public class Main_Thread {
public static void main(String[] args) {
A a=new A();
B b=new B();
Thread threadA=new Thread(a);
Thread threadB = new Thread(b);
threadA.start();
threadB.start();
}
}
Kumar Anand Singh
Advantage of Using Runnable
• remember – we can only extend one class at a time
• implementing runnable allows class to extend something else like an
applet

Kumar Anand Singh

Life cycle of a Thread Newborn

• Newborn state start() stop()

• Runnable state Dead

Runnable state
• Running state

• Blocked state

• Dead state

Kumar Anand Singh

Kumar Anand Singh
Methods used in Thread and there meanings

• yield() : if we want a thread to relinquish (hand over) to another

thread to equal priority before its turn comes.
• suspend() : if we want to turn a thread in waiting state
• resume() : if a thread is in waiting state then it can be revived
• sleep() : We can put a thread to wait state for a specified time in milli
seconds
• wait() : this method wait to resume thread for some event to ocour
• notify() : if a thread is in wait condition then using notify we can again
resume the thread

Kumar Anand Singh

The End

21