Multiple threads can run simultaneously within a single program thanks to Java’s powerful multithreading feature. To create applications that are responsive and efficient, this capability is necessary. This post will discuss the fundamentals of Multithreading in Java, its advantages, and practical implementation techniques.
What are Multiprocessing and Multithreading in Java?
By carrying out multiple tasks at once, multitasking reduces execution time and maximises CPU utilisation. There are two ways to accomplish multitasking in Java, which are outlined below.
- Multiprocessing in Java: Java’s multiprocessing capabilities are entirely dependent on the host computer’s processor capacity. Every process initiated by the user is routed to the CPU. It populates the CPU’s registers with information about the designated process. Multiprocessing in Java requires only one processor. When the user requests that the second process be run concurrently, the alternate CPU core is activated and the process is started.
- Multithreading in Java: Java’s multithreading and multiprocessing techniques are comparable. Nonetheless, there are a few key distinctions between the two. Virtual and independent threads are used in multithreading in place of a physical processor. Depending on how complex each process is, it allocates one or more threads to it. Every thread exists virtually and is separate from the others. Process execution is now much safer as a result. The process won’t stop if one or more threads end during an unforeseen circumstance.
Advantages of Java Multithreading
- Because threads are independent and allow you to execute multiple operations at once, it doesn’t block the user.
- Time can be saved as numerous tasks can be completed simultaneously.
- Because threads are independent of one another, an exception in one thread does not affect other threads.
Types of Multitasking
Process-based Multitasking (Multiprocessing)
- Every process in memory has an address. Stated differently, every process allows a distinct memory region.
- The procedure is bulky.
- There is a significant communication cost within the process.
- Memory maps, updating lists, and saving and loading registers all take time when switching between processes.
Thread-based Multitasking (Multithreading)
- The address space is shared by threads.
- A thread has little weight.
- The threads’ communication costs are minimal.
Methods of Multithreading in Java
| start() | The start method begins the execution of a thread |
| currentThread() | The current thread method returns the reference to the currently executing thread object. |
| run() | The run method initiates an action for the thread. |
| isAlive() | The isAlive method is used to determine whether the thread is alive or dead. |
| sleep() | The sleep method suspends the thread temporarily. |
| yield() | The yield method is used to send the currently executing threads to standby mode and run different sets of threads with higher priority. |
| suspend() | The suspend method is used to immediately suspend thread execution. |
| resume() | The resume method is used to restart the execution of a suspended thread only. |
| interrupt() | The interrupt method causes an interruption in the currently executing thread class. |
| destroy() | The destroy method is used to terminate the execution of a group of threads. |
| stop() | The stop method stops the execution of a thread. |
Threads can be created through two mechanisms
- Extending the Thread class:
// Java code for thread creation by extending
// the Thread class
class MultithreadingDemo extends Thread {
public void run()
{
try {
// Displaying the thread that is running
System.out.println(
“Thread ” + Thread.currentThread().getId()
+ ” is running”);
}
catch (Exception e) {
// Throwing an exception
System. out.println(“Exception is caught”);
}
}
}
// Main Class
public class Multithread {
public static void main(String[] args)
{
int n = 8; // Number of threads
for (int i = 0; i < n; i++) {
MultithreadingDemo object
= new MultithreadingDemo();
object.start();
}
}
}
Output
Thread 15 is running
Thread 14 is running
Thread 16 is running
Thread 12 is running
Thread 11 is running
Thread 13 is running
Thread 18 is running
Thread 17 is running
- Thread creation by implementing the Runnable Interface
// Java code for thread creation by implementing
//The Runnable Interface
class MultithreadingDemo implements Runnable {
public void run()
{
try {
// Displaying the thread that is running
System.out.println(
“Thread ” + Thread.currentThread().getId()
+ ” is running”);
}
catch (Exception e) {
// Throwing an exception
System. out.println(“Exception is caught”);
}
}
}
// Main Class
class Multithread {
public static void main(String[] args)
{
int n = 8; // Number of threads
for (int i = 0; i < n; i++) {
Thread object
= new Thread(new MultithreadingDemo());
object.start();
}
}
}
Output
Thread 13 is running
Thread 11 is running
Thread 12 is running
Thread 15 is running
Thread 14 is running
Thread 18 is running
Thread 17 is running
Thread 16 is running
Conclusion
Multithreading in Java allows several threads to run concurrently, improving speed and responsiveness. Java allows for thread-based multitasking, which maximises CPU efficiency and guarantees process safety. By extending the Thread class or implementing the Runnable interface, developers can create threads and control thread behaviour with methods like start(), run(), and sleep().
