How to use Thread Class In Java Multithreading
Java provides Thread class to achieve programming invoking threads thereby some major methods of thread class are shown below in the tabular format with which we deal frequently along the action performed by them.
| Methods | Action Performed |
|---|---|
| isDaemon() | It checks whether the current thread is daemon or not |
| start() | It starts the execution of the thread |
| run() | It does the executable operations statements in the body of this method over a thread |
| sleep() | It is a static method that puts the thread to sleep for a certain time been passed as an argument to it |
| wait() | It sets the thread back in waiting state. |
| notify() | It gives out a notification to one thread that is in waiting state |
| notifyAll() | It gives out a notification to all the thread in the waiting state |
| setDaemon() | It set the current thread as Daemon thread |
| stop() | It is used to stop the execution of the thread |
| resume() | It is used to resume the suspended thread. |
Pre-requisites: Basic syntax and methods to deal with threads
Now let us come up with how to set the name of the thread. By default, threads are named thread-0, thread-1, and so on. But there is also a method that is often used as setName() method. Also corresponding to it there is a method getName() which returns the name of the thread be it default or settled already by using setName() method. The syntax is as follows:
Syntax:
(a) Returning the name of the thread
public String getName() ;
(b) Changing the name of the thread
public void setName(String name);
Taking a step further, let us dive into the implementation part to understand more concepts about multithreading. So, there are basically two ways of implementing multithreading:
Illustration: Consider if one has to multiply all elements by 2 and there are 500 elements in an array.
Examples
// Case 1
// Java Program to illustrate Creation and execution of
// thread via start() and run() method in Single inheritance
// Class 1
// Helper thread Class extending main Thread Class
class MyThread1 extends Thread {
// Method inside MyThread2
// run() method which is called as
// soon as thread is started
public void run()
{
// Print statement when the thread is called
System.out.println("Thread1 is running");
}
}
// Class 2
// Main thread Class extending main Thread Class
class MyThread2 extends Thread {
// Method inside MyThread2
// run() method which is called
// as soon as thread is started
public void run()
{
// run() method which is called as soon as thread is
// started
// Print statement when the thread is called
System.out.println("Thread2 is running");
}
}
// Class 3
// Main Class
class GFG {
// Main method
public static void main(String[] args)
{
// Creating a thread object of our thread class
MyThread1 obj1 = new MyThread1();
MyThread2 obj2 = new MyThread2();
// Getting the threads to the run state
// This thread will transcend from runnable to run
// as start() method will look for run() and execute
// it
obj1.start();
// This thread will also transcend from runnable to
// run as start() method will look for run() and
// execute it
obj2.start();
}
}
// Case 2
// Java Program to illustrate Difference between Runnable
// & Non-runnable Threads And Single Inheritance
// Class 1
// Helper thread Class extending main Thread Class
class MyThread1 extends Thread {
// Method inside MyThread2
// run() method which is called as soon as thread is
// started
public void run() {
// Print statement when the thread is called
System.out.println("Thread 1 is running");
}
}
// Class 2
// Main thread Class extending main Thread Class
class MyThread2 extends Thread {
// Method
public void show() {
// Print statement when thread is called
System.out.println("Thread 2");
}
}
// Class 3
// Main Class
class GFG {
// Main method
public static void main(String[] args) {
// Creating a thread object of our thread class
MyThread1 obj1 = new MyThread1();
MyThread2 obj2 = new MyThread2();
// Getting the threads to the run state
// This thread will transcend from runnable to run
// as start() method will look for run() and execute
// it
obj1.start();
// This thread will now look for run() method which is absent
// Thread is simply created not runnable
obj2.start();
}
}
// Java Program to illustrate difference between
// start() method thread vs show() method
// Class 1
// Helper thread Class extending main Thread Class
class MyThread1 extends Thread {
// Method inside MyThread2
// run() method which is called as soon as thread is
// started
public void run() {
// Print statement when the thread is called
System.out.println("Thread 1 is running");
}
}
// Class 2
// Main thread Class extending main Thread Class
class MyThread2 extends Thread {
// Method
public void show() {
// Print statement when thread is called
System.out.println("Thread 2");
}
}
// Class 3
// Main Class
class GFG {
// Main method
public static void main(String[] args) {
// Creating a thread object of our thread class
MyThread1 obj1 = new MyThread1();
MyThread2 obj2 = new MyThread2();
// Getting the threads to the run state
// This thread will transcend from runnable to run
// as start() method will look for run() and execute
// it
obj1.start();
// This thread is simply a function call as
// no start() method is executed so here only
// thread is created only followed by call
obj2.show();
}
}
Output:
Case 1:
Thread1 is running
Thread2 is running
Here we have created our two thread classes for each thread. In the main method, we are simply creating objects of these thread classes where objects are now threads. So in main, we call thread using start() method over both the threads. Now start() method starts the thread and lookup for their run() method to run. Here both of our thread classes were having run() methods, so both threads are put to run state from runnable by the scheduler, and output on the console is justified.
Case 2:
Thread 1 is running
Here we have created our two thread classes for each thread. In the main method, we are simply creating objects of these thread classes where objects are now threads. So in main, we call thread using start() method over both the threads. Now start() method starts the thread and lookup their run() method to run. Here only class 1 is having the run() method to make the thread transcend from runnable to run state to execute whereas thread 2 is only created but not put to run state by the scheduler as its corresponding run() method was missing. Hence, only thread 1 is called rest thread 2 is created only and is in the runnable state later blocked by scheduler because the corresponding run() method was missing.
Case 3:
Thread 2
Thread 1 is running
Method 2: Using Runnable Interface
Another way to achieve multithreading in java is via the Runnable interface. Here as we have seen in the above example in way 1 where Thread class is extended. Here Runnable interface being a functional interface has its own run() method. Here classes are implemented to the Runnable interface. Later on, in the main() method, Runnable reference is created for the classes that are implemented in order to make bondage with Thread class to run our own corresponding run() methods.
Further, while creating an object of Thread class we will pass these references in Thread class as its constructor allows only one runnable object, which is passed as a parameter while creating Thread class object in a main() method. Now lastly just like what we did in Thread class, start() method is invoked over the runnable object who are now already linked with Thread class objects, so the execution begins for our run() methods in case of Runnable interface. It is shown in the program below as follows:
Example:
// Java Program to illustrate Runnable Interface in threads
// as multiple inheritance is not allowed
// Importing basic packages
import java.io.*;
import java.util.*;
// Class 1
// Helper class implementing Runnable interface
class MyThread1 implements Runnable {
// run() method inside this class
public void run()
{
// Iterating to get more execution of threads
for (int i = 0; i < 5; i++) {
// Print statement whenever run() method
// of this class is called
System.out.println("Thread1");
// Getting sleep method in try block to
// check for any exceptions
try {
// Making the thread pause for a certain
// time using sleep() method
Thread.sleep(1000);
}
// Catch block to handle the exceptions
catch (Exception e) {
}
}
}
}
// Class 2
// Helper class implementing Runnable interface
class MyThread2 implements Runnable {
// run() method inside this class
public void run()
{
for (int i = 0; i < 5; i++) {
// Print statement whenever run() method
// of this class is called
System.out.println("Thread2");
// Getting sleep method in try block to
// check for any exceptions
try {
// Making the thread pause for a certain
// time
// using sleep() method
Thread.sleep(1000);
}
// Catch block to handle the exceptions
catch (Exception e) {
}
}
}
}
// Class 3
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating reference of Runnable to
// our classes above in main() method
Runnable obj1 = new MyThread1();
Runnable obj2 = new MyThread2();
// Creating reference of thread class
// by passing object of Runnable in constructor of
// Thread class
Thread t1 = new Thread(obj1);
Thread t2 = new Thread(obj2);
// Starting the execution of our own run() method
// in the classes above
t1.start();
t2.start();
}
}
Output
Thread2 Thread1 Thread2 Thread1 Thread2 Thread1 Thread2 Thread1 Thread2 Thread1
Points to remember: Whenever you wanted to create threads, there are only two ways:
- Extending the class
- Implementing the interface which is runnable
Make sure to create an object of threads in which you have to pass the object of runnable
Special Methods of Threads
Now let us discuss various methods that are there for threads. Here we will be discussing major methods in order to have a practical understanding of threads and multithreading which are sequential as follows:
- start() Method
- suspend() Method
- stop() Method
- wait() Method
- notify() Method
- notifyAll() Method
- sleep() Method
- Output Without sleep() Method
- Output with sleep() method in Serial Execution Processes (Blocking methods approach)
- Output with sleep() method in Parallel Execution Processes (Unblocking methods approach)
- join() Method
Note: For naive users in multithreading where threads are backbone go through Program 4 to get very basics of threads, how to start, make it hold, or terminate then only toggle to program 1 and rest as follows.
Implementation:
// Example 1
// Java Program to illustrate Output Without sleep() Method
// Class 1
// Helper Class 1
class Shot extends Thread {
// Method 1
public void show() {
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement whenever method
// of this class is called
System.out.println("Shot");
}
}
}
// Class 2
// Helper Class 2
class Miss extends Thread {
// Method 2
public void show() {
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement whenever method
// of this class is called
System.out.println("Miss");
}
}
}
// Class 3
// Main class
public class GFG {
// Method 3
// Main method
public static void main(String[] args) {
// Creating objects in the main() method
// of class 1 and class 2
Shot obj1 = new Shot();
Miss obj2 = new Miss();
// Calling methods of the class 1 and class 2
obj1.show();
obj2.show();
}
}
// Example 2
// Java Program to illustrate Output Using sleep() Method
// in Serial Execution
// Class 1
// Helper Class 1
class Shot extends Thread {
// Method 1
// public void show() {
public void show()
{
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement
System.out.println("Shot");
// Making thread to sleep using sleep() method
// Try-catch block for exceptions
try {
Thread.sleep(1000);
}
catch (Exception e) {
}
}
}
}
// Class 2
// Helper Class 2 Hello
class Miss extends Thread {
// Method 2
// public void show() {
public void show()
{
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement
System.out.println("Miss");
// Making thread to sleep using sleep() method
// Try-catch block for exceptions
try {
Thread.sleep(1000);
}
catch (Exception e) {
}
}
}
}
// Class 3
// Main class
public class GFG {
// Method 3
// Main method
public static void main(String[] args)
{
// Creating objects in the main() method
Shot obj1 = new Shot();
Miss obj2 = new Miss();
// Starting the thread objects
obj1.start();
obj2.start();
// Calling methods of class 1 and class 2
obj1.show();
obj2.show();
}
}
// Example 3
// Java Program to illustrate Output Using sleep() Method
// in Parallel Execution
// Class 1
// Helper Class 1
class Shot extends Thread {
// Method 1
// public void show() {
public void run()
{
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement
System.out.println("Shot");
// Making thread to sleep using sleep() method
// Try catch block for exceptions
try {
Thread.sleep(1000);
}
catch (Exception e) {
}
}
}
}
// Class 2
// Helper Class 2 Hello
class Miss extends Thread {
// Method 2
// public void show() {
public void run()
{
// Iterating to print more number of times
for (int i = 0; i < 5; i++) {
// Print statement
System.out.println("Miss");
// Making thread to sleep using sleep() method
// Try catch block for exceptions
try {
Thread.sleep(1000);
}
catch (Exception e) {
}
}
}
}
// Class 3
// Main class
public class GFG {
// Method 3
// Main method
public static void main(String[] args)
{
// Creating objects in the main() method
Shot obj1 = new Shot();
Miss obj2 = new Miss();
// Starting the thread objects
// using start() method
// start() method calls the run() method
// automatically
obj1.start();
obj2.start();
}
}
Output:
Case 1:
Shot
Shot
Shot
Shot
Shot
Miss
Miss
Miss
Miss
Miss
Case 2: Video output
Shot
Shot
Shot
Shot
Shot
Miss
Miss
Miss
Miss
Miss
Case 3: Video output
Shot
Miss
Shot
Miss
Shot
Miss
Shot
Miss
Shot
Miss
Note: There is no priority been set for threads for which as per the order of execution of threads outputs will vary so do remember this drawback of multithreading of different outputs leading to data inconsistency issues which we will be discussing in-depth in the later part under synchronization in threads.
Priorities in Threads
Priorities in threads is a concept where each thread is having a priority which is represented by numbers ranging from 1 to 10.
- The default priority is set to 5 as excepted.
- Minimum priority is set to 1.
- Maximum priority is set to 10.
Here 3 constants are defined in it namely as follows:
- public static int NORM_PRIORITY
- public static int MIN_PRIORITY
- public static int MAX_PRIORITY
Let us discuss it with an example to get how internally the work is getting executed. Here we will be using the knowledge gathered above as follows:
- We will use currentThread() method to get the name of the current thread. User can also use setName() method if he/she wants to make names of thread as per choice for understanding purposes.
- getName() method will be used to get the name of the thread.
// Java Program to illustrate Priority Threads
// Case 1: No priority is assigned (Default priority)
// Importing input output thread class
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class (Our thread class)
class MyThread extends Thread {
public void run()
{
// Printing the current running thread via getName()
// method using currentThread() method
System.out.println("Running Thread : "
+ currentThread().getName());
// Print and display the priority of current thread
// via currentThread() using getPriority() method
System.out.println("Running Thread Priority : "
+ currentThread().getPriority());
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating objects of MyThread(above class)
// in the main() method
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// Case 1: Default Priority no setting
t1.start();
t2.start();
}
}
// Java Program to illustrate Priority Threads
// Case 2: NORM_PRIORITY
// Importing input output thread class
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class (Our thread class)
class MyThread extends Thread {
// run() method to transit thread from
// runnable to run state
public void run()
{
// Printing the current running thread via getName()
// method using currentThread() method
System.out.println("Running Thread : "
+ currentThread().getName());
// Print and display the priority of current thread
// via currentThread() using getPriority() method
System.out.println("Running Thread Priority : "
+ currentThread().getPriority());
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating objects of MyThread(above class)
// in the main() method
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// Setting priority to thread via NORM_PRIORITY
// which set priority to 5 as default thread
t1.setPriority(Thread.NORM_PRIORITY);
t2.setPriority(Thread.NORM_PRIORITY);
// Setting default priority using
// NORM_PRIORITY
t1.start();
t2.start();
}
}
// Java Program to illustrate Priority Threads
// Case 3: MIN_PRIORITY
// Importing input output thread class
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class (Our thread class)
class MyThread extends Thread {
// run() method to transit thread from
// runnable to run state
public void run()
{
// Printing the current running thread via getName()
// method using currentThread() method
System.out.println("Running Thread : "
+ currentThread().getName());
// Print and display the priority of current thread
// via currentThread() using getPriority() method
System.out.println("Running Thread Priority : "
+ currentThread().getPriority());
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating objects of MyThread(above class)
// in the main() method
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// Setting priority to thread via NORM_PRIORITY
// which set priority to 1 as least priority thread
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
// Setting default priority using
// NORM_PRIORITY
t1.start();
t2.start();
}
}
// Java Program to illustrate Priority Threads
// Case 4: MAX_PRIORITY
// Importing input output thread class
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class (Our thread class)
class MyThread extends Thread {
// run() method to transit thread from
// runnable to run state
public void run()
{
// Printing the current running thread via getName()
// method using currentThread() method
System.out.println("Running Thread : "
+ currentThread().getName());
// Print and display the priority of current thread
// via currentThread() using getPriority() method
System.out.println("Running Thread Priority : "
+ currentThread().getPriority());
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating objects of MyThread(above class)
// in the main() method
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// Setting priority to thread via MAX_PRIORITY
// which set priority to 10 as most priority thread
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
// Setting default priority using
// MAX_PRIORITY
// Starting the threads using start() method
// which automatically invokes run() method
t1.start();
t2.start();
}
}
Output:
Case 1: Default Priority
Running Thread : Thread-0
Running Thread : Thread-1
Running Thread Priority : 5
Running Thread Priority : 5
Case 2: NORM_PRIORITY
Running Thread : Thread-0
Running Thread : Thread-1
Running Thread Priority : 5
Running Thread Priority : 5
Case 3: MIN_PRIORITY
Running Thread : Thread-0
Running Thread : Thread-1
Running Thread Priority : 1
Running Thread Priority : 1
Case 4: MAX_PRIORITY
Running Thread : Thread-1
Running Thread : Thread-0
Running Thread Priority : 10
Running Thread Priority : 10
Output Explanation:
If we look carefully we do see the outputs for cases 1 and 2 are equivalent. This signifies that when the user is not even aware of the priority threads still NORM_PRIORITY is showcasing the same result as to what default priority is. It is because the default priority of running thread as soon as the corresponding start() method is called is executed as per setting priorities for all the thread to 5 which is equivalent to the priority of NORM case. This is because both the outputs are equivalent to each other. While in case 3 priority is set to a minimum on a scale of 1 to 10 so do the same in case 4 where priority is assigned to 10 on the same scale.
Hence, all the outputs in terms of priorities are justified. Now let us move ahead onto an important aspect of priority threading been incorporated in daily life – Daemon thread
Daemon thread is basically a service provider thread that provides services to the user thread. The scope for this thread start() or be it terminate() is completely dependent on the user’s thread as it supports in the backend for user threads being getting run. As soon as the user thread is terminated daemon thread is also terminated at the same time as being the service provider thread.
Hence, the characteristics of the Daemon thread are as follows:
- It is only the service provider thread not responsible for interpretation in user threads.
- So, it is a low-priority thread.
- It is a dependent thread as it has no existence on its own.
- JVM terminates the thread as soon as user threads are terminated and come back into play as the user’s thread starts.
- Yes, you guess the most popular example is garbage collector in java. Some other examples do include ‘finalizer’.
Exceptions: IllegalArgumentException as return type while setting a Daemon thread is boolean so do apply carefully.
Note: To get rid of the exception users thread should only start after setting it to daemon thread. The other way of starting prior setting it to daemon will not work as it will pop-out IllegalArgumentException
As discussed above in the Thread class two most widely used method is as follows:
| Daemon Thread Methods | Action Performed |
|---|---|
| isDaemon() | It checks whether the current thread is a daemon thread or not |
| setDaemon() | It set the thread to be marked as daemon thread |
Let us discuss the implementation of the Daemon thread before jumping onto the garbage collector.
// Java Program to show Working of Daemon Thread
// with users threads
import java.io.*;
// Importing Thread class from java.util package
import java.util.*;
// Class 1
// Helper Class extending Thread class
class CheckingMyDaemonThread extends Thread {
// Method
// run() method which is invoked as soon as
// thread start via start()
public void run()
{
// Checking whether the thread is daemon thread or
// not
if (Thread.currentThread().isDaemon()) {
// Print statement when Daemon thread is called
System.out.println(
"I am daemon thread and I am working");
}
else {
// Print statement whenever users thread is
// called
System.out.println(
"I am user thread and I am working");
}
}
}
// Class 2
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating threads in the main body
CheckingMyDaemonThread t1
= new CheckingMyDaemonThread();
CheckingMyDaemonThread t2
= new CheckingMyDaemonThread();
CheckingMyDaemonThread t3
= new CheckingMyDaemonThread();
// Setting thread named 't2' as our Daemon thread
t2.setDaemon(true);
// Starting all 3 threads using start() method
t1.start();
t2.start();
t3.start();
// Now start() will automatically
// invoke run() method
}
}
// Java Program to show Working of Daemon Thread
// with users threads where start() is invoked
// prior before setting thread to Daemon
import java.io.*;
// Basically we are importing Thread class
// from java.util package
import java.util.*;
// Class 1
// Helper Class extending Thread class
class CheckingMyDaemonThread extends Thread {
// Method
// run() method which is invoked as soon as
// thread start via start()
public void run()
{
// Checking whether the thread is daemon thread or
// not
if (Thread.currentThread().isDaemon()) {
// Print statement when Daemon thread is called
System.out.println(
"I am daemon thread and I am working");
}
else {
// Print statement whenever users thread is
// called
System.out.println(
"I am user thread and I am working");
}
}
}
// Class 2
// Main Class
class GFG {
// Method
// Main driver method
public static void main(String[] args)
{
// Creating threads objects of above class
// in the main body
CheckingMyDaemonThread t1
= new CheckingMyDaemonThread();
CheckingMyDaemonThread t2
= new CheckingMyDaemonThread();
CheckingMyDaemonThread t3
= new CheckingMyDaemonThread();
// Starting all 3 threads using start() method
t1.start();
t2.start();
t3.start();
// Now start() will automatically invoke run()
// method
// Now at last setting already running thread 't2'
// as our Daemon thread will throw an exception
t2.setDaemon(true);
}
}
Another way to achieve the same is through Thread Group in which as the name suggests multiple threads are treated as a single object and later on all the operations are carried on over this object itself aiding in providing a substitute for the Thread Pool.
Note:
While implementing ThreadGroup do note that ThreadGroup is a part of ‘java.lang.ThreadGroup’ class not a part of Thread class in java so do peek out constructors and methods of ThreadGroup class before moving ahead keeping a check over deprecated methods in his class so as not to face any ambiguity further.
Here main() method in itself is a thread because of which you do see Exception in main() while running the program because of which system.main thread exception is thrown sometimes while execution of the program.
Java Multithreading Tutorial
Threads are the backbone of multithreading. We are living in a real world which in itself is caught on the web surrounded by lots of applications. With the advancement in technologies, we cannot achieve the speed required to run them simultaneously unless we introduce the concept of multi-tasking efficiently. It is achieved by the concept of thread.
Contact Us