Java ThreadPoolExecutor execute() Method

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

The ThreadPoolExecutor class in Java provides the execute() method to submit a task for execution. This guide will cover the usage of the execute() method, explain how it works, and provide concise examples to demonstrate its functionality in real-world use cases.

Introduction

The execute() method is used to submit a task for execution. The task must be a Runnable. The method does not return a result and is typically used for tasks that do not need to return any value.

execute Method Syntax

The syntax for the execute method is as follows:

public void execute(Runnable command) 

• The method takes a single parameter command of type Runnable, which represents the task to be executed.

Examples

Example 1: Basic Usage

In this example, we create a ThreadPoolExecutor, submit multiple tasks using the execute() method, and then shut down the executor.

import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; public class ExecuteExample { public static void main(String[] args) { // Create a ThreadPoolExecutor with 2 threads ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2); // Submit tasks to the executor using the execute() method for (int i = 0; i < 5; i++) { final int taskNumber = i + 1; executor.execute(() -> { System.out.println("Executing task " + taskNumber + " by " + Thread.currentThread().getName()); try { Thread.sleep(2000); // Simulate task execution } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Task " + taskNumber + " completed by " + Thread.currentThread().getName()); }); } // Shutdown the executor executor.shutdown(); } } 

Output:

Executing task 1 by pool-1-thread-1 Executing task 2 by pool-1-thread-2 Executing task 3 by pool-1-thread-1 Executing task 4 by pool-1-thread-2 Executing task 5 by pool-1-thread-1 Task 1 completed by pool-1-thread-1 Task 2 completed by pool-1-thread-2 Task 3 completed by pool-1-thread-1 Task 4 completed by pool-1-thread-2 Task 5 completed by pool-1-thread-1 

Example 2: Handling Multiple Short-Lived Tasks

In this example, we use the execute() method to handle multiple short-lived tasks concurrently.

import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; public class ShortLivedTasksExample { public static void main(String[] args) { // Create a ThreadPoolExecutor with 4 threads ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(4); // Submit short-lived tasks to the executor using the execute() method for (int i = 0; i < 10; i++) { final int taskNumber = i + 1; executor.execute(() -> { System.out.println("Task " + taskNumber + " started by " + Thread.currentThread().getName()); try { Thread.sleep(500); // Simulate a short task } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Task " + taskNumber + " completed by " + Thread.currentThread().getName()); }); } // Shutdown the executor executor.shutdown(); } } 

Output:

Task 1 started by pool-1-thread-1 Task 2 started by pool-1-thread-2 Task 3 started by pool-1-thread-3 Task 4 started by pool-1-thread-4 Task 5 started by pool-1-thread-1 Task 6 started by pool-1-thread-2 Task 7 started by pool-1-thread-3 Task 8 started by pool-1-thread-4 Task 9 started by pool-1-thread-1 Task 10 started by pool-1-thread-2 Task 1 completed by pool-1-thread-1 Task 2 completed by pool-1-thread-2 Task 3 completed by pool-1-thread-3 Task 4 completed by pool-1-thread-4 Task 5 completed by pool-1-thread-1 Task 6 completed by pool-1-thread-2 Task 7 completed by pool-1-thread-3 Task 8 completed by pool-1-thread-4 Task 9 completed by pool-1-thread-1 Task 10 completed by pool-1-thread-2 

Example 3: Submitting Tasks with Error Handling

In this example, we use the execute() method to submit tasks and handle any exceptions that may occur during task execution.

import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; public class ErrorHandlingExample { public static void main(String[] args) { // Create a ThreadPoolExecutor with 3 threads ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(3); // Submit tasks to the executor using the execute() method for (int i = 0; i < 6; i++) { final int taskNumber = i + 1; executor.execute(() -> { try { System.out.println("Executing task " + taskNumber + " by " + Thread.currentThread().getName()); if (taskNumber == 3) { throw new RuntimeException("Exception in task " + taskNumber); } Thread.sleep(1000); // Simulate task execution System.out.println("Task " + taskNumber + " completed by " + Thread.currentThread().getName()); } catch (Exception e) { System.err.println("Error in task " + taskNumber + ": " + e.getMessage()); } }); } // Shutdown the executor executor.shutdown(); } } 

Output:

Executing task 1 by pool-1-thread-1 Executing task 2 by pool-1-thread-2 Executing task 3 by pool-1-thread-3 Executing task 4 by pool-1-thread-1 Executing task 5 by pool-1-thread-2 Executing task 6 by pool-1-thread-3 Task 1 completed by pool-1-thread-1 Task 2 completed by pool-1-thread-2 Error in task 3: Exception in task 3 Task 4 completed by pool-1-thread-1 Task 5 completed by pool-1-thread-2 Task 6 completed by pool-1-thread-3 

Example 4: Using a Custom Thread Factory

In this example, we create a ThreadPoolExecutor with a custom thread factory to set custom thread properties and then submit tasks using the execute() method.

import java.util.concurrent.Executors; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.atomic.AtomicInteger; public class CustomThreadFactoryExample { public static void main(String[] args) { // Create a custom thread factory ThreadFactory customThreadFactory = new ThreadFactory() { private final AtomicInteger threadNumber = new AtomicInteger(1); private final ThreadFactory defaultFactory = Executors.defaultThreadFactory(); @Override public Thread newThread(Runnable r) { Thread thread = defaultFactory.newThread(r); thread.setName("CustomThread-" + threadNumber.getAndIncrement()); return thread; } }; // Create a ThreadPoolExecutor with the custom thread factory ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2, customThreadFactory); // Submit tasks to the executor using the execute() method for (int i = 0; i < 4; i++) { final int taskNumber = i + 1; executor.execute(() -> { System.out.println("Executing task " + taskNumber + " by " + Thread.currentThread().getName()); try { Thread.sleep(2000); // Simulate task execution } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Task " + taskNumber + " completed by " + Thread.currentThread().getName()); }); } // Shutdown the executor executor.shutdown(); } } 

Output:

Executing task 1 by CustomThread-1 Executing task 2 by CustomThread-2 Executing task 3 by CustomThread-1 Executing task 4 by CustomThread-2 Task 1 completed by CustomThread-1 Task 2 completed by CustomThread-2 Task 3 completed by CustomThread-1 Task 4 completed by CustomThread-2 

Conclusion

The ThreadPoolExecutor.execute() method in Java is used for submitting tasks for execution without expecting a result. It is particularly useful for handling multiple short-lived tasks concurrently, implementing error handling, and customizing thread properties using a custom thread factory. Understanding how to use this method allows for better management of asynchronous task execution and improved application performance.