Multi

Threading
 Content
• Multi-Threading Fundamentals

• Thread States and Transitions

• Creating Threads - using Thread

class

• Creating Threads – using

Runnable interface

• Joining Threads

• Thread Priorities

• Synchronization

• Thread Communication
2
Multithreading Fundamentals
• Similar to Multiprocessing (OS can run several processes at the
same time)

• Only one process is actually executing at any given time. However, the
system appears to be running several programs simultaneously

• A thread is a sequential flow of

execution within a
program/process

• Single-threaded program can

handle one task at any time

• Multitasking allows single program

to run several concurrent threads

• Today’s modern OS supports

Multitasking inherently
3
 Multithreading Fundamentals
• Multitasking

• Multitasking is a process of executing multiple tasks

simultaneously in order to maximize the resource (CPU) utilization

• A single task which requires a lot of processing can make the

entire application appear to be "sluggish" or unresponsive

• In a multitasked application, each task can be performed by a

separate process/thread

• Multitasking can be achieved in two ways:

• Process based multitasking (Multiprocessing)

• Thread based multitasking (Multithreading)

4
 Multithreading Fundamentals
• Multithreading allows concurrent execution of two or more
parts of a program for attaining maximum utilization of CPU

• By using multithreading, your program can execute another

task during its idle time

• E.g.
• We have a program whose one part is sending a file over the network, another
part is reading the input from the keyboard while some other part is buffering the
next block of data to send

Thread 1

Multiple threads
Thread 2
Thread 3

sharing a single
Process

5
 Multithreading Fundamentals
• Threads Support in Java

• Few programming languages directly support multithreading

• E.g., Java, Go, Scala, Rust etc.

• A thread in Java means two different things

• An instance of class java.lang.Thread

• A thread under execution

• An instance of class Thread is just an object

(like other objects in Java) that lives and dies on the heap

• A thread under execution is a process

(a lightweight sub-process) that executes in its own call stack

• In Java, there is one call stack per thread

6
 Multithreading Fundamentals
• When we run any program in Java, the execution begins
from the main method

• Internally, the JVM creates a thread (called main thread)

that starts executing the code present inside the main
method
• There are other threads too.. Including the Garbage Collection
thread
Main • Although the main thread is
Thread created automatically (by
start start JVM), you can still control it
start
by obtaining a reference to
Thread Thread
this thread using
A Thread C currentThread() method of
B
the Thread class
Threads may switch or exchange data/results

7
 Multithreading Fundamentals
• All the other threads will be created from the main thread

• Main thread must be the last thread to finish execution

(JVM will take care of this)

• E.g. Returns a reference to

the currently executing
class MainThread
thread object
{
public static void main(String[] args)
{
Thread t=Thread.currentThread();
t.setName("MainThread");
System.out.println("Name of thread is "+t);
}
}
Output:
Name of thread is:
Thread[MainThread,5,main]

8
 • Thread States
• A thread can only be in one of the five states:

• New
• Runnable
• Running
• Non Runnable (Waiting/Blocked/Sleeping)
• Dead or Terminated

• A thread’s state changes based on:

Thread • Control methods such as: start, sleep, wait,

States & notify etc.

Transitions

9
Thread States & Transitions

10
 • Thread States
• New

• Thread will be in a New state after the Thread

instance has been created

• It is a live thread object, but not yet a thread of

execution

• A new thread begins its life cycle in the new state

Thread • It remains in this state until the program starts the

thread

States & • It is also referred to as born thread

Transitions

11
 Thread States & Transitions
• Thread States

• Runnable

• This is the state when a thread is considered eligible to run, but the scheduler has
not selected it to be the running thread

• A thread first enters the runnable state when the start() method is invoked

• A thread can also return to the runnable state after either running or coming back
from a blocked, waiting, or sleeping state

• When a thread is in the runnable state, it is considered as alive

12
 Thread States & Transitions
• Thread States

• Running
• A thread is in the running state if the
thread scheduler has selected it

• The scheduler chooses a thread for

execution from the runnable pool

• A thread can transition out of a

running state for several reasons:

• Completed

• Waiting for I/O

• Blocked by another thread

13
 Thread States &
Transitions
• Thread States

• Non Runnable (Waiting/blocked/sleeping)

• In this state, a thread is not eligible to run

(though the thread is still alive)

• A thread may be blocked waiting for a

resource (like I/O)

• A thread may be sleeping because the

thread’s run code (inside run()) tell it to
sleep for some period of time (using
sleep())

• A thread my be waiting because the

thread’s run code causes it to wait (using
wait())

14
 Thread States & Transitions
• Thread States

• Dead or Terminated

• A thread is considered dead when its run() method completes execution

• Once a thread is dead, it can never be brought back for execution

• If you invoke a start() on a dead thread instance, you’ll get a runtime

exception

15
 Creating Threads
• A thread can be created using any of the two ways

(i). By extending Thread class (Or)

(ii). By implementing Runnable interface and using Thread

class

• Thread class, along with Runnable interface is used to create and

run threads for utilizing Multithreading capabilities of Java

16
 Creating Threads
• Thread Class

• Thread class provide constructors and methods to create and perform

operations on a thread

• Commonly used constructors of the Thread class

• Thread() Extending Thread class

• Thread(String str)

• Thread(Runnable r) Implementing Runnable Interface

• Thread(Runnable r, String str)

17
 Creating Thread
• Thread class

• Thread class defines many methods for managing threads, few of these
methods are:

Method Name Description

setName() Give name to a thread
getName() Return thread’s name
getPriority() Return thread’s priority
isAlive() Checks if thread is still running or not
join() Wait for a thread to end
run()* Entry point for a thread
sleep() Suspend thread for a specified time
start() Starts a thread [with new call stack by calling
run() method]

18
 Creating Threads

• Thread class

• When we extend the Thread class, we cannot override setName() &

getName() methods, as they’re declared as final in Thread class

• The sleep() method throws an interrupted exception, so it’s important to

handle the exception it throws

static void sleep(long milliseconds) throws InterruptedException

• run() method is used to perform some action for the thread. It can call
other methods, declare variables or use other classes just like the main
thread

19
 • Thread class
• In order to create a thread using Thread class, you’ll
need to override the run() method

• This method provides an entry point for the thread & its
syntax is

public void run()

• Once the Thread object is created, you can start it by

Creating calling the start() method, which in turn invokes the

run() method, its syntax is

Threads void start()

20
 Creating Threads
• Thread class – Example

class ThreadDemo extends Thread {

private Thread t;
private String threadName;

ThreadDemo( String name) {

threadName = name;
System.out.println("Creating " + threadName );
}

public void run() {

System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
Thread.sleep(5000);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
21
 Creating Threads
• Example contd…
Output:
System.out.println("Thread " + threadName + " exiting."); Creating Thread-1
} Starting Thread-1
Creating Thread-2
} Starting Thread-2
Running Thread-1
// Driver Class Thread: Thread-1, 4
public class TestThread { Running Thread-2
Thread: Thread-2, 4
public static void main(String args[]) { Thread: Thread-1, 3
ThreadDemo T1 = new ThreadDemo( "Thread-1"); Thread: Thread-2, 3
T1.start(); Thread: Thread-1, 2
Thread: Thread-2, 2
ThreadDemo T2 = new ThreadDemo( "Thread-2"); Thread: Thread-1, 1
T2.start(); Thread: Thread-2, 1
}
Thread Thread-1 exiting.
Thread Thread-2 exiting.
}
22
Creating Threads
• Another Example

• Demonstrates basic threading techniques:

• Create a class derived from Thread

• Use sleep method

• What it does?

• Create four threads, which sleep for random amount of time

• After they finish sleeping, print their name

• Program has two classes:

• PrintThread -> Derived from Thread class

• ThreadTester -> Creates four PrintThread objects

23
 Creating Threads
• Example contd…

class PrintThread extends Thread {

private int sleepTime;

// PrintThread constructor assigns name to thread

// by calling Thread constructor
public PrintThread( String name )
{
super( name ); // Calls the super class Thread constructor

// sleep between 0 and 5 seconds

sleepTime = (int) ( Math.random() * 5000 ); // Random integer value

System.err.println( "Name: " + getName() + "; sleep: " + sleepTime );

}
24
Creating Threads

• Example contd…

// execute the thread

public void run()
{
// put thread to sleep for a random interval
try {
System.err.println( getName() + " going to sleep" );
Thread.sleep( sleepTime );
}
catch ( InterruptedException exception ) {
System.err.println( exception.toString() );
}

// print thread name

System.err.println( getName() + " done sleeping" );
}
}

25
 Creating Threads
• Example contd…
Output:
public class ThreadTester {
public static void main( String args[] ) Creating Thread-1
{ Starting Thread-1
PrintThread thread1, thread2, thread3, thread4; Creating Thread-2
Starting Thread-2
Running Thread-1
thread1 = new PrintThread( "thread1" ); Thread: Thread-1, 4
thread2 = new PrintThread( "thread2" ); Running Thread-2
thread3 = new PrintThread( "thread3" ); Thread: Thread-2, 4
thread4 = new PrintThread( "thread4" ); Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
System.err.println( "\nStarting threads" ); Thread: Thread-2, 2
Thread: Thread-1, 1
thread1.start(); Thread: Thread-2, 1
thread2.start(); Thread Thread-1 exiting..
Thread Thread-2 exiting..
thread3.start();
thread4.start();

System.err.println( "Threads started\n" );

}
}
26
Creating Threads

• Runnable Interface

• Another way to create a thread is by implementing the Runnable interface

• The Runnable interface has only one method i.e., run()

• First step is to implement the run() method that provides an action point
for the thread and contain the complete business logic inside it

• Second step is to instantiate a Thread class object using the given

constructor

Thread(Runnable threadObj, String threadName);

OR

Thread(Runnable threadObj)

27
 Creating Threads
• Runnable Interface
• Launching a new thread:
3) Finally start the thread
1) Make a Runnable object (the thread’s job)
myThread.start();

Runnable threadJob = new MyRunnable();

2) Make a Thread object (the worker) and give it a Runnable (the job)

Thread myThread = new Thread(threadJob);

28
Creating Threads
• Runnable Interface – Example
// Let the thread sleep for a while.
class RunnableDemo implements Runnable {
Thread.sleep(50);
private Thread t; }
private String threadName; } catch (InterruptedException e) {
System.out.println("Thread " +
threadName + " interrupted.");
RunnableDemo( String name) { }
threadName = name; System.out.println("Thread " +
threadName + " exiting.");
System.out.println("Creating " +
threadName ); }

}
public void start () {
System.out.println("Starting " +
threadName );
public void run() {
if (t == null) {
System.out.println("Running " + threadName );
t = new Thread (this, threadName);
try { t.start ();
for(int i = 4; i > 0; i--) { }

System.out.println("Thread: " + }
threadName + ", " + i); }

29
Creating Threads

• Runnable Interface – Example

Contd…
Output:
Creating Thread-1
Starting Thread-1
public class TestThread {
Creating Thread-2
Starting Thread-2
public static void main(String args[]) { Running Thread-1

RunnableDemo R1 = new RunnableDemo( "Thread-1"); Thread: Thread-1, 4

Running Thread-2
R1.start();
Thread: Thread-2, 4
Thread: Thread-1, 3

RunnableDemo R2 = new RunnableDemo( "Thread-2"); Thread: Thread-2, 3

Thread: Thread-1, 2
R2.start();
Thread: Thread-2, 2
} Thread: Thread-1, 1

} Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

30
 Creating Threads
• Another Example – Runnable Interface

class MyRunnableThread implements Runnable{

public static int myCount = 0;

public MyRunnableThread(){
// initialization code goes here
}
public void run() {
while(MyRunnableThread.myCount <= 10){
try{
System.out.println("Expl Thread: "+(++MyRunnableThread.myCount));
Thread.sleep(1000);
} catch (InterruptedException iex) {
System.out.println("Exception in thread: "+iex.getMessage());
}
}
}
}

31
 Creating Threads
• Example contd…

public class RunMyThread {

public static void main(String a[]){
System.out.println("Starting Main Thread...");
MyRunnableThread mrt = new MyRunnableThread();
Thread t = new Thread(mrt);
t.start();
while(MyRunnableThread.myCount <= 10){
try{
System.out.println("Main Thread: "+(++MyRunnableThread.myCount));
Thread.sleep(1000);
} catch (InterruptedException iex){
System.out.println("Exception in main thread: "+iex.getMessage());
}
}
System.out.println("End of Main Thread...");
}
}
32
 Creating Threads
• Special Cases

• Calling the run() method directly without using start() method

• Consider the given example on directly calling the run() method

• E.g.
public static void main( String args[] )
{
MyThread mt = new MyThread();
mt.run();
}

• In this case, the thread won’t create a new call stack, instead will start running in
the current call stack (i.e., call stack of main thread)

• Hence, there is no multithreading in this case

33
Creating Threads
• Special Cases

• Starting a thread twice

• A thread cannot be started twice (calling the start() method twice on the same
thread)

• When the second thread is called second time (using start()), it will throw an
IllegalThreadStateException

• E.g.
public static void main( String args[] )
{
MyThread mt = new MyThread();
mt.start();
mt.start(); //Exception thrown
}

34
What to
Choose?

Basis of Thread Runnable

Comparis
on
Basic Each thread creates a Multiple threads share the
unique object and gets same objects
associated with it

Memory & As each thread create a As multiple threads share

unique object, more the same object less
Performance memory required. memory is used. Less
Performance overhead overhead better
performance

Inheritance In Java, multiple If a class define thread

inheritance not allowed implementing the
hence, after a class extends Runnable interface it has
Thread class, it can not a chance of extending one
extend any other class class

Usage A user must extend thread If you only want to

class only if it wants to specialize run method
override the other methods then implementing
in Thread class Runnable is a better
option

Coupling Extending Thread class Implementing Runnable

introduces tight coupling as interface introduces loose
the class contains code of coupling as the code of
Thread class and also the Thread is separate form
job assigned to the thread the job of Threads

35
Joining Threads
• Sometimes, one thread needs to
know when other thread is
terminating

• Java supports two methods that are

used to check whether a thread has
finished its execution or not
(i). isAlive()
(ii). join()

• The isAlive() method returns true if

the thread upon which it is called is
still running else it returns false

• The join() method waits until the

thread on which it is called terminates

36
 Joining Threads
• Example – isAlive()

public class MyThread extends Thread

{
public void run()
{
System.out.println("r1 "); Output
try {
Thread.sleep(500);
} true
catch(InterruptedException ie) true
{ }
System.out.println("r2 "); r1
}
r2
public static void main(String[] args)
{ r2
MyThread t1=new MyThread();
MyThread t2=new MyThread();
t1.start();
t2.start();

System.out.println(t1.isAlive());
System.out.println(t2.isAlive());
}
}
37
Joining Threads
• Example – without using join()

public class MyThread extends Thread public static void main(String[] args)
{ {
MyThread t1=new MyThread();
public void run()
MyThread t2=new MyThread();
{ t1.start();

System.out.println("r1 "); t2.start();

}
try {
}
Thread.sleep(500);
} Output:
r1
catch(InterruptedException ie){
r1
}
r2
System.out.println("r2 "); r2
}

38
 • In the previous example, we created two threads t1 & t2

• Thread t1 starts its execution first by printing “r1” on the console

and goes to sleep for 500 ms (half second)

• Similarly, thread t2 starts and prints “r1” on the console & goes to
sleep for 500 ms

• After that thread t1 wakes up from sleep and prints “r2” similarly,
thread t2 wakes up and prints “r2”

Joining
Threads
• What if, we want thread t1 to finish its execution before t2 starts

39
Joining Threads
• Example – using join()
public class MyThread extends Thread t1.start();
try{
{

public void run()

t1.join();
{ //Waiting for t1 to
finish
System.out.println("r1 ");
}catch(InterruptedException ie){}
try { t2.start();
Thread.sleep(500); }

}catch(InterruptedException ie){ } }

System.out.println("r2 ");
Output
}
r1
public static void main(String[] args)
r2
{
• Join method on thread t1 ensures that it
r1
finishes its execution before thread t2
r2
MyThread t1=new MyThread(); starts
MyThread t2=new MyThread();

40
Thread Priorities

• Threads always run with some priority, usually represented as a number

between 1 and 10

• A thread’s priority determines how much CPU time a thread receives

• Higher the thread priority  larger chance being executed first

• In most cases, a thread scheduler schedules the threads according to their

priority (known as preemptive scheduling)

• If a thread enters the Runnable state, and it has a higher priority than of the
threads in the thread-pool then the lower priority thread will be taken back to
Runnable state and the higher priority thread will be chosen to run

• In most cases, the running thread will of equal or greater priority than the
highest priority threads in the pool

41
Thread Priorities

42
Thread Priorities

43
Thread Priorities

44
Thread Priorities

45
Create Custom Thread with user-defined
name and Priority

46
Create Custom Thread with user-defined
name and Priority

47
Create Custom Thread with user-defined
name and Priority

48
Output

49
 • Constants defined in Thread class

• There are 3 constants that defines the priority of a thread, these are

• public static int MIN_PRIORITY

• public static int NORM_PRIORITY
• public static int MAX_PRIORITY

• Default priority of a thread is 5 (NORM_PRIORITY)

• Value of MIN_PRIORITY is 1 & the value of MAX_PRIORITY is 10

Thread
Priorities

50
 Thread Priorities
• Demo Example – Checking the CPU usage

• The example demonstration

creates two threads with
different priorities

• The run() method contains a

loop that counts the number
of iterations and stops when
the count reaches 10,000,000
or the static variable stop is
true

• Each time through the loop

the string in currentName will
be checked for the name of
executing thread

• This allows you to check how

often each thread has access
to the CPU
51
Thread Priorities
• Demo Example
class Priority implements Runnable {

int count;

Thread thrd;

static boolean stop = false; if(currentName.compareTo(thrd.getName()) != 0) {

static String currentName; currentName = thrd.getName();

System.out.println("In " +
Priority(String name) { currentName);
thrd = new Thread(this, name); }
count = 0; } while(stop == false && count < 10000000);
currentName = name; stop = true;
} System.out.println("\n" + thrd.getName() + The first

// Begin execution of new thread. " terminating."); thread to

complete
}
public void run() { 10,000,000
} iterations
System.out.println(thrd.getName() + " starting.");
will stop all
do { threads
count++;

52
 Thread Priorities
• Demo Example
class PriorityDemo { System.out.println("Low priority thread counted
public static void main(String args[]) { to " +
Priority mt1 = new Priority("High Priority"); mt2.count);
Priority mt2 = new Priority("Low Priority");
}
// set the priorities
}
mt1.thrd.setPriority(Thread.NORM_PRIORITY+2);
mt2.thrd.setPriority(Thread.NORM_PRIORITY-2); Sample run:
// start the threads High Priority starting.
mt1.thrd.start();
In High Priority
mt2.thrd.start(); Giving mt1 a
higher priority Low Priority starting.
try {
than mt2
mt1.thrd.join(); In Low Priority

mt2.thrd.join(); In High Priority

Higher
} High Priority terminating. priority
catch(InterruptedException exc) { thread got a
Low Priority terminating. vast majority
System.out.println("Main thread interrupted.");
of CPU
High priority thread counted to 10000000
}
System.out.println("\nHigh priority thread counted to Low priority thread counted to 8183
" +
mt1.count);

53
Threads

54
Thread

55
Thread Creation

56
Thread Creation

• Thread creation by extending the Thread class

We create a class that extends the java.lang.Thread
class.
• This class overrides the run() method available in the
Thread class.
• A thread begins its life inside run() method.
• We create an object of our new class and call start()
method to start the execution of a thread.
• Start() invokes the run() method on the Thread object.

57
Thread Creation

• Thread creation by implementing the Runnable

Interface
We create a new class which implements
java.lang.Runnable interface and override run()
method.
• Then we instantiate a Thread object and call start()
method on this object.

58
Thread Creation

• Thread Class vs Runnable Interface

1.If we extend the Thread class, our class cannot extend
any other class because Java doesn’t support multiple
inheritance. But, if we implement the Runnable
interface, our class can still extend other base classes.
2.We can achieve basic functionality of a thread by
extending Thread class because it provides some inbuilt
methods like yield(), interrupt() etc. that are not
available in Runnable interface.
3.Using runnable will give you an object that can be
shared amongst multiple threads.

59
Thread Creation

60
Difference between Sleep & Wait

61
Thread extends

62
Threads Runnable

63
Thread Multiple Threads

64
Exercise

• Write a Java program that implements a multi-thread

application that has three threads. First thread
generates a random integer for every 1 second; second
thread computes the square of the number and prints;
third thread will print the value of cube of the number

65
Exercise

66
Exercise

67
resume()

68
resume()

69
Difference between Sleep & Wait

70
Difference between Sleep & Wait

71
Demo Wait

72
Synchronised

73
Difference between Sleep & Wait

74
Difference between Sleep & Wait

75
Demo Join

76
Demo Without Join

77
Demo isAlive

78
Thread Priority

79
Setting Custom Thread Name

80
Setting Custom Thread Name

81
Daemon Thread

82
Daemon Thread

83
Daemon Thread

84
Daemon Thread

85
Daemon Thread

86
Thank You

87