1. Multithreading
2. Multitasking
3. Process-based multitasking
4. Thread-based multitasking
5. What is Thread

Multithreading in Java is a process of executing multiple threads simultaneously.

A thread is a lightweight sub-process, the smallest unit of processing. Multiprocessing and multithreading, both are used to achieve multitasking.

However, we use multithreading than multiprocessing because threads use a shared memory area. They don't allocate separate memory area so saves memory, and context-switching between the threads takes less time than process.

Java Multithreading is mostly used in games, animation, etc.

1) It doesn't block the user because threads are independent and you can perform multiple operations at the same time.

2) You can perform many operations together, so it saves time.

3) Threads are independent, so it doesn't affect other threads if an exception occurs in a single thread.

Multitasking is a process of executing multiple tasks simultaneously. We use multitasking to utilize the CPU. Multitasking can be achieved in two ways:

• Process-based Multitasking (Multiprocessing)
• Thread-based Multitasking (Multithreading)

• Each process has an address in memory. In other words, each process allocates a separate memory area.
• A process is heavyweight.
• Cost of communication between the process is high.
• Switching from one process to another requires some time for saving and loading registers, memory maps, updating lists, etc.

• Threads share the same address space.
• A thread is lightweight.
• Cost of communication between the thread is low.

A thread is a lightweight subprocess, the smallest unit of processing. It is a separate path of execution.

Threads are independent. If there occurs exception in one thread, it doesn't affect other threads. It uses a shared memory area.

As shown in the above figure, a thread is executed inside the process. There is context-switching between the threads. There can be multiple processes inside the OS, and one process can have multiple threads.

Java provides Thread class to achieve thread programming. Thread class provides constructors and methods to create and perform operations on a thread. Thread class extends Object class and implements Runnable interface

==========================================================================

 

In Java, a thread always exists in any one of the following states. These states are:

1. New
2. Active
3. Blocked / Waiting
4. Timed Waiting
5. Terminated

New: Whenever a new thread is created, it is always in the new state. For a thread in the new state, the code has not been run yet and thus has not begun its execution.

Active: 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.

• Runnable: 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, i.e., moving the thread the running state.
  A program implementing multithreading acquires a fixed slice of time to 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 willing to run, waiting for their turn to run, lie in the runnable state. In the runnable state, there is a queue where the threads lie.
• Running: When the thread gets the CPU, it moves from the runnable to the running state. Generally, the most common change in the state of a thread is from runnable to running and again back to runnable.

Blocked or Waiting: Whenever a thread is inactive for a span of time (not permanently) then, either the thread is in the blocked state or is in the waiting state.

ADVERTISEMENT

For example, a thread (let's say its name is A) may want to print some data from the printer. However, at the same time, the other thread (let's say its name is B) is using the printer to print some data. Therefore, thread A has to wait for thread B to use the printer. Thus, thread A is in the blocked state. A thread in the blocked state is unable to perform any execution and thus never consume any cycle of the Central Processing Unit (CPU). Hence, we can say that thread A remains idle until the thread scheduler reactivates thread A, which is in the waiting or blocked state.

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 job, a notification is sent to the main thread, which 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 and which one to reject, and the chosen thread is then given the opportunity to run.

Timed Waiting: Sometimes, waiting for leads to starvation. For example, a thread (its name is A) has entered the critical section of a code and is not willing to leave that critical section. In such a scenario, another thread (its name is B) has to wait forever, which leads to starvation. To avoid such scenario, a timed waiting state is given to thread B. Thus, thread 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 start its execution from when it has left earlier.

Terminated: A thread reaches the termination state because of the following reasons:

• When a thread has finished its job, then it exists or terminates normally.
• Abnormal termination: It occurs when some unusual events such as an unhandled exception or segmentation fault.

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.

The following diagram shows the different states involved in the life cycle of a thread.

In Java, one can get the current state of a thread using the Thread.getState() method. The java.lang.Thread.State class of Java provides the constants ENUM to represent the state of a thread. These constants are:

public static final Thread.State NEW  

                                     It represents the first state of a thread that is the NEW state.

public static final Thread.State RUNNABLE  

                           It represents the runnable state.It means a thread is waiting in the queue to run.

public static final Thread.State BLOCKED  

                           It represents the blocked state. In this state, the thread is waiting to acquire a lock.

public static final Thread.State WAITING  

                         It 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.

public static final Thread.State TIMED_WAITING  

                                     It represents the timed waiting state. The main difference between waiting and timed waiting is the time constraint. Waiting has no time constraint, whereas timed waiting has the time constraint. A thread invoking the following method reaches the timed waiting state.

• sleep
• join with timeout
• wait with timeout
• parkUntil
• parkNanos

public static final Thread.State TERMINATED  

                    It represents the final state of a thread that is terminated or dead. A terminated thread means it has completed its execution.

The following Java program shows some of the states of a thread defined above.

FileName: ThreadState.java

1. // ABC class implements the interface Runnable 
2. class ABC implements Runnable  
3. {  
4. public void run()  
5. {  
6. // try-catch block 
7. try 
8. {  
9. // moving thread t2 to the state timed waiting 
10. Thread.sleep(100);  
11. }  
12. catch (InterruptedException ie)  
13. {  
14. ie.printStackTrace();  
15. }  
16. System.out.println("The state of thread t1 while it invoked the method join() on thread t2 -"+ ThreadState.t1.getState());  
17. // try-catch block 
18. try 
19. {  
20. Thread.sleep(200);  
21. }  
22. catch (InterruptedException ie)  
23. {  
24. ie.printStackTrace();  
25. }     
26. }  
27. }  
28. // ThreadState class implements the interface Runnable 
29. public class ThreadState implements Runnable  
30. {  
31. public static Thread t1;  
32. public static ThreadState obj;  
33. // main method  
34. public static void main(String argvs[])  
35. {  
36. // creating an object of the class ThreadState 
37. obj = new ThreadState();  
38. t1 = new Thread(obj);  
39. // thread t1 is spawned  
40. // The thread t1 is currently in the NEW state. 
41. System.out.println("The state of thread t1 after spawning it - " + t1.getState());  
42. // invoking the start() method on  
43. // the thread t1 
44. t1.start();  
45. // thread t1 is moved to the Runnable state 
46. System.out.println("The state of thread t1 after invoking the method start() on it - " + t1.getState());  
47. }  
48. public void run()  
49. {  
50. ABC myObj = new ABC();  
51. Thread t2 = new Thread(myObj);  
52. // thread t2 is created and is currently in the NEW state. 
53. System.out.println("The state of thread t2 after spawning it - "+ t2.getState());  
54. t2.start();  
55. // thread t2 is moved to the runnable state 
56. System.out.println("the state of thread t2 after calling the method start() on it - " + t2.getState());  
57. // try-catch block for the smooth flow of the  program 
58. try 
59. {  
60. // moving the thread t1 to the state timed waiting  
61. Thread.sleep(200);  
62. }  
63. catch (InterruptedException ie)  
64. {  
65. ie.printStackTrace();  
66. }  
67. System.out.println("The state of thread t2 after invoking the method sleep() on it - "+ t2.getState() );  
68. // try-catch block for the smooth flow of the  program 
69. try 
70. {  
71. // waiting for thread t2 to complete its execution 
72. t2.join();  
73. }  
74. catch (InterruptedException ie)  
75. {  
76. ie.printStackTrace();  
77. }  
78. System.out.println("The state of thread t2 when it has completed it's execution - " + t2.getState());  
79. }  
80. }  

Output:

The state of thread t1 after spawning it - NEW

The state of thread t1 after invoking the method start() on it - RUNNABLE

The state of thread t2 after spawning it - NEW

the state of thread t2 after calling the method start() on it - RUNNABLE

The state of thread t1 while it invoked the method join() on thread t2 -TIMED_WAITING

The state of thread t2 after invoking the method sleep() on it - TIMED_WAITING

The state of thread t2 when it has completed it's execution - TERMINATED

Explanation: Whenever we spawn a new thread, that thread attains the new state. When the method start() is invoked on a thread, the thread scheduler moves that thread to the runnable state. Whenever the join() method is invoked on any thread instance, the current thread executing that statement has to wait for this thread to finish its execution, i.e., move that thread to the terminated state. Therefore, before the final print statement is printed on the console, the program invokes the method join() on thread t2, making the thread t1 wait while the thread t2 finishes its execution and thus, the thread t2 get to the terminated or dead state. Thread t1 goes to the waiting state because it is waiting for thread t2 to finish it's execution as it has invoked the method join() on thread t2.

==========================================================================

 

There are two ways to create a thread:

1. By extending Thread class
2. By implementing Runnable interface.

Thread class provide constructors and methods to create and perform operations on a thread.Thread class extends Object class and implements Runnable interface.

ADVERTISEMENTADVERTISEMENT

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

1. public void run(): is used to perform action for a thread.
2. public void start(): starts the execution of the thread.JVM calls the run() method on the thread.
3. public void sleep(long miliseconds): Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds.
4. public void join(): waits for a thread to die.
5. public void join(long miliseconds): waits for a thread to die for the specified miliseconds.
6. public int getPriority(): returns the priority of the thread.
7. public int setPriority(int priority): changes the priority of the thread.
8. public String getName(): returns the name of the thread.
9. public void setName(String name): changes the name of the thread.
10. public Thread currentThread(): returns the reference of currently executing thread.
11. public int getId(): returns the id of the thread.
12. public Thread.State getState(): returns the state of the thread.
13. public boolean isAlive(): tests if the thread is alive.
14. public void yield(): causes the currently executing thread object to temporarily pause and allow other threads to execute.
15. public void suspend(): is used to suspend the thread(depricated).
16. public void resume(): is used to resume the suspended thread(depricated).
17. public void stop(): is used to stop the thread(depricated).
18. public boolean isDaemon(): tests if the thread is a daemon thread.
19. public void setDaemon(boolean b): marks the thread as daemon or user thread.
20. public void interrupt(): interrupts the thread.
21. public boolean isInterrupted(): tests if the thread has been interrupted.
22. public static boolean interrupted(): tests if the current thread has been interrupted.

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. Runnable interface have only one method named run().

1. public void run(): is used to perform action for a thread.

The start() method of Thread class is used to start a newly created thread. It performs the following tasks:

• A new thread starts(with new callstack).
• The thread moves from New state to the Runnable state.
• When the thread gets a chance to execute, its target run() method will run.

FileName: Multi.java

1. class Multi extends Thread{  
2. public void run(){  
3. System.out.println("thread is running...");  
4. }  
5. public static void main(String args[]){  
6. Multi t1=new Multi();  
7. t1.start();  
8.  }  
9. }  

Output:

thread is running...

FileName: Multi3.java

1. class Multi3 implements Runnable{  
2. public void run(){  
3. System.out.println("thread is running...");  
4. }  
5. public static void main(String args[]){  
6. Multi3 m1=new Multi3();  
7. Thread t1 =new Thread(m1);   // Using the constructor Thread(Runnable r) 
8. t1.start();  
9.  }  
10. }  

Output:

thread is running...

If you are not extending the Thread class, your class object would not be treated as a thread object. So you need to explicitly create the Thread class object. We are passing the object of your class that implements Runnable so that your class run() method may execute.

We can directly use the Thread class to spawn new threads using the constructors defined above.

FileName: MyThread1.java

1. public class MyThread1  
2. {  
3. // Main method 
4. public static void main(String argvs[])  
5. {  
6. // creating an object of the Thread class using the constructor Thread(String name)  
7. Thread t= new Thread("My first thread");  
8. // the start() method moves the thread to the active state 
9. t.start();  
10. // getting the thread name by invoking the getName() method 
11. String str = t.getName();  
12. System.out.println(str);  
13. }  
14. }  

Output:

My first thread

Observe the following program.

FileName: MyThread2.java

1. public class MyThread2 implements Runnable  
2. {    
3. public void run()  
4. {    
5. System.out.println("Now the thread is running ...");    
6. }    
7. // main method 
8. public static void main(String argvs[])  
9. {   
10. // creating an object of the class MyThread2 
11. Runnable r1 = new MyThread2();   
12. // creating an object of the class Thread using Thread(Runnable r, String name) 
13. Thread th1 = new Thread(r1, "My new thread");    
14. // the start() method moves the thread to the active state 
15. th1.start();   
16. // getting the thread name by invoking the getName() method 
17. String str = th1.getName();  
18. System.out.println(str);  
19. }    
20. }    

Output:

My new thread

Now the thread is running ...

===============================================================================

 

A component of Java that decides which thread to run or execute and which thread to wait is called a thread scheduler in Java. In Java, a thread is only chosen by a thread scheduler if it is in the runnable state. However, if there is more than one thread in the runnable state, it is up to the thread scheduler to pick one of the threads and ignore the other ones. There are some criteria that decide which thread will execute first. There are two factors for scheduling a thread i.e. Priority and Time of arrival.

Priority: 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.

Time of Arrival: Suppose two threads of the same priority enter the runnable state, then priority cannot be the factor to pick a thread from these two threads. In such a case, arrival time of thread is considered by the thread scheduler. A thread that arrived first gets the preference over the other threads.

On the basis of the above-mentioned factors, the scheduling algorithm is followed by a Java thread scheduler.

In this scheduling algorithm, the scheduler picks the threads thar arrive first in the runnable queue. Observe the following table:

ThreadsTime of Arrivalt10t21t32t43

In the above table, we can see that Thread t1 has arrived first, then Thread t2, then t3, and at last t4, and the order in which the threads will be processed is according to the time of arrival of threads.

Hence, Thread t1 will be processed first, and Thread t4 will be processed last.

Usually, the First Come First Serve algorithm is non-preemptive, which is bad as it may lead to infinite blocking (also known as starvation). To avoid that, some time-slices are provided to the threads so that after some time, the running thread has to give up the CPU. Thus, the other waiting threads also get time to run their job.

In the above diagram, each thread is given a time slice of 2 seconds. Thus, after 2 seconds, the first thread leaves the CPU, and the CPU is then captured by Thread2. The same process repeats for the other threads too.

The name of the scheduling algorithm denotes that the algorithm is related to the priority of the threads.

Suppose there are multiple threads available in the runnable state. The thread scheduler picks that thread that has the highest priority. Since the algorithm is also preemptive, therefore, time slices are also provided to the threads to avoid starvation. Thus, after some time, even if the highest priority thread has not completed its job, it has to release the CPU because of preemption.

Let's understand the working of the Java thread scheduler. Suppose, there are five threads that have different arrival times and different priorities. Now, it is the responsibility of the thread scheduler to decide which thread will get the CPU first.

The thread scheduler selects the thread that has the highest priority, and the thread begins the execution of the job. If a thread is already in runnable state and another thread (that has higher priority) reaches in the runnable state, then the current thread is pre-empted from the processor, and the arrived thread with higher priority gets the CPU time.

When two threads (Thread 2 and Thread 3) having the same priorities and arrival time, the scheduling will be decided on the basis of FCFS algorithm. Thus, the thread that arrives first gets the opportunity to execute first.

==============================================================================

 

The Java Thread class provides the two variant of the sleep() method. First one accepts only an arguments, whereas the other variant accepts two arguments. The method sleep() is being used to halt the working of a thread for a given amount of time. The time up to which the thread remains in the sleeping state is known as the sleeping time of the thread. After the sleeping time is over, the thread starts its execution from where it has left.

Following are the syntax of the sleep() method.

1. public static void sleep(long mls) throws InterruptedException   
2. public static void sleep(long mls, int n) throws InterruptedException   

The method sleep() with the one parameter is the native method, and the implementation of the native method is accomplished in another programming language. The other methods having the two parameters are not the native method. That is, its implementation is accomplished in Java. We can access the sleep() methods with the help of the Thread class, as the signature of the sleep() methods contain the static keyword. The native, as well as the non-native method, throw a checked Exception. Therefore, either try-catch block or the throws keyword can work here.

The Thread.sleep() method can be used with any thread. It means any other thread or the main thread can invoke the sleep() method.

The following are the parameters used in the sleep() method.

mls: The time in milliseconds is represented by the parameter mls. The duration for which the thread will sleep is given by the method sleep().

n: It shows the additional time up to which the programmer or developer wants the thread to be in the sleeping state. The range of n is from 0 to 999999.

The method does not return anything.

Whenever the Thread.sleep() methods execute, it always halts the execution of the current thread.

Whenever another thread does interruption while the current thread is already in the sleep mode, then the InterruptedException is thrown.

If the system that is executing the threads is busy, then the actual sleeping time of the thread is generally more as compared to the time passed in arguments. However, if the system executing the sleep() method has less load, then the actual sleeping time of the thread is almost equal to the time passed in the argument.

The following example shows how one can use the sleep() method on the custom thread.

FileName: TestSleepMethod1.java

1. class TestSleepMethod1 extends Thread{    
2. public void run(){    
3. for(int i=1;i<5;i++){   
4. // the thread will sleep for the 500 milli seconds  
5. try{Thread.sleep(500);}catch(InterruptedException e){System.out.println(e);}    
6.     System.out.println(i);    
7.   }    
8.  }    
9. public static void main(String args[]){    
10.   TestSleepMethod1 t1=new TestSleepMethod1();    
11.   TestSleepMethod1 t2=new TestSleepMethod1();    
12.   t1.start();    
13.   t2.start();    
14.  }    
15. }    

Output:

1

1

2

2

3

3

4

4

As you know well that at a time only one thread is executed. If you sleep a thread for the specified time, the thread scheduler picks up another thread and so on.

FileName: TestSleepMethod2.java

1. // important import statements 
2. import java.lang.Thread;  
3. import java.io.*;  
4. public class TestSleepMethod2  
5. {  
6. // main method 
7. public static void main(String argvs[])  
8. {  
9. try {  
10. for (int j = 0; j < 5; j++)  
11. {  
12. // The main thread sleeps for the 1000 milliseconds, which is 1 sec 
13. // whenever the loop runs 
14. Thread.sleep(1000);  
15. // displaying the value of the variable 
16. System.out.println(j);  
17. }  
18. }  
19. catch (Exception expn)   
20. {  
21. // catching the exception 
22. System.out.println(expn);  
23. }  
24. }  
25. }  

Output:

0

1

2

3

4

The following example throws the exception IllegalArguementException when the time for sleeping is negative.

FileName: TestSleepMethod3.java

1. // important import statements 
2. import java.lang.Thread;  
3. import java.io.*;  
4. public class TestSleepMethod3  
5. {  
6. // main method 
7. public static void main(String argvs[])  
8. {  
9. // we can also use throws keyword followed by 
10. // exception name for throwing the exception 
11. try 
12. {  
13. for (int j = 0; j < 5; j++)   
14. {  
15. // it throws the exception IllegalArgumentException 
16. // as the time is -ive which is -100 
17. Thread.sleep(-100);  
18. // displaying the variable's value 
19. System.out.println(j);  
20. }  
21. }  
22. catch (Exception expn)   
23. {  
24. // the exception iscaught here  
25. System.out.println(expn);  
26. }  
27. }  
28. }  

Output:

java.lang.IllegalArgumentException: timeout value is negative

================================================================================

 

No. After starting a thread, it can never be started again. If you does so, an IllegalThreadStateException is thrown. In such case, thread will run once but for second time, it will throw exception.

Let's understand it by the example given below:

1. public class TestThreadTwice1 extends Thread{  
2. public void run(){  
3.    System.out.println("running...");  
4.  }  
5. public static void main(String args[]){  
6.   TestThreadTwice1 t1=new TestThreadTwice1();  
7.   t1.start();  
8.   t1.start();  
9.  }  
10. }  

Output:

running

Exception in thread "main" java.lang.IllegalThreadStateException

===============================================================================

 

ADVERTISEMENTADVERTISEMENT

• Each thread starts in a separate call stack.
• Invoking the run() method from the main thread, the run() method goes onto the current call stack rather than at the beginning of a new call stack.

FileName: TestCallRun1.java

1. class TestCallRun1 extends Thread{  
2. public void run(){  
3.    System.out.println("running...");  
4.  }  
5. public static void main(String args[]){  
6.   TestCallRun1 t1=new TestCallRun1();  
7.   t1.run();//fine, but does not start a separate call stack 
8.  }  
9. }  

Output:

running...

Problem if you direct call run() method

FileName: TestCallRun2.java

ADVERTISEMENT

1. class TestCallRun2 extends Thread{  
2. public void run(){  
3. for(int i=1;i<5;i++){  
4. try{Thread.sleep(500);}catch(InterruptedException e){System.out.println(e);}  
5.     System.out.println(i);  
6.   }  
7.  }  
8. public static void main(String args[]){  
9.   TestCallRun2 t1=new TestCallRun2();  
10.   TestCallRun2 t2=new TestCallRun2();  
11.   t1.run();  
12.   t2.run();  
13.  }  
14. }  

Output:

1

2

3

4

1

2

3

4

As we can see in the above program that there is no context-switching because here t1 and t2 will be treated as normal object not thread object.

=============================================================================

 

The join() method in Java is provided by the java.lang.Thread class that permits one thread to wait until the other thread to finish its execution. Suppose th be the object the class Thread whose thread is doing its execution currently, then the th.join(); statement ensures that th is finished before the program does the execution of the next statement. When there are more than one thread invoking the join() method, then it leads to overloading on the join() method that permits the developer or programmer to mention the waiting period. However, similar to the sleep() method in Java, the join() method is also dependent on the operating system for the timing, so we should not assume that the join() method waits equal to the time we mention in the parameters. The following are the three overloaded join() methods.

join(): When the join() method is invoked, the current thread stops its execution and the thread goes into the wait state. The current thread remains in the wait state until the thread on which the join() method is invoked has achieved its dead state. If interruption of the thread occurs, then it throws the InterruptedException.

Syntax:

1. public final void join() throws InterruptedException  

join(long mls): When the join() method is invoked, the current thread stops its execution and the thread goes into the wait state. The current thread remains in the wait state until the thread on which the join() method is invoked called is dead or the wait for the specified time frame(in milliseconds) is over.

ADVERTISEMENT

Syntax:

1. public final synchronized void join(long mls) throws InterruptedException, where mls is in milliseconds  

join(long mls, int nanos): When the join() method is invoked, the current thread stops its execution and go into the wait state. The current thread remains in the wait state until the thread on which the join() method is invoked called is dead or the wait for the specified time frame(in milliseconds + nanos) is over.

Syntax:

1. public final synchronized void join(long mls, int nanos) throws InterruptedException, where mls is in milliseconds.  

The following program shows the usage of the join() method.

FileName: ThreadJoinExample.java

1. // A Java program for understanding  
2. // the joining of threads 
3. // import statement 
4. import java.io.*;  
5. // The ThreadJoin class is the child class of the class Thread 
6. class ThreadJoin extends Thread  
7. {  
8. // overriding the run method 
9. public void run()  
10. {  
11. for (int j = 0; j < 2; j++)  
12. {  
13. try 
14. {  
15. // sleeping the thread for 300 milli seconds 
16. Thread.sleep(300);  
17. System.out.println("The current thread name is: " + Thread.currentThread().getName());  
18. }  
19. // catch block for catching the raised exception 
20. catch(Exception e)  
21. {  
22. System.out.println("The exception has been caught: " + e);  
23. }  
24. System.out.println( j );  
25. }  
26. }  
27. }  
28. public class ThreadJoinExample  
29. {  
30. // main method 
31. public static void main (String argvs[])  
32. {  
33. // creating 3 threads 
34. ThreadJoin th1 = new ThreadJoin();  
35. ThreadJoin th2 = new ThreadJoin();  
36. ThreadJoin th3 = new ThreadJoin();  
37. // thread th1 starts 
38. th1.start();  
39. // starting the second thread after when 
40. // the first thread th1 has ended or died. 
41. try 
42. {  
43. System.out.println("The current thread name is: "+ Thread.currentThread().getName());  
44. // invoking the join() method 
45. th1.join();  
46. }  
47. // catch block for catching the raised exception 
48. catch(Exception e)  
49. {  
50. System.out.println("The exception has been caught " + e);  
51. }  
52. // thread th2 starts 
53. th2.start();  
54. // starting the th3 thread after when the thread th2 has ended or died. 
55. try 
56. {  
57. System.out.println("The current thread name is: " + Thread.currentThread().getName());  
58. th2.join();  
59. }  
60. // catch block for catching the raised exception 
61. catch(Exception e)  
62. {  
63. System.out.println("The exception has been caught " + e);  
64. }  
65. // thread th3 starts 
66. th3.start();  
67. }  
68. }  

Output:

The current thread name is: main

The current thread name is: Thread - 0

0

The current thread name is: Thread - 0

1

The current thread name is: main

The current thread name is: Thread - 1

0

The current thread name is: Thread - 1

1

The current thread name is: Thread - 2

0

The current thread name is: Thread - 2

1

Explanation: The above program shows that the second thread th2 begins after the first thread th1 has ended, and the thread th3 starts its work after the second thread th2 has ended or died.

We have learnt in the description of the join() method that whenever the interruption of the thread occurs, it leads to the throwing of InterruptedException. The following example shows the same.

FileName: ThreadJoinExample1.java

1. class ABC extends Thread  
2. {  
3. Thread threadToInterrupt;  
4. // overriding the run() method 
5. public void run()  
6. {  
7. // invoking the method interrupt 
8. threadToInterrupt.interrupt();  
9. }  
10. }  
11. public class ThreadJoinExample1  
12. {  
13. // main method 
14. public static void main(String[] argvs)  
15. {  
16. try 
17. {  
18. // creating an object of the class ABC 
19. ABC th1 = new ABC();  
20. th1.threadToInterrupt = Thread.currentThread();  
21. th1.start();  
22. // invoking the join() method leads  
23. // to the generation of InterruptedException 
24. th1.join();  
25. }  
26. catch (InterruptedException ex)  
27. {  
28. System.out.println("The exception has been caught. " + ex);  
29. }  
30. }  
31. }  

Output:

The exception has been caught. java.lang.InterruptedException

Let' see some other examples.

Filename: TestJoinMethod1.java

1. class TestJoinMethod1 extends Thread{    
2. public void run(){    
3. for(int i=1;i<=5;i++){    
4. try{    
5.     Thread.sleep(500);    
6.    }catch(Exception e){System.out.println(e);}    
7.   System.out.println(i);    
8.   }    
9.  }    
10. public static void main(String args[]){    
11.  TestJoinMethod1 t1=new TestJoinMethod1();    
12.  TestJoinMethod1 t2=new TestJoinMethod1();    
13.  TestJoinMethod1 t3=new TestJoinMethod1();    
14.  t1.start();    
15. try{    
16.   t1.join();    
17.  }catch(Exception e){System.out.println(e);}    
18.  t2.start();    
19.  t3.start();    
20.  }    
21. }    

Output:

      1

       2

       3

       4

       5

       1

       1

       2

       2

       3

       3

       4

       4

       5

       5

We can see in the above example, when t1 completes its task then t2 and t3 starts executing.

Filename: TestJoinMethod2.jav

1. class TestJoinMethod2 extends Thread{    
2. public void run(){    
3. for(int i=1;i<=5;i++){    
4. try{    
5.     Thread.sleep(500);    
6.    }catch(Exception e){System.out.println(e);}    
7.   System.out.println(i);    
8.   }    
9.  }    
10. public static void main(String args[]){    
11.  TestJoinMethod2 t1=new TestJoinMethod2();    
12.  TestJoinMethod2 t2=new TestJoinMethod2();    
13.  TestJoinMethod2 t3=new TestJoinMethod2();    
14.  t1.start();    
15. try{    
16.   t1.join(1500);    
17.  }catch(Exception e){System.out.println(e);}    
18.  t2.start();    
19.  t3.start();    
20.  }    
21. }    

Output:

	1

       2

       3

       1

       4

       1

       2

       5

       2

       3

       3

       4

       4

       5

       5

In the above example, when t1 completes its task for 1500 milliseconds(3 times), then t2 and t3 start executing.

============================================================================

 

The Thread class provides methods to change and get the name of a thread. By default, each thread has a name, i.e. thread-0, thread-1 and so on. By we can change the name of the thread by using the setName() method. The syntax of setName() and getName() methods are given below:

1. public String getName(): is used to return the name of a thread.  
2. public void setName(String name): is used to change the name of a thread.  

We can also set the name of a thread directly when we create a new thread using the constructor of the class.

FileName: TestMultiNaming1.java

1. class TestMultiNaming1 extends Thread{  
2. public void run(){  
3.    System.out.println("running...");  
4.   }  
5. public static void main(String args[]){  
6.   TestMultiNaming1 t1=new TestMultiNaming1();  
7.   TestMultiNaming1 t2=new TestMultiNaming1();  
8.   System.out.println("Name of t1:"+t1.getName());  
9.   System.out.println("Name of t2:"+t2.getName());  
10.   t1.start();  
11.   t2.start();  
12.   t1.setName("Sonoo Jaiswal");  
13.   System.out.println("After changing name of t1:"+t1.getName());  
14.  }  
15. }  

Output:

Name of t1:Thread-0

Name of t2:Thread-1

After changing name of t1:Sonoo Jaiswal

running...

running...

One can also set the name of a thread at the time of the creation of a thread, without using the setName() method. Observe the following code.

FileName: ThreadNamingExample.java

1. // A Java program that shows how one can  
2. // set the name of a thread at the time 
3. // of creation of the thread 
4. // import statement 
5. import java.io.*;  
6. // The ThreadNameClass is the child class of the class Thread 
7. class ThreadName extends Thread  
8. {  
9. // constructor of the class 
10. ThreadName(String threadName)  
11. {  
12. // invoking the constructor of 
13. // the superclass, which is Thread class. 
14. super(threadName);  
15. }  
16. // overriding the method run() 
17. public void run()  
18. {  
19. System.out.println(" The thread is executing....");  
20. }  
21. }  
22. public class ThreadNamingExample  
23. {  
24. // main method 
25. public static void main (String argvs[])  
26. {  
27. // creating two threads and settting their name 
28. // using the contructor of the class 
29. ThreadName th1 = new ThreadName("JavaTpoint1");  
30. ThreadName th2 = new ThreadName("JavaTpoint2");  
31. // invoking the getName() method to get the names 
32. // of the thread created above 
33. System.out.println("Thread - 1: " + th1.getName());  
34. System.out.println("Thread - 2: " + th2.getName());  
35. // invoking the start() method on both the threads 
36. th1.start();  
37. th2.start();  
38. }  
39. }  

Output:

Thread - 1: JavaTpoint1

Thread - 2: JavaTpoint2

 The thread is executing....

 The thread is executing....

The currentThread() method returns a reference of the currently executing thread.

1. public static Thread currentThread()    

FileName: TestMultiNaming2.java

1. class TestMultiNaming2 extends Thread{  
2. public void run(){  
3.   System.out.println(Thread.currentThread().getName());  
4.  }  
5. public static void main(String args[]){  
6.   TestMultiNaming2 t1=new TestMultiNaming2();  
7.   TestMultiNaming2 t2=new TestMultiNaming2();  
8.   t1.start();  
9.   t2.start();  
10.  }  
11. }  

Output:

Thread-0

Thread-1

================================================================================

==================================================== 

Each thread has a priority. Priorities are represented by a number between 1 and 10. In most cases, the thread scheduler schedules the threads according to their priority (known as preemptive scheduling). But it is not guaranteed because it depends on JVM specification that which scheduling it chooses. Note that not only JVM a Java programmer can also assign the priorities of a thread explicitly in a Java program.

Let's discuss the setter and getter method of the thread priority.

public final int getPriority(): The java.lang.Thread.getPriority() method returns the priority of the given thread.

public final void setPriority(int newPriority): The java.lang.Thread.setPriority() method updates or assign the priority of the thread to newPriority. The method throws IllegalArgumentException if the value newPriority goes out of the range, which is 1 (minimum) to 10 (maximum).

ADVERTISEMENT

1. public static int MIN_PRIORITY
2. public static int NORM_PRIORITY
3. public static int MAX_PRIORITY

Default priority of a thread is 5 (NORM_PRIORITY). The value of MIN_PRIORITY is 1 and the value of MAX_PRIORITY is 10.

FileName: ThreadPriorityExample.java

1. // Importing the required classes 
2. import java.lang.*;  
3. public class ThreadPriorityExample extends Thread   
4. {  
5. // Method 1 
6. // Whenever the start() method is called by a thread 
7. // the run() method is invoked 
8. public void run()  
9. {  
10. // the print statement 
11. System.out.println("Inside the run() method");  
12. }  
13. // the main method 
14. public static void main(String argvs[])  
15. {  
16. // Creating threads with the help of ThreadPriorityExample class 
17. ThreadPriorityExample th1 = new ThreadPriorityExample();  
18. ThreadPriorityExample th2 = new ThreadPriorityExample();  
19. ThreadPriorityExample th3 = new ThreadPriorityExample();  
20. // We did not mention the priority of the thread. 
21. // Therefore, the priorities of the thread is 5, the default value 
22. // 1st Thread 
23. // Displaying the priority of the thread 
24. // using the getPriority() method 
25. System.out.println("Priority of the thread th1 is : " + th1.getPriority());  
26. // 2nd Thread  
27. // Display the priority of the thread 
28. System.out.println("Priority of the thread th2 is : " + th2.getPriority());  
29. // 3rd Thread  
30. // // Display the priority of the thread 
31. System.out.println("Priority of the thread th2 is : " + th2.getPriority());  
32. // Setting priorities of above threads by 
33. // passing integer arguments 
34. th1.setPriority(6);  
35. th2.setPriority(3);  
36. th3.setPriority(9);  
37. // 6 
38. System.out.println("Priority of the thread th1 is : " + th1.getPriority());  
39. // 3 
40. System.out.println("Priority of the thread th2 is : " + th2.getPriority());  
41. // 9 
42. System.out.println("Priority of the thread th3 is : " + th3.getPriority());  
43. // Main thread 
44. // Displaying name of the currently executing thread  
45. System.out.println("Currently Executing The Thread : " + Thread.currentThread().getName());  
46. System.out.println("Priority of the main thread is : " + Thread.currentThread().getPriority());  
47. // Priority of the main thread is 10 now 
48. Thread.currentThread().setPriority(10);  
49. System.out.println("Priority of the main thread is : " + Thread.currentThread().getPriority());  
50. }  
51. }  

Output:

Priority of the thread th1 is : 5

Priority of the thread th2 is : 5

Priority of the thread th2 is : 5

Priority of the thread th1 is : 6

Priority of the thread th2 is : 3

Priority of the thread th3 is : 9

Currently Executing The Thread : main

Priority of the main thread is : 5

Priority of the main thread is : 10

We know that a thread with high priority will get preference over lower priority threads when it comes to the execution of threads. However, there can be other scenarios where two threads can have the same priority. All of the processing, in order to look after the threads, is done by the Java thread scheduler. Refer to the following example to comprehend what will happen if two threads have the same priority.

FileName: ThreadPriorityExample1.java

1. // importing the java.lang package 
2. import java.lang.*;  
3. public class ThreadPriorityExample1 extends Thread   
4. {  
5. // Method 1 
6. // Whenever the start() method is called by a thread 
7. // the run() method is invoked 
8. public void run()  
9. {  
10. // the print statement 
11. System.out.println("Inside the run() method");  
12. }  
13. // the main method 
14. public static void main(String argvs[])  
15. {  
16. // Now, priority of the main thread is set to 7 
17. Thread.currentThread().setPriority(7);  
18. // the current thread is retrieved 
19. // using the currentThread() method 
20. // displaying the main thread priority 
21. // using the getPriority() method of the Thread class 
22. System.out.println("Priority of the main thread is : " + Thread.currentThread().getPriority());  
23. // creating a thread by creating an object of the class ThreadPriorityExample1 
24. ThreadPriorityExample1 th1 = new ThreadPriorityExample1();  
25. // th1 thread is the child of the main thread 
26. // therefore, the th1 thread also gets the priority 7 
27. // Displaying the priority of the current thread 
28. System.out.println("Priority of the thread th1 is : " + th1.getPriority());  
29. }  
30. }  

Output:

Priority of the main thread is : 7

Priority of the thread th1 is : 7

Explanation: If there are two threads that have the same priority, then one can not predict which thread will get the chance to execute first. The execution then is dependent on the thread scheduler's algorithm (First Come First Serve, Round-Robin, etc.)

We know that if the value of the parameter newPriority of the method getPriority() goes out of the range (1 to 10), then we get the IllegalArgumentException. Let's observe the same with the help of an example.

FileName: IllegalArgumentException.java

1. // importing the java.lang package 
2. import java.lang.*;  
3. public class IllegalArgumentException extends Thread   
4. {  
5. // the main method 
6. public static void main(String argvs[])  
7. {  
8. // Now, priority of the main thread is set to 17, which is greater than 10 
9. Thread.currentThread().setPriority(17);  
10. // The current thread is retrieved 
11. // using the currentThread() method 
12. // displaying the main thread priority 
13. // using the getPriority() method of the Thread class 
14. System.out.println("Priority of the main thread is : " + Thread.currentThread().getPriority());  
15. }  
16. }  

When we execute the above program, we get the following exception:

Exception in thread "main" java.lang.IllegalArgumentException

	at java.base/java.lang.Thread.setPriority(Thread.java:1141)

	at IllegalArgumentException.main(IllegalArgumentException.java:12)

================================================================================

 

Daemon thread in Java is a service provider thread that provides services to the user thread. Its life depend on the mercy of user threads i.e. when all the user threads dies, JVM terminates this thread automatically.

There are many java daemon threads running automatically e.g. gc, finalizer etc.

You can see all the detail by typing the jconsole in the command prompt. The jconsole tool provides information about the loaded classes, memory usage, running threads etc.

• It provides services to user threads for background supporting tasks. It has no role in life than to serve user threads.
• Its life depends on user threads.
• It is a low priority thread.

The sole purpose of the daemon thread is that it provides services to user thread for background supporting task. If there is no user thread, why should JVM keep running this thread. That is why JVM terminates the daemon thread if there is no user thread.

Backward Skip 10sPlay VideoForward Skip 10sADVERTISEMENT

The java.lang.Thread class provides two methods for java daemon thread.

No.MethodDescription1)public void setDaemon(boolean status)is used to mark the current thread as daemon thread or user thread.2)public boolean isDaemon()is used to check that current is daemon.

File: MyThread.java

1. public class TestDaemonThread1 extends Thread{  
2. public void run(){  
3. if(Thread.currentThread().isDaemon()){//checking for daemon thread 
4.    System.out.println("daemon thread work");  
5.   }  
6. else{  
7.   System.out.println("user thread work");  
8.  }  
9.  }  
10. public static void main(String[] args){  
11.   TestDaemonThread1 t1=new TestDaemonThread1();//creating thread 
12.   TestDaemonThread1 t2=new TestDaemonThread1();  
13.   TestDaemonThread1 t3=new TestDaemonThread1();  
14.   t1.setDaemon(true);//now t1 is daemon thread 
15.   t1.start();//starting threads 
16.   t2.start();  
17.   t3.start();  
18.  }  
19. }  

Output:

daemon thread work

user thread work

user thread work

File: MyThread.java

1. class TestDaemonThread2 extends Thread{  
2. public void run(){  
3.   System.out.println("Name: "+Thread.currentThread().getName());  
4.   System.out.println("Daemon: "+Thread.currentThread().isDaemon());  
5.  }  
6. public static void main(String[] args){  
7.   TestDaemonThread2 t1=new TestDaemonThread2();  
8.   TestDaemonThread2 t2=new TestDaemonThread2();  
9.   t1.start();  
10.   t1.setDaemon(true);//will throw exception here 
11.   t2.start();  
12.  }  
13. }  

Output:

exception in thread main: java.lang.IllegalThreadStateException

===============================================================================

 

Java Thread pool represents a group of worker threads that are waiting for the job and reused many times.

In the case of a thread pool, a group of fixed-size threads is created. A thread from the thread pool is pulled out and assigned a job by the service provider. After completion of the job, the thread is contained in the thread pool again.

newFixedThreadPool(int s): The method creates a thread pool of the fixed size s.

newCachedThreadPool(): The method creates a new thread pool that creates the new threads when needed but will still use the previously created thread whenever they are available to use.

newSingleThreadExecutor(): The method creates a new thread.

Better performance It saves time because there is no need to create a new thread.

It is used in Servlet and JSP where the container creates a thread pool to process the request.

Let's see a simple example of the Java thread pool using ExecutorService and Executors.

File: WorkerThread.java

1. import java.util.concurrent.ExecutorService;  
2. import java.util.concurrent.Executors;  
3. class WorkerThread implements Runnable {  
4. private String message;  
5. public WorkerThread(String s){  
6. this.message=s;  
7.     }  
8. public void run() {  
9.         System.out.println(Thread.currentThread().getName()+" (Start) message = "+message);  
10.         processmessage();//call processmessage method that sleeps the thread for 2 seconds 
11.         System.out.println(Thread.currentThread().getName()+" (End)");//prints thread name 
12.     }  
13. private void processmessage() {  
14. try {  Thread.sleep(2000);  } catch (InterruptedException e) { e.printStackTrace(); }  
15.     }  
16. }  

File: TestThreadPool.java

1. public class TestThreadPool {  
2. public static void main(String[] args) {  
3.         ExecutorService executor = Executors.newFixedThreadPool(5);//creating a pool of 5 threads 
4. for (int i = 0; i < 10; i++) {  
5.             Runnable worker = new WorkerThread("" + i);  
6.             executor.execute(worker);//calling execute method of ExecutorService 
7.           }  
8.         executor.shutdown();  
9. while (!executor.isTerminated()) {   }  
10.         System.out.println("Finished all threads");  
11.     }  
12.  }  

Output:

pool-1-thread-1 (Start) message = 0

pool-1-thread-2 (Start) message = 1

pool-1-thread-3 (Start) message = 2

pool-1-thread-5 (Start) message = 4

pool-1-thread-4 (Start) message = 3

pool-1-thread-2 (End)

pool-1-thread-2 (Start) message = 5

pool-1-thread-1 (End)

pool-1-thread-1 (Start) message = 6

pool-1-thread-3 (End)

pool-1-thread-3 (Start) message = 7

pool-1-thread-4 (End)

pool-1-thread-4 (Start) message = 8

pool-1-thread-5 (End)

pool-1-thread-5 (Start) message = 9

pool-1-thread-2 (End)

pool-1-thread-1 (End)

pool-1-thread-4 (End)

pool-1-thread-3 (End)

pool-1-thread-5 (End)

Finished all threads

Let's see another example of the thread pool.

FileName: ThreadPoolExample.java

1. // important import statements 
2. import java.util.Date;  
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.text.SimpleDateFormat;  
6. class Tasks implements Runnable  
7. {  
8. private String taskName;  
9. // constructor of the class Tasks 
10. public Tasks(String str)  
11. {  
12. // initializing the field taskName  
13. taskName = str;  
14. }  
15. // Printing the task name and then sleeps for 1 sec 
16. // The complete process is getting repeated five times 
17. public void run()  
18. {  
19. try 
20. {  
21. for (int j = 0; j <= 5; j++)  
22. {  
23. if (j == 0)  
24. {  
25. Date dt = new Date();  
26. SimpleDateFormat sdf = new SimpleDateFormat("hh : mm : ss");  
27. //prints the initialization time for every task 
28. System.out.println("Initialization time for the task name: "+ taskName + " = " + sdf.format(dt));  
29. }  
30. else 
31. {  
32. Date dt = new Date();  
33. SimpleDateFormat sdf = new SimpleDateFormat("hh : mm : ss");  
34. // prints the execution time for every task 
35. System.out.println("Time of execution for the task name: " + taskName + " = " +sdf.format(dt));  
36. }  
37. // 1000ms = 1 sec 
38. Thread.sleep(1000);  
39. }  
40. System.out.println(taskName + " is complete.");  
41. }  
42. catch(InterruptedException ie)  
43. {  
44. ie.printStackTrace();  
45. }  
46. }  
47. }  
48. public class ThreadPoolExample  
49. {  
50. // Maximum number of threads in the thread pool 
51. static final int MAX_TH = 3;              
52. // main method 
53. public static void main(String argvs[])  
54. {  
55. // Creating five new tasks 
56. Runnable rb1 = new Tasks("task 1");  
57. Runnable rb2 = new Tasks("task 2");  
58. Runnable rb3 = new Tasks("task 3");  
59. Runnable rb4 = new Tasks("task 4");  
60. Runnable rb5 = new Tasks("task 5");   
61. // creating a thread pool with MAX_TH number of 
62. // threads size the pool size is fixed 
63. ExecutorService pl = Executors.newFixedThreadPool(MAX_TH);  
64. // passes the Task objects to the pool to execute (Step 3) 
65. pl.execute(rb1);  
66. pl.execute(rb2);  
67. pl.execute(rb3);  
68. pl.execute(rb4);  
69. pl.execute(rb5);  
70. // pool is shutdown 
71. pl.shutdown();    
72. }  
73. }  

Output:

Initialization time for the task name: task 1 = 06 : 13 : 02

Initialization time for the task name: task 2 = 06 : 13 : 02

Initialization time for the task name: task 3 = 06 : 13 : 02

Time of execution for the task name: task 1 = 06 : 13 : 04

Time of execution for the task name: task 2 = 06 : 13 : 04

Time of execution for the task name: task 3 = 06 : 13 : 04

Time of execution for the task name: task 1 = 06 : 13 : 05

Time of execution for the task name: task 2 = 06 : 13 : 05

Time of execution for the task name: task 3 = 06 : 13 : 05

Time of execution for the task name: task 1 = 06 : 13 : 06

Time of execution for the task name: task 2 = 06 : 13 : 06

Time of execution for the task name: task 3 = 06 : 13 : 06

Time of execution for the task name: task 1 = 06 : 13 : 07

Time of execution for the task name: task 2 = 06 : 13 : 07

Time of execution for the task name: task 3 = 06 : 13 : 07

Time of execution for the task name: task 1 = 06 : 13 : 08

Time of execution for the task name: task 2 = 06 : 13 : 08

Time of execution for the task name: task 3 = 06 : 13 : 08

task 2 is complete.

Initialization time for the task name: task 4 = 06 : 13 : 09

task 1 is complete.

Initialization time for the task name: task 5 = 06 : 13 : 09

task 3 is complete.

Time of execution for the task name: task 4 = 06 : 13 : 10

Time of execution for the task name: task 5 = 06 : 13 : 10

Time of execution for the task name: task 4 = 06 : 13 : 11

Time of execution for the task name: task 5 = 06 : 13 : 11

Time of execution for the task name: task 4 = 06 : 13 : 12

Time of execution for the task name: task 5 = 06 : 13 : 12

Time of execution for the task name: task 4 = 06 : 13 : 13

Time of execution for the task name: task 5 = 06 : 13 : 13

Time of execution for the task name: task 4 = 06 : 13 : 14

Time of execution for the task name: task 5 = 06 : 13 : 14

task 4 is complete.

task 5 is complete.

Explanation: It is evident by looking at the output of the program that tasks 4 and 5 are executed only when the thread has an idle thread. Until then, the extra tasks are put in the queue.

The takeaway from the above example is when one wants to execute 50 tasks but is not willing to create 50 threads. In such a case, one can create a pool of 10 threads. Thus, 10 out of 50 tasks are assigned, and the rest are put in the queue. Whenever any thread out of 10 threads becomes idle, it picks up the 11th task. The other pending tasks are treated the same way.

The following are the risk involved in the thread pools.

Deadlock: It is a known fact that deadlock can come in any program that involves multithreading, and a thread pool introduces another scenario of deadlock. Consider a scenario where all the threads that are executing are waiting for the results from the threads that are blocked and waiting in the queue because of the non-availability of threads for the execution.

Thread Leakage: Leakage of threads occurs when a thread is being removed from the pool to execute a task but is not returning to it after the completion of the task. For example, when a thread throws the exception and the pool class is not able to catch this exception, then the thread exits and reduces the thread pool size by 1. If the same thing repeats a number of times, then there are fair chances that the pool will become empty, and hence, there are no threads available in the pool for executing other requests.

Resource Thrashing: A lot of time is wasted in context switching among threads when the size of the thread pool is very large. Whenever there are more threads than the optimal number may cause the starvation problem, and it leads to resource thrashing.

Do not queue the tasks that are concurrently waiting for the results obtained from the other tasks. It may lead to a deadlock situation, as explained above.

Care must be taken whenever threads are used for the operation that is long-lived. It may result in the waiting of thread forever and will finally lead to the leakage of the resource.

ADVERTISEMENTADVERTISEMENT

In the end, the thread pool has to be ended explicitly. If it does not happen, then the program continues to execute, and it never ends. Invoke the shutdown() method on the thread pool to terminate the executor. Note that if someone tries to send another task to the executor after shutdown, it will throw a RejectedExecutionException.

One needs to understand the tasks to effectively tune the thread pool. If the given tasks are contrasting, then one should look for pools for executing different varieties of tasks so that one can properly tune them.

To reduce the probability of running JVM out of memory, one can control the maximum threads that can run in JVM. The thread pool cannot create new threads after it has reached the maximum limit.

A thread pool can use the same used thread if the thread has finished its execution. Thus, the time and resources used for the creation of a new thread are saved.

The accurate size of a thread pool is decided by the number of available processors and the type of tasks the threads have to execute. If a system has the P processors that have only got the computation type processes, then the maximum size of the thread pool of P or P + 1 achieves the maximum efficiency. However, the tasks may have to wait for I/O, and in such a scenario, one has to take into consideration the ratio of the waiting time (W) and the service time (S) for the request; resulting in the maximum size of the pool P * (1 + W / S) for the maximum efficiency.

A thread pool is a very handy tool for organizing applications, especially on the server-side. Concept-wise, a thread pool is very easy to comprehend. However, one may have to look at a lot of issues when dealing with a thread pool. It is because the thread pool comes with some risks involved it (risks are discussed above).