Code360 powered by Coding Ninjas X Naukri.com. Code360 powered by Coding Ninjas X Naukri.com
Table of contents
1.
Introduction
2.
Benefits of Multithreading
3.
Types of Threads
3.1.
User Threads
3.1.1.
Characteristics of user threads
3.2.
Daemon Threads
3.2.1.
Characteristics of daemon threads:
3.3.
Java
4.
Frequently Asked Questions
4.1.
Can a daemon thread be converted into a user thread?
4.2.
Do user threads affect the performance of an application?
4.3.
How does Java handle thread prioritization?
5.
Conclusion
Last Updated: May 21, 2024
Medium

Types of Threads in Java

Author Rahul Singh
0 upvote
Crack Google SDE interview : Essential projects
Speaker
Saurav Prateek
SDE-2 @
20 Jun, 2024 @ 01:30 PM

Introduction

In Java, threads are the basic units of execution that allow multiple parts of a program to run concurrently. Threads enable efficient utilization of system resources & improve overall performance by dividing a large task into smaller, manageable units. 

Types of Threads in Java

In this article, we will talk about the different types of threads available in Java & their characteristics. We will also discuss the benefits of multithreading with proper code examples.

Benefits of Multithreading

Multithreading is a powerful feature in Java that allows concurrent execution of multiple threads within a single program. By utilizing multiple threads, you can achieve several benefits:

  1. Improved performance: Multithreading enables parallel execution of tasks, allowing different parts of the program to run simultaneously. This can lead to significant performance improvements, especially in scenarios where tasks can be executed independently.
     
  2. Efficient resource utilization: With multithreading, you can make optimal use of system resources. While one thread is waiting for I/O operations or blocked on a synchronization lock, other threads can continue executing, ensuring that the CPU is not idle.
     
  3. Responsiveness: Multithreading can enhance the responsiveness of your application. By delegating time-consuming tasks to separate threads, the main thread can remain responsive to user interactions or other critical operations.
     
  4. Simplified modeling: Some problems are inherently concurrent in nature. Multithreading allows you to model such problems more naturally by assigning different threads to handle different aspects of the problem concurrently.
     
  5. Modularity & maintainability: Multithreading promotes modular design by allowing you to separate concerns & encapsulate related functionality into separate threads. This can lead to cleaner & more maintainable code.
     

Note -: It's important to note that multithreading also introduces complexities such as synchronization, race conditions, & deadlocks.  

Get the tech career you deserve, faster!
Connect with our expert counsellors to understand how to hack your way to success
User rating 4.7/5
1:1 doubt support
95% placement record
Akash Pal
Senior Software Engineer
326% Hike After Job Bootcamp
Himanshu Gusain
Programmer Analyst
32 LPA After Job Bootcamp
After Job
Bootcamp

Types of Threads

In Java, there are two main types of threads: user threads & daemon threads. Let's explore each type in detail.

User Threads

User threads, also known as non-daemon threads, are the most common type of threads used in Java applications. These threads are created & managed by the application itself & are responsible for executing the main logic of the program.

Characteristics of user threads

  • User threads are explicitly created & started by the application.
     
  • The JVM waits for all user threads to complete before terminating the program.
     
  • User threads have a higher priority & are not dependent on the existence of other threads.
     
  • They are used to perform the main tasks & computations of the application.
     

Here's an example of creating & starting a user thread in Java:

public class UserThread extends Thread {
    @Override
    public void run() {
        // Thread logic goes here
        System.out.println("User thread is running.");
    }
}
public class Main {
    public static void main(String[] args) {
        UserThread userThread = new UserThread();
        userThread.start();
    }
}


In this example, we define a UserThread class that extends the Thread class & overrides the run() method to define the thread's logic. In the main() method, we create an instance of UserThread & start it using the start() method.

Daemon Threads

Daemon threads, also known as background threads, are threads that run in the background & provide services to other threads. These threads are typically used for background tasks such as garbage collection, system monitoring, or handling I/O operations.

Characteristics of daemon threads:

  • Daemon threads are created by setting the daemon property of a thread to true before starting it.
     
  • The JVM does not wait for daemon threads to complete before terminating the program. When all user threads have finished execution, the JVM will automatically terminate any remaining daemon threads.
     
  • Daemon threads have a lower priority compared to user threads.
     
  • They are used for performing background tasks that do not require explicit control by the application.
     

Here's an example of creating & starting a daemon thread in Java:

  • Java

Java

public class DaemonThreadExample implements Runnable {
public void run() {
while (true) {
try {
System.out.println("Daemon thread checking resources...");
Thread.sleep(1000); // Check every second
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}

public static void main(String[] args) {
Thread daemonThread = new Thread(new DaemonThreadExample());
daemonThread.setDaemon(true);
daemonThread.start();

try {
Thread.sleep(5000); // Main thread sleeping
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("Main thread ends, daemon may still be running.");
}
}

Output

Daemon thread checking resources...
Daemon thread checking resources...
Daemon thread checking resources...
Daemon thread checking resources...
Daemon thread checking resources...
Main thread ends, daemon may still be running.


In this code, the daemon thread runs a loop that periodically checks system resources. It continues to run in the background and does not prevent the JVM from terminating when the main user tasks are complete.

Frequently Asked Questions

Can a daemon thread be converted into a user thread?

No, once a thread is set as a daemon, it cannot be converted back to a user thread. The nature of the thread is determined at the time of its creation and remains consistent throughout its lifecycle.

Do user threads affect the performance of an application?

Yes, user threads can impact the performance of an application, especially if there are many threads running intensive tasks simultaneously. Proper management and optimization of threads are essential to maintain application efficiency.

How does Java handle thread prioritization?

Java allows developers to set priorities on threads using the setPriority(int) method. Higher priority threads are given preference in execution over lower priority ones, but thread scheduling can still depend on the JVM and the underlying operating system.

Conclusion

In this article, we have learned about the two primary types of threads in Java: user and daemon threads. User threads are crucial for the main operations of an application and must complete before the JVM can terminate. In contrast, daemon threads handle background tasks and do not prevent the JVM from exiting. By utilizing these threads effectively, developers can enhance the responsiveness and efficiency of Java applications. 

You can refer to our guided paths on the Coding Ninjas. You can check our course to learn more about DSADBMSCompetitive ProgrammingPythonJavaJavaScript, etc. Also, check out some of the Guided Paths on topics such as Data Structure andAlgorithmsCompetitive ProgrammingOperating SystemsComputer Networks, DBMSSystem Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry.

Previous article
Start() method in thread
Next article
Shutdown Hook
Live masterclass