Multithreading in Java

Advantages of Java Multithreading

• Since each thread is independent and allows for simultaneous execution of multiple operations, the user is not blocked.
• It saves time because multiple tasks can be completed simultaneously.
• Multithreading in Java enables the simultaneous execution of multiple independent threads. This concurrency feature ensures that exceptions encountered in one thread do not disrupt the execution of other threads.

Multitasking

• Executing several tasks at once is known as multitasking. There are two ways to achive multitask.
  • Multitasking Based on Process (Multiprocessing)
  • Multitasking based on Threads (Multithreading)

Multitasking Based on Process (Multiprocessing)

• Each process in Java operates with its own unique memory address, signifying its distinct memory area.
• Processes in Java are resource-intensive, resulting in expensive communication between them.
• The process switching in Java entails saving and loading registers, memory maps, update lists, and other operations, which contribute to a time delay.

Multitasking based on Threads (Multithreading)

• Lightweight processes within processes are called threads.
• The same address space is used by all threads.
• Multithreading in Java enables concurrent execution of multiple threads within a program. Threads in Java are lightweight and have efficient communication, resulting in minimal overhead.
• For each thread, at least one process is necessary.

What is Thread in java

In Java, a thread is a small part of a program that can be executed independently. It allows concurrent execution of multiple tasks or processes, enabling programs to perform multiple operations simultaneously. Parallelism can be achieved and system resources, like CPU cores, can be used to the fullest extent possible thanks to threads.

The Thread class, which is a component of the java.lang package, is used to represent threads in Java. By creating and managing threads, developers can execute different sections of code concurrently, leading to improved performance and responsiveness in multi-tasking scenarios.

Threads can be created by using two mechanisms

• Extending the Thread class
• Implementing the Runnable Interface

Creating threads by extending the Thread class

A class that extends java.lang is created. thread type. The run() method of the Thread class is overridden by this class. A thread is created inside the run() method. In order to initiate the execution of a thread, we create an object of our new class and call the start() method. Start() calls the Thread object's run() method.

class Multithreadings extends Thread {
    public void run(){
        try {
            System.out.println("Thread " + Thread.currentThread().getId()+ "running");
        }
        catch (Exception e) {
            System.out.println("Exception caught");
        }
    }
}
public class Main { // class to use user define above exception
	public static void main(String args[]){
        int th = 5; // Number of threads
        for (int i = 0; i < th; i++) {
        	Multithreadings object= new Multithreadings();
        	object.start();
        }
	}
}

Thread 17 running
Thread 14 running
Thread 18 running
Thread 15 running
Thread 16 running 

Thread creation by implementing the runnable interface

We develop a brand-new class that complies with Java.lang. run() method is overridden by the runnable interface. After that, we create a Thread object and call its start() method.

class Multithreadings implements Runnable  {
    public void run(){
        try {
            System.out.println("Thread " + Thread.currentThread().getId()+ " running");
        }
        catch (Exception e) {
            System.out.println("Exception caught");
        }
    }
}
public class Main { // class to use user define above exception
	public static void main(String args[]){
        int th = 5; // Number of threads
        for (int i = 0; i < th; i++) {
        	Thread  thread= new Thread(new Multithreadings());
        	thread.start();
        }
   }
}

Thread 14 running
Thread 18 running
Thread 17 running
Thread 16 running
Thread 15 running 

What we learn in multithreading