4 种线程池

Java 里面线程池的顶级接口是 Executor，但是严格意义上讲 Executor 并不是一个线程池，而 只是一个执行线程的工具。真正的线程池接口是 ExecutorService

1、newCachedThreadPool

         newCachedThreadPool 是 Java 中 Executors 类的一个静态方法，用于创建一个可缓存的线程池。这种线程池能够根据需要创建新线程，但在先前构建的线程变得闲置时会回收它们。这意味着线程池的大小不是固定的，而是动态调整的。

下面是一个使用 newCachedThreadPool 创建线程池的示例：

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

public class CachedThreadPoolExample {

    public static void main(String[] args) {
        // 创建一个可缓存的线程池
        ExecutorService executor = Executors.newCachedThreadPool();

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task ID: " + taskId + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println("Task interrupted");
                }
            });
        }

        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }
        System.out.println("All tasks completed.");
    }
}

2、newFixedThreadPool

         newFixedThreadPool 是 Java 中 Executors 类的一个静态方法，用于创建一个固定大小的线程池。当线程池中的线程数量达到指定的最大值后，新提交的任务会在队列中等待，直到线程池中有可用的线程来执行它们。

下面是一个使用 newFixedThreadPool 创建线程池的示例：

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

public class ThreadPoolExample {

    public static void main(String[] args) {
        // 创建一个固定大小的线程池，这里设置为 5 个线程
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task ID: " + taskId + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println("Task interrupted");
                }
            });
        }

        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }
        System.out.println("All tasks completed.");
    }
}

3、newScheduledThreadPool

       newScheduledThreadPool 是 Java 中 Executors 类的一个静态方法，用于创建一个支持定时任务的线程池。这种线程池可以安排任务在给定的延迟后运行，或者定期执行任务

下面是一个使用 newScheduledThreadPool 创建线程池的示例：

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

public class ScheduledThreadPoolExample {

    public static void main(String[] args) {
        // 创建一个支持定时任务的线程池，这里设置为 5 个线程
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            // 安排任务在 1 秒后开始执行，并且每隔 2 秒重复执行一次
            executor.scheduleAtFixedRate(() -> {
                System.out.println("Task ID: " + taskId + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println("Task interrupted");
                }
            }, 1, 2, TimeUnit.SECONDS);
        }

        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }
        System.out.println("All tasks completed.");
    }
}

4、newSingleThreadExecutor

      newSingleThreadExecutor 是 Java 中 Executors 类的一个静态方法，用于创建一个只包含一个线程的线程池。这种线程池保证所有任务按照提交顺序执行，并且在一个线程中依次执行。

下面是一个使用 newSingleThreadExecutor 创建线程池的示例：

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

public class SingleThreadExecutorExample {

    public static void main(String[] args) {
        // 创建一个只包含一个线程的线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task ID: " + taskId + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println("Task interrupted");
                }
            });
        }

        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }
        System.out.println("All tasks completed.");
    }
}