The key to mastering Java multi-threaded programming: learn to create four thread pools

Java multi-threaded programming is an essential skill in modern software development, which can improve the concurrency performance and response speed of the system. In actual development, we often need to manage and control a large number of threads. As an important concurrent programming tool, the thread pool can help us manage threads efficiently and improve resource utilization.

This article will introduce four commonly used thread pool creation methods in Java, and provide specific code examples to help readers quickly master the use of thread pools.

1. FixedThreadPool (fixed size thread pool)

FixedThreadPool is a thread pool with a fixed number of core threads, an unlimited maximum number of threads, and invalid thread idle time. When submitting a task, if there are idle threads in the thread pool, it will be executed immediately; if there are no idle threads, the task will enter the blocking queue and wait. Fixed-size thread pools are suitable for executing long-term, fixed-number tasks.

The following is a sample code to create a thread pool using FixedThreadPool:

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

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

2. CachedThreadPool (cached thread pool)

CachedThreadPool is a core thread A thread pool with a number of 0, an unlimited maximum number of threads, and a thread idle time of 60 seconds. When submitting a task, if there are idle threads in the thread pool, it will be executed immediately; if there are no idle threads, a new thread will be created. When the thread is idle for more than 60 seconds, it is terminated and removed from the thread pool. The cache thread pool is suitable for performing a large number of short-term tasks and can dynamically create and destroy threads according to demand.

The following is a sample code to create a thread pool using CachedThreadPool:

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

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

3. ScheduledThreadPool (scheduled thread pool)

ScheduledThreadPool is a core thread A thread pool with a fixed number and unlimited maximum number of threads, used to execute scheduled tasks or periodic tasks. The thread pool maintains a delay queue internally and processes tasks in an orderly manner according to the delay time of the task.

The following is a sample code that uses ScheduledThreadPool to create a thread pool and execute scheduled tasks:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        
        executorService.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("Task 1 is running.");
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        executorService.scheduleWithFixedDelay(new Runnable() {
            public void run() {
                System.out.println("Task 2 is running.");
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        executorService.shutdown();
    }
}

4. SingleThreadExecutor (single-threaded thread pool)

SingleThreadExecutor is a thread pool with a core number of threads of 1, a maximum number of threads of 1, and invalid thread idle time. All tasks are executed serially in the same thread in first-in, first-out order. The single-threaded thread pool is suitable for scenarios where tasks need to be executed in a specific order and sequence.

The following is a sample code for using SingleThreadExecutor to create a thread pool:

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

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

By mastering the above four thread pool creation methods, we can choose the appropriate thread pool according to different scenarios, thereby improving Concurrency performance and response speed of the program. In actual development, we also need to pay attention to thread safety issues and reasonable thread pool parameter settings to give full play to the advantages of the thread pool.

We hope that the code examples and explanations provided in this article can help readers quickly master the skills of using thread pools in Java multi-threaded programming, so that they can use thread pools more efficiently to improve program performance in actual development.

The above is the detailed content of The key to mastering Java multi-threaded programming: learn to create four thread pools. For more information, please follow other related articles on the PHP Chinese website!