Multithreading in Java
Multithreading in Java: An Introduction
The process of performing several tasks by multiple threads concurrently is known as multithreading.
A STEP-BY-STEP UNDERSTANDING OF MULTITHREADING IN JAVA:
What is a Task?
A task in Java is something that performs some work.
Calculating, like multiplying 2 with 4, is an example of a simple task for a computer.
What is Multitasking?
Performing multiple tasks at the same time is known as multitasking.
There are two types of multitasking:
1) Process-based multitasking and
2) Thread-based multitasking.
The entire program is a single unit of dispatchable code sent by the scheduler to the microprocessor, which is known as process-based multitasking.
Like-wise, the smallest unit of an object is the single dispatchable code by the scheduler to the microprocessor, which is known as thread-based multitasking.
Mechanism of Performing the Tasks:
While a single task uses a single thread, multitasking uses multiple threads.
Threading in Java
Threads in Java help perform specific tasks.
Importantly, thread can also be known as the basic building block of processing.
For example, consider various departments in an organization, such as the HR, Marketing, and Finance departments. Suppose each department is a process, and each employee in a department can be considered a thread.
With threads exhibiting independence during tasks, exceptions affecting one thread are restrictive to that thread alone, with the other threads being free of exceptions.
The main advantage of threads is that they can share a common memory area, enabling efficient memory management.
Threading is the term we use when the thread is performing a task.
Similarly, if multiple threads perform various tasks, it is known as multithreading in Java.
For example: Find the odd numbers in the given list (It is a task).
To perform that task, Java needs a thread.
How to Create Threads in Java?
Threads can be created in two ways:
1) By implementing Runnable Interface.
2) By extending Thread
For example,
Class MyClass extends Thread (or implements Runnable)
{
}
In API, the Thread extends Runnable.
Use of Threads in Java
Memory Management:
The processor requires a larger space, making the execution process complicated. However, with the introduction of lighter-weight threads, the execution occurs by utilizing minimal space in the memory.
Easier Resource Management:
However, with the introduction of the multithreading concept in combination with multitasking, the requirement for the number of processors decreases, enabling programmers to lessen the burden of resource management. In multithreading, different threads can share common resources.
While processors require enormous resources, threads require fewer resources. Hence, processors require higher resource management than threads.
Significantly, the number of operations notably increases.
Hence, multithreading helps in
- Enhancing the performance of a computer.
- To perform more than one operation.
- Enables to complete various tasks within a short period.
Creation and Termination of Threads:
After creating a main thread, the programmer can also develop sub-threads.
We use the new Thread() object to create a new thread.
After creating a thread, the start() method helps to execute the thread.
The start() method in the thread also helps to start the program execution.
An important point to note is that the thread need not remain active till the program execution, except for the main thread. However, there is an option to remove all the sub-threads.
Life Cycle of Threads in Multithreading in Java:
There are four major stages in a thread. They include,
First Stage: Born
Second Stage: Runnable (Ready to Run)
Third Stage: 3: Running
Fourth Stage: 4: Dead
Stage 1 Born:
Whenever the programmer initiates the t.start(); method, the cursor moves to the public void run(), where the new thread creation occurs. This is the thread’s initial stage.
Stage 2: Runnable (Ready to Run):
In the runnable stage, the thread will be in the queue after reaching the scheduler, in the next process the microprocessor executes it. The programmer can specify the priority number for ascertaining its position in the queue. However, if the programmer doesn’t specify any priority, the JVM automatically assigns priority five to the queue.
Stage 3: Running:
In the running stage, the thread reaches the microprocessor for execution.
If join() is given, the thread will be killed and will not run again.
If yield(), the thread reaches the runnable stage.
Stage 4: Dead:
Next, after the completion of execution at the microprocessor, the thread will reach the Dead stage.
Stage 4A:
Blocked Stage:
In case of an I/O operation, it goes to a Blocked Stage. After the completion of the input-output operation, it goes to the running stage.
Stage 4B:
Suspended Stage:
By including the suspend() option the thread will suspend. Again, by opting the resume() option, the thread enters the running stage.
Stage 4C:
Wait Stage:
The thread enters the waiting stage with the wait() method. With the inclusion of notify(), the thread enters the running stage.
Stage 4D:
Sleep Stage:
Finally, with the sleep() method, it enters the sleep stage. The thread enters the running stage with the inclusion of notify().
To know more about multithreading, click on the link