Multithreaded Programming: The java Thread Model, The Main Thread,

Creating a Thread, Creating Multiple Threads, using isAlive(0 and join(),

Thread Priorities, Synchronization, Interthread communication,
suspending, Resuming and stopping Threads, Obtaining a Threads State.

Multithreading is a Java feature that allows concurrent execution of two or

more parts of a program for maximum utilization of CPU. Each part of such
program is called a thread. So, threads are light-weight processes within a
process.
Threads can be created by using two mechanisms:
1. Extending the Thread class
2. Implementing the Runnable Interface

Multitasking is being achieved in two ways :

1. Multiprocessing : Process-based multitasking is a heavyweight process
and occupies different address spaces in memory. Hence, while switching
from one process to another, it will require some time be it very small,
causing a lag because of switching. This happens as registers will be
loaded in memory maps and the list will be updated.
2. Multithreading : Thread-based multitasking is a lightweight process and
occupies the same address space. Hence, while switching cost of
communication will be very less.

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.
Lifecycle and States of a Thread in Java
A thread in Java at any point of time exists in any one of the following states. A
thread lies only in one of the shown states at any instant:
1. New State
 2. Runnable State
3. Blocked State
4. Waiting State
5. Timed Waiting State
6. Terminated State
The diagram shown below represents various states of a thread at any instant in
time.

Life Cycle of a Thread

There are multiple states of the thread in a lifecycle as mentioned below:
1. New Thread: When a new thread is created, it is in the new state. The
thread has not yet started to run when the thread is in this state. When a
thread lies in the new state, its code is yet to be run and hasn’t started to
execute.
2. Runnable State: A thread that is ready to run is moved to a runnable
state. In this state, a thread might actually be running or it might be ready
to run at any instant of time. It is the responsibility of the thread
scheduler to give the thread, time to run.
A multi-threaded program allocates a fixed amount of time to each
individual thread. Each and every thread runs for a short while and then
pauses and relinquishes the CPU to another thread so that other threads
can get a chance to run. When this happens, all such threads that are
ready to run, waiting for the CPU and the currently running thread lie in
a runnable state.
3. Blocked: The thread will be in blocked state when it is trying to acquire a
lock but currently the lock is acquired by the other thread. The thread will
move from the blocked state to runnable state when it acquires the lock.
4. Waiting state: The thread will be in waiting state when it calls wait()
method or join() method. It will move to the runnable state when other
thread will notify or that thread will be terminated.
5. Timed Waiting: A thread lies in a timed waiting state when it calls a
method with a time-out parameter. A thread lies in this state until the
timeout is completed or until a notification is received. For example,
when a thread calls sleep or a conditional wait, it is moved to a timed
waiting state.
6. Terminated State: A thread terminates because of either of the following
reasons:

• Because it exits normally. This happens when the code of the

thread has been entirely executed by the program.
• Because there occurred some unusual erroneous event, like a
segmentation fault or an unhandled exception.
Java Threads
we can define threads as a subprocess with lightweight with the smallest unit of
processes and also has separate paths of execution. The main advantage of
multiple threads is efficiency (allowing multiple things at the same time). For
example, in MS Word. one thread automatically formats the document while
another thread is taking user input. Another advantage is quick response, if we
use multiple threads in a process and if a thread gets stuck due to lack of
resources or an exception, the other threads can continue to execution, allowing
the process (which represents an application) to continue to be responsive.

Threads in a Shared Memory Environment in OS

As we can observe in, the above diagram a thread runs inside the process and
there will be context-based switching between threads there can be multiple
processes running in OS, and each process again can have multiple threads
running simultaneously. The Multithreading concept is popularly applied in
games, animation…etc.
The Concept Of Multitasking
To help users Operating System accommodates users the privilege of
multitasking, where users can perform multiple actions simultaneously on the
machine. This Multitasking can be enabled in two ways:
1. Process-Based Multitasking
2. Thread-Based Multitasking
1. Process-Based Multitasking (Multiprocessing)
In this type of Multitasking, processes are heavyweight and each process was
allocated by a separate memory area. And as the process is heavyweight the cost
of communication between processes is high and it takes a long time for
switching between processes as it involves actions such as loading, saving in
registers, updating maps, lists, etc.
2. Thread-Based Multitasking
As we discussed above Threads are provided with lightweight nature and share
the same address space, and the cost of communication between threads is also
low.
Why Threads are used?
Threads are being used as they had the advantage of being lightweight and can
provide communication between multiple threads at a Low Cost contributing to
effective multi-tasking within a shared memory environment.

What is Main Thread?

We create Main Method in each and every Java Program, which acts as an entry
point for the code to get executed by JVM, Similarly in this Multithreading
Concept, Each Program has one Main Thread which was provided by default by
JVM, hence whenever a program is being created in java, JVM provides the
Main Thread for its Execution.
How to Create Threads using Java Programming Language?
We can create Threads in java using two ways, namely :
1. Extending Thread Class
2. Implementing a Runnable interface
1. By Extending Thread Class
We can run Threads in Java by using Thread Class, which provides constructors
and methods for creating and performing operations on a Thread, which extends
a Thread class that can implement Runnable Interface. We use the following
constructors for creating the Thread:
• Thread
• Thread(Runnable r)
 • Thread(String name)
• Thread(Runnable r, String name)

Java.lang.Thread Class in Java

Thread is a line of execution within a program. Each program can have multiple
associated threads. Each thread has a priority which is used by the thread
scheduler to determine which thread must run first. Java provides a thread class
that has various method calls in order to manage the behavior of threads by
providing constructors and methods to perform operations on threads.

Ways of creating threads

1. Creating own class which is extending to parent Thread class
2. Implementing the Runnable interface.

Thread Class in Java

A thread is a program that starts with a method() frequently used in this class
only known as the start() method. This method looks out for the run() method
which is also a method of this class and begins executing the body of the run()
method. Here, keep an eye over the sleep() method which will be discussed later
below.

Syntax:
public class Thread extends Object implements Runnable
Constructors of this class are as follows:

Constructor Action Performed

Thread() Allocates a new Thread object.

Thread(Runnable target) Allocates a new Thread object.

Thread(Runnable target,
Allocates a new Thread object.
String name)

Thread(String name) Allocates a new Thread object.

Thread(ThreadGroup group,
Allocates a new Thread object.
Runnable target)

Allocates a new Thread object so that it has

Thread(ThreadGroup group, targeted as its run object, has the specified
Runnable target, String name) name as its name, and belongs to the thread
group referred to by a group.

Allocates a new Thread object so that it has

Thread(ThreadGroup group, targeted as its run object, has the specified
Runnable target, String name, name as its name, and belongs to the thread
long stackSize) group referred to by group, and has the
specified stack size.

Thread(ThreadGroup group,
Allocates a new Thread object.
String name)

Methods of Thread class:

Now let us do discuss all the methods of this class are illustrated as follows:

Methods Action Performed

Returns an estimate of the

number of active threads in the
activeCount()
current thread’s thread group and
its subgroups

Determines if the currently

checkAccess() running thread has permission to
modify this thread

Throws
CloneNotSupportedException as
clone()
a Thread can not be meaningfully
cloned

Returns a reference to the

currentThread()
currently executing thread object

Prints a stack trace of the current

dumpStack() thread to the standard error
stream

Copies into the specified array

every active thread in the current
enumerate(Thread[] tarray)
thread’s thread group and its
subgroups

Returns a map of stack traces for

getAllStackTraces()
all live threads
Methods Action Performed

Returns the context ClassLoader

getContextClassLoader()
for this Thread

Returns the default handler

invoked when a thread abruptly
getDefaultUncaughtExceptionHandler()
terminates due to an uncaught
exception

Returns the identifier of this

getId()
Thread

getName() Returns this thread’s name

getPriority() Returns this thread’s priority

Returns an array of stack trace

getStackTrace() elements representing the stack
dump of this thread

getState() Returns the state of this thread

Returns the thread group to

getThreadGroup()
which this thread belongs

Returns the handler invoked

when this thread abruptly
getUncaughtExceptionHandler()
terminates due to an uncaught
exception
Methods Action Performed

Returns true if and only if the

holdsLock(Object obj) current thread holds the monitor
lock on the specified object

interrupt() Interrupts this thread

Tests whether the current thread

interrupted()
has been interrupted

isAlive() Tests if this thread is alive

Tests if this thread is a daemon

isDaemon()
thread

Tests whether this thread has

isInterrupted()
been interrupted

join() Waits for this thread to die

Waits at most millis milliseconds

join(long millis)
for this thread to die

If this thread was constructed

using a separate Runnable run
object, then that Runnable
run()
object’s run method is called;
otherwise, this method does
nothing and returns
Methods Action Performed

Sets the context ClassLoader for

setContextClassLoader(ClassLoader cl)
this Thread

Marks this thread as either a

setDaemon(boolean on)
daemon thread or a user thread

Set the default handler invoked

when a thread abruptly terminates
setDefaultUncaughtExceptionHandler(
due to an uncaught exception,
Thread.UncaughtExceptionHandler eh)
and no other handler has been
defined for that thread

Changes the name of this thread

setName(String name)
to be equal to the argument name.

Set the handler invoked when this

setUncaughtExceptionHandler(
thread abruptly terminates due to
Thread.UncaughtExceptionHandler eh)
an uncaught exception

Changes the priority of this

setPriority(int newPriority)
thread

Causes the currently executing

thread to sleep (temporarily cease
execution) for the specified
sleep(long millis)
number of milliseconds, subject
to the precision and accuracy of
system timers and schedulers

start() Causes this thread to begin

execution; the Java Virtual
Methods Action Performed

Machine calls the run method of

this thread

Returns a string representation of

toString() this thread, including the thread’s
name, priority, and thread group

A hint to the scheduler that the

yield() current thread is willing to yield
its current use of a processor

Also do remember there are certain methods inherited from class

java. lang.Object that are as follows:
1. equals() Method
2. finalize() Method
3. getClass() Method
4. hashCode() Method
5. notify() Method
6. notifyAll() Method
7. toString() Method
8. wait() Method

Runnable interface in Java

java.lang.Runnable is an interface that is to be implemented by a class whose
instances are intended to be executed by a thread. There are two ways to start a
new Thread – Subclass Thread and implement Runnable. There is no need of
subclassing a Thread when a task can be done by overriding only run() method
of Runnable.
Steps to create a new thread using Runnable
 1. Create a Runnable implementer and implement the run() method.
2. Instantiate the Thread class and pass the implementer to the Thread,
Thread has a constructor which accepts Runnable instances.
3. Invoke start() of Thread instance, start internally calls run() of the
implementer. Invoking start() creates a new Thread that executes the code
written in run(). Calling run() directly doesn’t create and start a new
Thread, it will run in the same thread. To start a new line of execution,
call start() on the thread.

Main thread in Java

Java provides built-in support for multithreaded programming. A multi-threaded
program contains two or more parts that can run concurrently. Each part of such
a program is called a thread, and each thread defines a separate path of
execution.
When a Java program starts up, one thread begins running immediately. This is
usually called the main thread of our program because it is the one that is
executed when our program begins.
There are certain properties associated with the main thread which are as
follows:
• It is the thread from which other “child” threads will be spawned.
• Often, it must be the last thread to finish execution because it performs
various shutdown actions
The flow diagram is as follows:
How to control Main thread
The main thread is created automatically when our program is started. To
control it we must obtain a reference to it. This can be done by calling the
method currentThread( ) which is present in Thread class. This method returns a
reference to the thread on which it is called. The default priority of Main thread
is 5 and for all remaining user threads priority will be inherited from parent to
child.
Java Thread Priority in Multithreading
Whenever we create a thread in Java, it always has some priority assigned to it.
Priority can either be given by JVM while creating the thread or it can be given
by the programmer explicitly.
Priorities in threads is a concept where each thread is having a priority which
in layman’s language one can say every object is having priority here which is
represented by numbers ranging from 1 to 10.
• The default priority is set to 5 as excepted.
• Minimum priority is set to 1.
• Maximum priority is set to 10.
Here 3 constants are defined in it namely as follows:
1. public static int NORM_PRIORITY
2. public static int MIN_PRIORITY
3. public static int MAX_PRIORITY

• We will use currentThread() method to get the name of the current thread.
User can also use setName() method if he/she wants to make names of
thread as per choice for understanding purposes.
• getName() method will be used to get the name of the thread.
The accepted value of priority for a thread is in the range of 1 to 10.
Let us do discuss how to get and set priority of a thread in java.
1. public final int getPriority(): java.lang.Thread.getPriority() method
returns priority of given thread.
2. public final void setPriority(int
newPriority): java.lang.Thread.setPriority() method changes the priority
of thread to the value newPriority. This method throws
IllegalArgumentException if value of parameter newPriority goes beyond
minimum(1) and maximum(10) limit.
Enumerations, Type Wrappers and Autoboxing: Enumerations
(Enumeration Fundamentals, The values() and valueOf() Methods). Type
Wrappers (Character, Boolean, The Numeric Type Wrappers), Autoboxing
(Autoboxing and Methods, Autoboxing/Unboxing Occurs in Expressions,
Autoboxing/Unboxing Boolean and Character Values).

A Java enumeration is a class type. Although we don’t need to instantiate an

enum using new, it has the same capabilities as other classes. This fact makes
Java enumeration a very powerful tool.

One thing to keep in mind is that, unlike classes, enumerations neither inherit
other classes nor can get extended(i.e become superclass). We can also add
variables, methods, and constructors to it. The main objective of an enum is to
define our own data types(Enumerated Data Types).

Declaration of enum in Java

Enum declaration can be done outside a class or inside a class but not inside a
method.

enum Color {
RED,
GREEN,
BLUE;
}

public class Test {

// Driver method
public static void main(String[] args) {
Color c1 = Color.RED;
System.out.println(c1);
}
}

Output
RED
2. Declaration inside a class
public class Test {
enum Color {
RED,
GREEN,
BLUE;
}

// Driver method
public static void main(String[] args) {
Color c1 = Color.RED;
System.out.println(c1);
}
}
• The first line inside the enum should be a list of constants and then other
things like methods, variables, and constructors.
• According to Java naming conventions, it is recommended that we name
constant with all capital letters

Properties of Enum in Java

There are certain properties followed by Enum as mentioned below:
• Class Type: Every enum is internally implemented using the Class type.
• Enum Constants: Each enum constant represents an object of type
enum.
• Switch Statements: Enum types can be used in switch statements.
• Implicit Modifiers: Every enum constant is implicitly public static final.
Since it is static, it can be accessed using the enum name. Since it is final,
enums cannot be extended.
 • Main Method: Enums can declare a main() method, allowing direct
invocation from the command line.

In Java, the values( ) method can be used to return all values present inside
the enum.

The valueOf() method returns the enum constant of the specified string value
if exists.

Type Wrappers
A Wrapper class in Java is a class whose object wraps or contains primitive data
types. When we create an object to a wrapper class, it contains a field and in this
field, we can store primitive data types. In other words, we can wrap a primitive
value into a wrapper class object

Need of Wrapper Classes

There are certain needs for using the Wrapper class in Java as mentioned below:
1. They convert primitive data types into objects. Objects are needed if we
wish to modify the arguments passed into a method (because primitive
types are passed by value).
2. The classes in java.util package handles only objects and hence wrapper
classes help in this case also.
3. Data structures in the Collection framework, such
as ArrayList and Vector, store only objects (reference types) and not
primitive types.
4. An object is needed to support synchronization in multithreading.
Advantages of Wrapper Classes
1. Collections allowed only object data.
2. On object data we can call multiple methods compareTo(), equals(),
toString()
3. Cloning process only objects
 4. Object data allowed null values.
5. Serialization can allow only object data.
Wrapper classes allow primitive data types to be used as objects. To explore the
details of wrapper classes and how to use them effectively in Java, the Java
Programming Course provides in-depth lessons with real-world use cases
Below are given examples of wrapper classes in Java with their corresponding
Primitive data types in Java.
Primitive Data Types and their Corresponding Wrapper Class

Primitive Data Type Wrapper Class

char Character

byte Byte

short Short

int Integer

long Long

float Float

double Double

boolean Boolean

Autoboxing and Unboxing

1. Autoboxing
The automatic conversion of primitive types to the object of their corresponding
wrapper classes is known as autoboxing. For example – conversion of int to
Integer, long to Long, double to Double, etc.

import java.util.ArrayList;
class Autoboxing {
public static void main(String[] args)
{
char ch = 'a';

// Autoboxing- primitive to Character object

// conversion
Character a = ch;

ArrayList<Integer> arrayList
= new ArrayList<Integer>();

// Autoboxing because ArrayList stores only objects

arrayList.add(25);

// printing the values from object

System.out.println(arrayList.get(0));
}
}
Output
25

2. Unboxing
It is just the reverse process of autoboxing. Automatically converting an object
of a wrapper class to its corresponding primitive type is known as unboxing. For
example – conversion of Integer to int, Long to long, Double to double, etc.

import java.util.ArrayList;

class Unboxing {
public static void main(String[] args)
{
Character ch = 'a';

// unboxing - Character object to primitive

// conversion
char a = ch;

ArrayList<Integer> arrayList
= new ArrayList<Integer>();
arrayList.add(24);

// unboxing because get method returns an Integer

// object
int num = arrayList.get(0);

// printing the values from primitive data types

System.out.println(num);
}
}
Output
24