Introduction to Multithreading In Java

According to TIOBE Java is ranked number one as the most popular programming developer which is used by over 10 Million developers worldwide.Java is supported by over 15 billion devices. It is used for creating applications for trending technologies like Big Data to household devices like Mobiles and DTH Boxes, it is used everywhere in today’s information age.

Multithreading in Java is a process of executing multiple threads concurrently. Multithreading in Java is a feature that permits simultaneous execution of two or more parts of a program for maximum utilization of the CPU. It is like breaking the overall process of the program into smaller processes or parts.
Each part of such a program is called a thread. So, threads are smaller lightweight processes within a process. A thread is a lightweight sub-process. A sub-process is the smallest unit of processing.

Multiprocessing and multithreading, both are utilized to accomplish multitasking on the CPU. Anyways we use multithreading mostly and not multiprocessing because the threads utilize a shared memory area. They don’t distribute separate memory regions,  so this saves memory space. And with multithreading in java, the context switching between the threads takes less time than in multiprocessing. Java Multithreading is used by programmers mostly in games, animations, video creation, etc. 

In this article, we start with the basics of multi-tasking and eventually detail about multithreading in java. 

What is Multi-Tasking? 

Multitasking is the process of executing multiple tasks simultaneously. We use the CPU to perform various tasks. Multitasking is the ability of the CPU to perform various tasks at the same time. There will be constant context switching of CPU between the tasks which is quick and henceforth brings out better execution and performance. Multitasking can be achieved in two ways:

1. Process-based Multitasking (Multiprocessing)- Process-based multitasking is known as multiprocessing. In multiprocessing, each process has an address in the memory. In other words, each process allocates a separate memory area. A process is a heavyweight. The cost of communication between the processes is high. Saving and loading of registers, memory maps, and updating lists are required to switch from one process to another.   
2. Thread-based Multitasking (Multithreading)-Thread-based multitasking is known as multithreading in java. At least one process is required for each thread. A thread is lightweight. The cost of communication between the threads is low. In this article, we are going to know the details about multithreading in java. 

EXAMPLE of multitasking : Example: While typing a java program in an editor we can listen to audio songs by an mp3 player in our system at the same time we can download a file from the net. All these jobs are executed together and independent of each other hence, this is Process-based multitasking.

What is Multi-Threading: Definition & Advantages of Multi-Threading

Multithreading in java implies multiple threads and is viewed as one of the main features of Java. As the name suggests, a CPU can execute numerous threads independently. At the same time, it simultaneously shares the interaction process resources. Its primary objective is to give synchronous execution of multiple threads to use the CPU time reasonably.

Multithreading in java is a Java feature where one can subdivide the particular program into at least two threads or more to make the execution of the program quick and simple. There are different advantages of multithreading as given beneath

1) Multithreading in java helps perform multiple operations at the same time without blocking the user.

2) You can perform numerous tasks together, so multithreading in java saves time.

3) All Threads are independent, so it doesn’t influence different threads assuming in any case any exception occurs in a single thread.

4) Multithreading in java permits the program to run persistently regardless of whether a part of it is impeded or blocked.

5) Multithreading in java improves overall performance compared to conventional parallel programs that use multiple processes.

6) Multithreading in java permits us to compose effective programs that utilize maximum CPU time.

7) It works on the responsiveness of complex applications or programs.

8) It increases the utilization of CPU resources and reduces the cost of maintenance.

9) Multithreading in java saves time. 

10) Assuming an exception occurs in a single thread, multithreading in java won’t influence different strings as all strings are autonomous.

What Is Thread In Java: Definition And Types Of Thread 

Threads are independent of each other. If there occurs any exception in one of the threads, it doesn’t influence other threads. It utilizes a shared memory area. Threads are referred to as parts of a cycle or process that basically allows a program to execute efficiently with different parts or threads of the process simultaneously.

Utilizing threads, one can perform complicated tasks in the easiest manner. It is viewed as the simplest method to take advantage of multiple CPUs available in a machine. They share common address space and are autonomous of one another.

TYPES OF THREADS IN JAVA

Java offers types of threads: user threads and daemon threads. User threads are high-priority threads. The Java Virtual Machine ( JVM)  will wait for any user thread to finish its task prior to terminating it. Whereas, daemon threads are low-priority threads whose main job is to provide services to user threads.

Basically, User and Daemon are two kinds of threads used in Java by using a ‘Thread Class’.

1. USER THREAD (Non-Daemon Thread): In Java, user threads have a particular life cycle and their life is independent of any other thread. JVM (Java Virtual Machine) waits for any of the user threads to complete its tasks before terminating it. At the point when user threads are finished, JVM terminates the entire program alongside associated daemon strings.
2. DAEMON THREAD: In Java, daemon threads are fundamentally referred to as a service provider that provides services and support to user threads. There are essentially two methods available in thread class for daemon thread: setDaemon() and is Daemon().

USER THREAD VS DAEMON THREAD

User Thread                                         

• JVM waits for user threads to complete their tasks before termination.
• These threads are ordinarily created by the user for executing tasks simultaneously. 
• They are used for critical tasks or core work of an application.
• These threads are referred to as high-priority tasks and hence are required for running in the forefront.

Daemon Thread

• JVM doesn’t wait for daemon threads to finish with their tasks before termination.
• These threads are ordinarily created by JVM.
• They are not used for any critical tasks however to do a few supporting tasks.
• These threads are referred to as low priority threads, in this manner they are particularly required for supporting background tasks like garbage collection, releasing the memory of unused items, and so on. 

The Various States Of Thread: Explanation and Implementation

Multithreading in Java, a thread always exists in one or the other state. It is also referred to as the life cycle of a thread. A brief about various states of threads is given below  

1. New State -Whenever a thread is created, it is always in a new state. For a thread in the new state, the code has not been run yet and thus its execution has not begun yet. In Java, one can get the current state of a thread using the Thread.getState() method. The Java language is the Thread. The State class of Java provides the constants ENUM to represent the state of a thread. The constant for the new state of thread in java is stated below:

• public static final Thread.State NEW  – This represents the first state of a thread that is in the NEW state.

2. Active State –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. Let’s know about them: 

RUNNABLE STATE – 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. The thread scheduler has to allot the thread in the running state. A program implementing multithreading acquires a fixed slice of time for each individual thread.
Each and every thread runs for a short span of time and when that allocated time slice is over, the thread voluntarily gives up the CPU to the other thread, so that the other threads can also run for their slice of time. Whenever such a scenario occurs, all those threads that are waiting for their turn to run and hence they lie in the runnable state for the time being. In the runnable state, there is a queue where the threads lie and wait for their turn.

RUNNING STATE –  When the thread from the queue gets the CPU now it moves from the runnable to the running state. Usually, the most common change in the state of a thread is from runnable to running state and again back to runnable state. 

The multithreading in java language Thread.State class of Java provides the constants ENUM to represent the state of a thread. The constant for the runnable state in java is stated below:

• public static final Thread.State RUNNABLE  – This represents the runnable state of the thread which means that a thread is waiting in the queue to run.

3. Blocked or Waiting State- Whenever a thread is inactive for a span of time but not permanently inactive then either the thread is in the blocked state or is in the waiting state. For example, thread A may want to print some data from the printer. However, at the same time, the other thread B is using the printer to print some other data.
   Now thread A has to wait for thread B to use the printer.
   Thus, thread A currently is in the blocked state. A thread in a blocked state is unable to perform any execution and thus never consumes any cycle of the CPU. Hence, we can say that thread A remains idle for the time being until the thread scheduler reactivates thread A, which is in the waiting or blocked state.

Now, when the main thread invokes the join() method then it is said that the main thread is in the waiting state. The main thread then waits for the child threads to complete their tasks. When the child threads complete their tasks then a notification is sent to the main thread.
The main thread now again moves the thread from waiting to the active state. If there are a lot of threads in the waiting or blocked state, then it is the duty of the thread scheduler to determine which thread to choose for execution and which one to reject. 

The java language Thread.State class of Java provides the constants ENUM to represent the state of a thread. The constant for the blocked and waiting state of the thread is stated below:

• public static final Thread.State BLOCKED-This represents the blocked state where the thread is waiting to acquire a lock.

• public static final Thread.State WAITING -This represents the waiting state. A thread will go to this state when it invokes the Object.wait() method, or Thread.join() method with no timeout. A thread in the waiting state is waiting for another thread to complete its task and only then does it run.

4. Timed Waiting State- In this, a thread is allotted a specific time so that the other thread does not have to wait forever for its execution. For example, a thread A has entered the critical section of a code and is not willing to leave that critical section. In such a scenario, another thread B has to wait forever, which leads to starvation. To avoid such situations, a timed waiting state is given to thread B.
   Thus, thread B lies in the waiting state for a specific span of time and not forever. A real example of timed waiting is when we invoke the sleep() method on a specific thread. The sleep() method puts the thread in the timed wait state. After the time runs out, the thread wakes up and starts its execution from where it has left earlier.
   The multithreading in java language Thread.State class of Java provides the constants ENUM to represent the state of a thread. The constants for the timed waiting state of the thread are stated below:

• public static final Thread.State WAITING -It represents the waiting state of the thread. A thread will go to this state when it invokes the Object.wait() method, or Thread.join() method with no timeout. A thread in the waiting state is waiting for another thread to complete its task.

5. Terminated State- 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. A thread reaches the termination state because of two reasons namely:

• When a thread has finished its job, then it exists or terminates normally.
• ABNORMAL TERMINATION- It occurs when some unusual event such as an unhandled exception or segmentation fault occurs.

The multithreading in java language Thread.State class of Java provides the constants ENUM to represent the state of a thread. The constant for the terminated state is 

• a public static final Thread.State TERMINATED -This represents the final state of a thread that is terminated or dead. A terminated thread means it has completed its execution.

Methods Used For Java Thread: Types, Method, And Description

Serial Number	Type	Method	Description
1)	void	start()	It is used to start the execution of the thread.
2)	void	run()	It is used to do an action for a thread.
3)	static void	sleep()	It sleeps a thread for the specified amount of time.
4)	static Thread	current thread()	It returns a reference to the currently executing thread object.
5)	void	join()	It waits for a thread to die.
6)	int	get priority()	It returns the priority of the thread.
7)	void	setPriority()	It changes the priority of the thread.
8)	String	getname()	It returns the name of the thread.
9)	void	setname()	It changes the name of the thread.
10)	long	getld()	It returns the id of the thread.
11)	boolean	isAlive()	It tests if the thread is alive.
12)	static void	yield()	It causes the currently executing thread object to pause and allow other threads to execute temporarily.
13)	void	suspend()	It is used to suspend the thread.
14)	void	resume()	It is used to resume the suspended thread.
15)	void	stop()	It is used to stop the thread.
16)	void	destroy()	It is used to destroy the thread group and all of its subgroups.
17)	boolean	isDaemon()	It tests if the thread is a daemon thread.
18)	void	setDaemon()	It marks the thread as a daemon or user thread.
19)	void	interrupt()	It interrupts the thread.
20)	boolean	isinterrupted()	It tests whether the thread has been interrupted.
21)	static boolean	interrupted()	It tests whether the current thread has been interrupted.
22)	static int	activeCount()	It returns the number of active threads in the current thread’s thread group.
23)	void	checkAccess()	It determines if the currently running thread has permission to modify the thread.
24)	static boolean	holdLock()	It returns true if and only if the current thread holds the monitor lock on the specified object.
25)	static void	dumpStack()	It is used to print a stack trace of the current thread to the standard error stream.
26)	StackTraceElement[]	getStackTrace()	It returns an array of stack trace elements representing the stack dump of the thread.
27)	static int	enumerate()	It is used to copy every active thread’s thread group and its subgroup into the specified array.
28)	Thread.State	getState()	It is used to return the state of the thread.
29)	ThreadGroup	getThreadGroup()	It is used to return the thread group to which this thread belongs
30)	String	toString()	It is used to return a string representation of any thread, including the thread’s name, priority, and thread group.
31)	void	notify()	It is used to give the notification for only one thread that is waiting for a particular object.
32)	void	notifyAll()	It is used to give the notification to all waiting threads of a particular object.
33)	void	setContextClassLoader()	It sets the context ClassLoader for the Thread.
34)	ClassLoader	getContextClassLoader()	It returns the context ClassLoader for the thread.
35)	static Thread.UncaughtExceptionHandler	getDefaultUncaughtExceptionhandler()	It returns the default handler invoked when a Thread abruptly terminates due to an uncaught exception.
36)	static void	setDefaultUncaughtExceptionHandler()	It sets the default handler invoked when a Thread abruptly terminates due to an uncaught exception.

How To Create A Thread In Java Program: Explanation And Example

Threads are lightweight processes within processes. Multithreading In java, there are two different ways of creating threads in particular, namely via Thread Class and through Runnable Interface, Let’s know about them with help of an example:

1. Thread creation by extending the Thread class

provides constructors and methods to create and perform operations on a thread. Thread class extends Object class and implements Runnable interface. We create a class that extends the Java language Thread class. This class overrides the run() method available in the Thread class.
A thread begins its life inside the run() method. We create an object of our new class and call the start() method to start the execution of a thread. Start() invokes the run() method on the Thread object. Some of the commonly used Constructors of Thread class are

• Thread()
• Thread(String name)
• Thread(Runnable r)
• Thread(Runnable r, String name)

Some of the commonly used methods of Thread class are stated below:

• public void run()-  It is used to perform actions for a thread.
• public void start(): It starts the execution of the thread, and the Java Virtual Machine (JVM)  calls the run() method on the thread.
• public void sleep(long milliseconds): It causes the currently executing thread to sleep which temporarily ceases the execution for the specified number of milliseconds.
• public void join(): It waits for a thread to die.
• public void join(long milliseconds): It waits for a thread to die for the specified milliseconds.
• public int getPriority(): It returns the priority of the thread.
• public int setPriority(int priority): It changes the priority of the thread.
• public String getName(): It returns the name of the thread.
• public void setName(String name): It changes the name of the multithreading in java.
• public Thread currentThread(): It returns the reference of the currently executing thread.
• public int getId(): It returns the id of the thread.
• public Thread.State getState(): It returns the state of the thread.
• public boolean isAlive(): It tests if the thread is alive.
• public void yield(): It causes the currently executing thread object to temporarily pause and allow other threads to execute.
• public void suspends (): It is used to suspend the thread.
• public void resume(): It is used to resume the suspended thread.
• public void stop(): It is used to stop the thread.
• public boolean isDaemon(): It tests if the thread is a daemon thread or not.
• public void setDaemon(boolean b): It marks the thread as daemon or user thread.
• public void interrupt(): It interrupts the thread.
• public boolean isInterrupted(): It tests if the thread has been interrupted or not 
• public static boolean interrupted(): It tests if the current thread has been interrupted or not. 

EXAMPLE OF THREAD CREATION BY EXTENDING THREAD CLASS IN A JAVA PROGRAM

2. Thread creation by implementing the Runnable Interface

We create new multithreading in java language which implements the Runnable interface and overrides the run() method. The runnable interface should be implemented by any thread class whose instances are intended to be executed by a thread. For example, 

Scheduling Thread in Java after Creation

The scheduling of threads in Java programs is done by a component. The component of Java that decides which thread to run or execute and which thread has to wait meanwhile is called a thread scheduler in Java. Multithreading in Java, a thread is only chosen by a thread scheduler if it is in the runnable state of its life cycle.

However, if there is more than one thread in the runnable state, it is up to the thread scheduler to pick any one of the threads and ignore all the other threads. There are some criteria that decide which thread will execute first according to two factors. The two factors for scheduling a thread are stated below and are helpful in Multithreading in java ;

1. Priority: The priority of each multithreading in java lies between 1 to 10. If a thread has a higher priority, it means that thread has got a better chance of getting picked up by the thread scheduler and the thread with lesser priority will wait.
2. Time of Arrival: According to this factor, suppose there are two threads of the same priority entering the runnable state, then priority cannot be the factor to pick a thread from these two threads. In such a case, the time at which the thread arrives is considered by the thread scheduler. A thread that arrived first gets the preference over the other threads.

Conclusion

We have discussed the components of Multithreading In Java in detail starting from the definition to the types of threads in java, etc. Now we can say that it reduces the storage of resources and also make CPUs perform better despite the complexities of using Multithreading in java. The essential part of Multithreading in java implies multiple threads and is viewed as one of the main features of Java. 

As the name suggests, a CPU can execute numerous threads independently. As a java programmer, you must be acknowledged for multithreading in java it is one of the necessary phenomenal and helpful for programmers. It is important for programmers because it permits the execution of various parts of coding simultaneously.

There are mainly two types of threads in Java a User Thread which is also known as a non-daemon thread and the second is a Daemon Thread. I hope this article regarded multitasking in java would be helpful for you.

Frequetly Asked Question’s

1. Why do we use multithreading in Java?

We use multithreading in Java because the main purpose of multithreading is to provide simultaneous or concurrent execution of two or more parts of a program to maximize usage of CPU efficiency.

With the use of multithreading in java, a  multithreaded program contains two or more parts that can run concurrently which leads to a lot of time-saving and maximization of efficiency.

2. What is multithreading and its types?

Multithreading in Java implies multiple threads and is viewed as one of the main features of Java. Multithreading in java is the ability of a CPU to execute numerous threads independently.

At the same time, it simultaneously shares the interaction process resources. Its primary objective is to give synchronous execution of multiple threads to use the CPU time reasonably.

Multithreading in java is a Java feature where one can subdivide the particular program into at least two threads or more to make the execution of the program quick and simple.

Multithreading in java is the phenomenon of executing more than one thread in the system, where the execution of these threads can be of two different types which are Concurrent and Parallel multithread executions.

3. What is the point of multithreading?

There are many benefits of multithreading in Java-like it helps perform multiple operations at the same time without blocking the user. One can perform numerous tasks together, so it saves time.

All the threads while multithreading in java is independent, so it doesn’t influence different threads assuming in any case any exception occurs in a single thread.

Multithreading also permits the program to run persistently regardless of whether a part of it is impeded or blocked. It improves overall performance compared to conventional parallel programs that use multiple processes.

Multithreading in java permits us to compose effective programs that utilize maximum CPU time. It increases the utilization of CPU resources and reduces the cost of maintenance.

4. How many types of multithreading are there in Java?

There are two ways of multithreading in Java which are Thread execution by extending the thread class and Thread Execution by the runnable interface. Apart from these, there are two types of thread namely User Thread and Daemon Thread.

5. What are multithreaded applications?

A multi-threaded application is an application whose architecture takes advantage of the multithreading in java provided by the operating system. Usually, these applications assign specific jobs to individual threads within the process and the threads communicate with each other simultaneously through various means to synchronize their actions

6. How do I know if my CPU supports multithreading?

To know whether your  CPU supports multithreading in java first Click the “Performance” tab in the Task Manager. This shows current CPU and memory usage.

The Task Manager displays a separate graph for each CPU core on your system. And you can see from there whether it supports multithreading or not.

7. Is multithreading faster?

Yes, multithreading in java is faster than multiprocessing when it comes to multitasking on a computer. Even though dispatching a CPU’S  heavy task into multiple threads won’t speed up the execution.

8. Why does multithreading improve performance?

Multithreading in java decreases performance in the sense that it increases the total CPU time required to perform a task. However, it increases performance in the sense that it usually does, and depending on the task’s characteristics reduces the wall clock time that is required to perform the task.

9. What is a daemon thread in Java?

Multithreading in java has daemon threads that are fundamentally referred to as a service provider that provides services and support to user threads. There are essentially two methods available in thread class for daemon thread: setDaemon() and isDaemon().

10. What is the maximum thread priority in Java?

 For multithreading in java Priority of each thread lies between 1 to 10. If a thread has a higher priority, it means that thread has got a better chance of getting picked up by the thread scheduler and the thread with lesser priority will wait. Maximum thread priority in java is 10 and minimum thread priority in java is 1.