Multithreading in Java is a process of executing multiple threads

simultaneously.
A thread is a lightweight sub-process, the smallest unit of processing.
Multiprocessing and multithreading, both are used to achieve
multitasking.
However, we use multithreading than multiprocessing because threads
use a shared memory area. They don't allocate separate memory area
so saves memory, and context-switching between the threads takes less
time than process.
Java Multithreading is mostly used in games, animation, etc.
Multitasking
Multitasking is a process of executing multiple tasks simultaneously. We use
multitasking to utilize the CPU. Multitasking can be achieved in two ways:
• Process-based Multitasking (Multiprocessing)
• Thread-based Multitasking (Multithreading)
1) Process-based Multitasking (Multiprocessing)
• Each process has an address in memory. In other words, each process allocates a
separate memory area.
• A process is heavyweight.
• Cost of communication between the process is high.
• Switching from one process to another requires some time for saving and loading
registers, memory maps, updating lists, etc.
2) Thread-based Multitasking (Multithreading)
• Threads share the same address space.
• A thread is lightweight.
• Cost of communication between the thread is low.
What is Thread in java
A thread is a lightweight subprocess, the smallest
unit of processing. It is a separate path of
execution.
Threads are independent. If there occurs exception
in one thread, it doesn't affect other threads.
It uses a shared memory area.
As shown in the figure, a thread is executed inside
the process. There is context-switching between the
threads.
There can be multiple processes inside the OS, and
Life cycle of a Thread (Thread States)
In Java, a thread always exists in any one of the following states. These states are:
1.New
2.Active
3.Blocked / Waiting
4.Timed Waiting
5.Terminated
New: Whenever a new thread is created, it is always in the new state. For a
thread in the new state, the code has not been run yet and thus has not begun its
execution.
Active: When a thread invokes the start() method, it moves from the new state to
the active state. The active state contains two states within it: one is runnable,
and the other is running.
Runnable: A thread, that is ready to run is then moved to the runnable state. In
the runnable state, the thread may be running or may be ready to run at any given
instant of time. It is the duty of the thread scheduler to provide the thread time to
run, i.e., moving the thread the running state.
Running: When the thread gets the CPU, it moves from the runnable to the
running state. Generally, the most common change in the state of a thread is from
runnable to running and again back to runnable.
Blocked or Waiting: Whenever a thread is inactive for a span of time (not
permanently) then, either the thread is in the blocked state or is in the waiting
state.
Timed Waiting: Sometimes, waiting for leads to starvation.
For example, a thread (its name is A) has entered the critical section of a code and
is not willing to leave that critical section. In such a scenario, another thread (its
name is B) has to wait forever, which leads to starvation. To avoid such scenario,
a timed waiting state is given to thread B. Thus, thread lies in the waiting state for
a specific span of time, and not forever
Terminated: A thread reaches the termination state because of the following
reasons:
•When a thread has finished its job, then it exists or terminates normally.
•Abnormal termination: It occurs when some unusual events such as an
unhandled exception or segmentation fault.
A terminated thread means the thread is no more in the system. In other words,
the thread is dead, and there is no way one can respawn (active after kill) the dead
thread.
Java Threads
How to create a thread in Java
There are two ways to create a thread:
1) By extending Thread class
2) By implementing Runnable interface.
Thread class:
Thread class provide constructors and methods to create and perform operation
os on a thread.
Thread class extends Object class and implements Runnable interface.
Commonly used Constructors of Thread class:
•Thread()
•Thread(String name)
•Thread(Runnable r)
•Thread(Runnable r,String name)
 class Multi3 implements
class Multi extends Thread{ Runnable{
public void run(){ public void run(){
System.out.println("thread is running. System.out.println("thread is
.."); running...");
} }
public static void main(String args[]) public static void main(String
{ args[])
Multi t1=new Multi(); {
t1.start(); Multi3 m1=new Multi3();
} Thread t1 =new
} Thread(m1); // Using the
constructor Thread(Runnable
r)
t1.start();
}
Example of Thread with some methods