Usage analysis of Executor and ThreadPool in Java parallel programming

The Executor interface provides a task execution mechanism, and ThreadPool is its implementation, managing the thread pool to execute tasks. ThreadPool is created using the Executors tool class, such as newFixedThreadPool(), and uses the execute() method to submit tasks. In a practical case, ExecutorService and ThreadPool are used to calculate the sum of squares of numbers to demonstrate the use of parallel programming. Considerations include balancing thread pool size and number of tasks, avoiding exceptions being thrown, and closing ThreadPool after use.

Executor and ThreadPool Usage Guide in Java Parallel Programming

When implementing parallel programming in Java, Executor and ThreadPool are the two core concepts. In this tutorial, we'll take an in-depth look at both mechanisms and demonstrate how to use them through practical examples.

Executor

Executor interface represents a task execution mechanism. It provides a general method execute() for submitting tasks for execution. By implementing the Executor interface, you can customize how tasks are executed, for example, create a custom thread pool or use a ready-made thread pool.

public class CustomExecutor implements Executor {

    @Override
    public void execute(Runnable command) {
        // 自定义任务执行逻辑
        // ...
    }
}

ThreadPool

ThreadPool is an implementation of Executor, providing a set of threads to execute tasks in parallel. It manages the life cycle of threads and ensures that the number of tasks running simultaneously does not exceed the thread pool size.

You can use the Executors tool class to create a thread pool, such as newFixedThreadPool() and newCachedThreadPool():

ExecutorService threadPool = Executors.newFixedThreadPool(5);
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        // 任务代码
    }
});

Practical case

Calculating the square of a number

Consider a scenario where the sum of the squares of a number is calculated in parallel. We can use Executor and ThreadPool to achieve the following:

import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SquareSum {

    private static int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        long sum = 0;
        for (int number : numbers) {
            threadPool.execute(() -> sum += Math.pow(number, 2));
        }

        threadPool.shutdown();
        while (!threadPool.isTerminated()) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Square sum: " + sum);
    }
}

In this case, Executors.newFixedThreadPool() creates a thread pool, Its size matches the number of available processors. Then, the task is submitted to the thread pool to calculate the square of each number in parallel. Finally, the shutdown() method shuts down the thread pool and waits for all tasks to complete.

Notes

• When using ThreadPool, you should pay attention to the balance between the thread pool size and the number of tasks. A thread pool that is too large may lead to a waste of resources, while a thread pool that is too small may lead to performance bottlenecks.
• Tasks submitted to Executor should not throw exceptions. If a task throws an exception, Executor may fail, causing all other tasks to fail to execute.
• After using ThreadPool, the thread pool should be closed using the shutdown() method to ensure that all threads have been stopped.

The above is the detailed content of Usage analysis of Executor and ThreadPool in Java parallel programming. For more information, please follow other related articles on the PHP Chinese website!