By: Naol G.

METTU UNIVERSITY
FACULTY OF ENGINEERING & TECHNOLOGY
DEPARTMENT OF COMPUTER SCIENCE
Java programming course

Chapter-5
Multithreading Concepts in Java
 By: Naol G. 2

Introduction
Human body performs variety of operations in parallel/concurrently.

• Computers also too, can perform operations concurrently.

Only computers that have multiple processors can truly execute

multiple instructions concurrently.

Operating systems on single-processor computers create the illusion of

concurrent execution

• by rapidly switching between activities.

• but on such computers, only single instruction can be executed at once.

Java makes concurrency available to you through its APIs.

 By: Naol G. 3

What is java Thread

Thread is
Process created
is Thread is &controlled by
program lightweigh
in t sub- java.lang.Thre
execution process. ad class

Thread is Every java Ex: MS word

smallest program (main process),
independent contains typing and spell
unit of a at least checking (sub-
process. one processes\
threads)
thread.
 By: Naol G. 4

What is Multithreading
Multitasking allows CPU to perform multiple tasks (process, threads)
simultaneously

• Maximum (optimal) utilization of CPU.

• Multitasking can be achieved in two ways:
• Process based and thread based multitasking

Multithreading is a conceptual programming paradigm where a program

(process) is divided into sub-processes, which can be implemented at same
time in parallel.
• For example, one subprogram can be used for typing while the another
may used to check spelling error.
• This is sometimes similar to dividing a task in to subtasks and assigned
them to different people for execution independently and simultaneously.

Both are used:

• To reduce CPU idle time and increase system performance.

 By: Naol G. 5

Single-Threaded vs. Multi-Threaded Process

 By: Naol G. 6

Advantage of Multithreading
Responsiveness
• Multithreading an interactive application may allow a program to
continue running even if part of it is blocked or doing a lengthy
operation.

Resource Sharing
• Threads share the memory and the resources(code, data, and
files)of the process to which they belong.

Enhancing throughput of the system: 

• If a process is divided into multiple threads, and each thread
function is considered as one job, then the number of jobs
completed per unit of time is increased, thus increasing the
throughput of the system.

Utilization of multi-processor architectures

• Threads may be running in parallel on different processors.
 By: Naol G. 7

How to create Thread in java

We know that every Java program has at least one thread
called main thread.
• When a program starts, main thread starts running immediately.

Apart from this main thread, we can also create our own
threads in a program that is called child thread.

Every child threads create from its main thread known as

parent thread.

There are two ways to create a new thread in Java:

• By extending java.lang.Thread class

• By implementing java.lang.Runnable interface
03/03/2022 By: Naol G. 8

Life Cycle of Thread

A thread can be in any of the five following states:

1. Newborn State:
• When a thread object is created a new thread is born and said to
be in Newborn state.
• Eg.: MyThread t1 = new MyThread();

2. Runnable State:
• If a thread is in this state it means that the thread is ready for
execution and waiting for the availability of the processor.
• If all threads in queue are of same priority then they are given
time slots for execution in round robin fashion.
03/03/2022 By: Naol G. 9

Cont…
3. Running State:

• It means that the processor has given its time to the thread for
execution.
• A thread keeps running until the following conditions occurs.
Eg.: After t1.start(); ,if thread scheduler allocate processor, automatically start()
will invoke run() method.
• Thread give up its control on its own and it can happen in the following
situations.
• A thread gets suspended using suspend() method which can only be
revived with resume() method.
• A thread is made to sleep for a specified period of time using sleep(time)
method, where time in milliseconds.
• A thread is made to wait for some event to occur using wait()method. In
this case a thread can be scheduled to run again using notify()method
• A thread is pre-empted by a higher priority thread
03/03/2022 By: Naol G. 10

…
4. Blocked State:
• If a thread is prevented from entering into runnable state and
subsequently running state, then a thread is said to be in Blocked
state.
• Eg.: t1.sleep(500); or t1.suspend(); or t1.wait();

5. Dead State:

• A runnable thread enters the Dead or terminated state when it

completes its task or otherwise terminates.
• Eg.: t1.stop();
03/03/2022 By: Naol G. 11
 By: Naol G. 12

Methods of Thread class

 By: Naol G. 13

Creating Threads
In the most general sense, you can create a thread by
instantiating an object of type Thread.

But, Java defines two ways in which this can be accomplished:

• 1. You can extend the Thread class, itself

• 2. You can implement the Runnable interface.
 By: Naol G. 14

Extending Thread
One way to create a thread is to create a new class that extends
Thread, and then to create an instance of that class.

The extending class must override the run() method, which is the
entry point for the new thread.

It must also call start() to begin execution of the new thread.

 By: Naol G. 15

Creating Thread in Java demo-1

• .
class MyThread extends Thread {
public void run() { //to run thread, we put our implementation here
System.out.print(“thread is running…”);
}

public static void main(String[] args) {

MyThread mt = new MyThread (); // creating thread
mt.start(); // calling run() via start()
}
}

Note:
• Everything inside run() is called job of the thread.
• mt.start(); - create new thread and execute run()
• mt.run(); - only execute run() as normal program execution
• start() method is considered as the ‘heart’ of multithreading concept.
• Register the thread with thread scheduler
• Invoke run() method
 By: Naol G. 16

Creating Thread in Java demo-2

public class Hello extends Thread {
public void run() { //run() help us to execute two/more thread in parallel
• for ( int i=1; i<=5; i++) {
System.out.println(“Hello”);
Thread.sleep(1000); //sleep() to delay execution for given millisecond value(1s)
}
}
public class Bye extends Thread {
public void run() {
for ( int i=1; i<=5; i++) {
System.out.println(“Bye”);
Thread.sleep(500); //sleep() to delay execution for given millisecond
value(0.5s)
}
}
public class ThreadDemo{
public static void main(String [ ] args) {
Hello hello = new Hello();
Bye bye = new Bye();

hello.start(); //hello executed first, then bye

bye.start();
}
}
 By: Naol G. 17

Implementing Runnable
The second way to create a thread is to create a class that
implements the Runnable interface.

To implement Runnable, a class need only implement a single method

called run( ), which is declared like this:
• public void run()

After you create a class that implements Runnable, you will instantiate
an object of type thread from within that class.

Next, after the new thread is created, it will not start running until you
call its start( )method, which is declared within Thread.

In essence, start() executes a call to run( ).

 By: Naol G. 18

Creating Thread in Java demo-3

public class Hello implements Runnable{
public void run() { //run() help us to execute two/more thread in parallel
for ( int i=1; i<=5; i++) {
•. System.out.println(“Hello”);
Thread.sleep(1000); //sleep() to delay execution for given millisecond value(1s)
}
}
public class Bye implements Runnable{
public void run() {
for ( int i=1; i<=5; i++) {
System.out.println(“Bye”);
Thread.sleep(500); //sleep() to delay execution for given millisecond value(0.5s)
}
}
public class ThreadDemo{
public static void main(String [ ] args) {
Hello hello = new Hello();
Bye bye = new Bye();

Thread thr1 = new Thread(hello); //hello is called target runnable

Thread thr2 = new Thread(bye); //bye is called target runnable

thr1.start(); //hello executed first, then bye

thr2.start();
}
}
 By: Naol G. 19

Which approach is recommended to define thread:

• Implementing Runnable interface is preferred one.

• Why:
• We will have advantage of multiple inheritance benefit.

• Eg.:
class MyThreadOne extends MyThreadTwo implements Runnable
{
//code here
}
 By: Naol G. 20

Available Thread constructor (8):

• Thread t = new Thread();
• Thread t = new Thread(Runnable r);
• Thread t = new Thread(String name);
• Thread t = new Thread(Runnable r, String name);
• Thread t = new Thread(threadGroup g, String name);
• Thread t = new Thread(threadGroup g, Runnable r);
• Thread t = new Thread(threadGroup g, Runnable r, String name);
• Thread t = new Thread(threadGroup g, Runnable r, String name, long stacksize );
 By: Naol G. 21

Controlling Threads
Controlling threads is the art of moving them from one state to another.

You control threads by triggering state transitions.

• Starting a thread:
• Once a Thread has been created it is started by calling start() method.
• The start() method puts the thread into the ready state.
• To start a thread we use the following syntax: thread.start();

• Stopping a thread:
• To stop a thread from running further, we may do so by calling its stop() method.
• This causes a thread to stop immediately and move it to its dead state.
• It forces the thread to stop abruptly before its completion
• It causes premature death.
• To stop a thread we use the following syntax: thread.stop();
 By: Naol G. 22

Controlling Threads…
Blocking Threads:
• A thread can also be temporarily suspended or blocked from
entering into the runnable and subsequently running state,
• 1. sleep(t) // blocked for ‘t’ milliseconds
• 2. suspend() // blocked until resume() method is invoked
• 3. wait() // blocked until notify () is invoked

• sleep() Vs yield() Methods

• Calling sleep put the current running thread into the blocked state
• Calling yield does not put the running thread into the blocked
state
• It causes the currently running thread to move to the ready state.
• Thus other threads are given a chance to enter the running state.
 By: Naol G. 23

Controlling Threads Demo

 By: Naol G. 24

Threads Priority
Every Java thread has a thread priority that helps the operating
system to determine the order in which threads are scheduled
priorities range between:
• MIN_PRIORITY (a constant of 1)
• NORM_PRIORITY (a constant of 5, default) and
• MAX_PRIORITY (a constant of 10)

Each new thread inherits the priority of the thread that created it.
• Note: In case two threads have the same priority, the JVM will execute them in FIFO
order.

Java's Thread class provides methods for checking the thread’s

priority and for modifying it.
• getPriority() method returns the integer that represents its priority.
• setPriority(INT I) method takes integer between 1-10 to change thread's priority.
• If we pass a value outside the 1-10 range, the method will throw an error.
 By: Naol G. 25

Threads Priority Demo

 By: Naol G. 26

Thread Synchronization
When we start two or more threads within a program, there may be
a situation when multiple threads try to access the same resource
• Then they can produce unexpected result due to concurrency issues.

For example,

• if multiple threads try to write within a same file then they may corrupt the data
because
• one of the threads can override data or
• while one thread is opening the same file at the same time another thread
might be closing the same file.

So there is a need to synchronize the action of multiple threads

and make sure that only one thread can access the resource at a
given point in time.
 By: Naol G. 27

Java programming language provides a very handy way of creating

threads and synchronizing their task by using synchronized blocks.

You keep shared resources within this block

synchronized(objectidentifier){
// Access shared variables and other shared resources;
}

Reading:

• Thread Synchronization Demo

• InterThread Communication and deadlock
 By: Naol G. 28

End
Thank you