In the world of Java programming, developing effective and responsive applications requires a thorough understanding of threads. But what exactly constitutes a thread? In this tutorial, we will learn about thread in Java, including their uses, capabilities, and contributions to concurrent programming.
Thread in Java – Definition
A thread is a small, parallel subprocess that has its call stack and runs alongside other threads. Java’s Thread feature allows you to efficiently complete multiple tasks at once within a single program. Threads are independent execution paths within a program that run concurrently.
It can also mean the course that is followed when a program is being carried out. Generally speaking, every program consists of a single thread, sometimes referred to as the main thread. When the program is first running, the Java Virtual Machine, or JVM, provides this. This same main Thread calls the main() method at this point after providing the main Thread.
In Java, multitasking refers to the ability to work on several tasks at once. Multithreading allows for the division of these tasks or processes into Threads. Let’s talk about the two methods used by Java for multitasking:
- Process-based multitasking: This kind of multitasking involves heavy processes that take a long time to finish because the program takes a long time to switch between them.
- Multithreading: This entails the simultaneous execution of two or more Threads, each of which can be handled in a separate section of the program’s code. Java’s multithreading feature allows Threads to operate in parallel, making efficient use of CPU resources—especially on multi-core processors.
Benefits of using Threads in Java
- Simplified program structure: Splitting a program into several Threads makes it simpler to administer and update.
- Efficient use of system resources: Java Threads optimise system resources by enabling multiple tasks to run simultaneously within a single program.
- Improved program responsiveness: Because multithreading enables you to interact with a program while it handles other tasks in the background, it can enhance a program’s responsiveness.
Java Thread Methods
| S.N. | Modifier and Type | Method | Description |
| 1) | void | start() | It starts the thread’s execution. |
| 2) | void | run() | It is employed to carry out a thread’s task. |
| 3) | static void | sleep() | It sleeps a thread for a specified amount of time. |
| 4) | static Thread | currentThread() | It gives back a reference to the thread object that is currently running. |
| 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 | getId() | 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 allows 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() | The thread group and all of its subgroups are destroyed using it. |
| 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 | interrupted() | It tests whether the thread has been interrupted. |
| 21) | static boolean | interrupted() | It tests whether the current thread has been interrupted. |
| 22) | static int | active count() | It gives back the total number of running threads in the thread group of the active thread. |
| 23) | void | check access() | It ascertains whether the thread that is executing at the moment is authorised to change the thread. |
| 24) | static boolean | hold lock() | If and only if the current thread has the monitor lock on the given object, it returns true. |
| 25) | static void | dump stack() | It is used to print a stack trace of the current thread to the standard error stream. |
| 26) | StackTraceElement[] | getStackTrace() | It gives back an array of stack trace elements that correspond to the thread’s stack dump. |
| 27) | static int | enumerate() | Its purpose is to copy the thread group and subgroup of each running thread into the designated array. |
| 28) | Thread.State | getState() | It is employed to provide the thread’s current state. |
| 29) | ThreadGroup | getThreadGroup() | It is employed to retrieve the thread group that this thread is a member of. |
| 30) | String | toString() | Its purpose is to provide back a string representation of this thread that contains its group, name, and priority. |
| 31) | void | notify() | It serves as a notification system for a single thread that is waiting on a specific object. |
| 32) | void | notifyAll() | It is employed to notify every thread that is waiting for a specific 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() | When an uncaught exception causes a thread to terminate unexpectedly, it returns the default handler that was called. |
| 36) | static void | setDefaultUncaughtExceptionHandler() | It modifies the default handler that is triggered when an uncaught exception causes a thread to end unexpectedly. |
Thread Lifecycle in Java
- New: When the code is not yet running, the model is in its new state.
- Running state or the active stage: When the program is running or prepared to run, it is in this state.
- Suspended state: This state allows you to temporarily halt execution and can be used to pause activity in response to a specified event.
- Blocked state: When a thread is waiting for resources, it is in the blocked state. When a thread is blocked, the thread scheduler rejects any existing unwanted threads to clear the queue.
- Terminated state: this state instantly ends the execution of a thread. A terminated thread has reached the end of its life and is no longer usable.
How to Create a Thread in Java?
- Extension of the Thread class: To create a new Thread, you must extend the Thread class and override the run() method with a new class. You can make an instance of this class and use the start() method to start it by extending the Thread class. As an illustration, consider this:
public class MyThread extends Thread {
public void run()
{
System.out.println(“Starting MyThread”);
for (int i = 0; i < 10; i++)
{
System.out.println(i);
}
System.out.println(“Ending MyThread”);
}
}
public class Main {
public static void main(String[] args)
{
MyThread myThread = new MyThread();
myThread.start();
System.out.println(“Finished”);
}
}
- Implementing the runnable interface: To create a new Thread by implementing the runnable interface, you need to create a new class that implements the runnable interface and overrides the run() method. After that, you may make an instance of this class, encapsulate it in a Thread object, and use the start() function to launch the Thread. As an illustration, consider this:
public class MyRunnable implements Runnable {
public void run()
{
System.out.println(“Starting MyRunnable”);
for (int i = 0; i < 10; i++)
{
System.out.println(i);
}
System.out.println(“Ending MyRunnable”);
}
}
public class Main
{
public static void main(String[] args)
{
MyRunnable myRunnable = new MyRunnable();
Thread myThread = new Thread(myRunnable);
myThread.start();
System.out.println(“Finished”);
}
}
Conclusion
Programming in Java requires an understanding of threads to create responsive and effective applications. Multitasking, streamlining program structure, maximising resource utilisation, and enhancing responsiveness are all made possible by threads. Java’s concurrent programming capabilities can be improved by implementing the Runnable interface or by creating threads using the Thread class extension, both of which have different methods and lifecycle stages.
