Java 创建线程池的几种方式

在Java中，线程池是一种重要的资源管理技术，它能够有效地控制线程的数量，重用已有的线程，从而提高应用程序的性能和资源利用率。Java提供了多种创建线程池的方式，主要通过Executors类来实现。下面我们将介绍几种常见的线程池创建方式，并给出相应的代码示例。

1. 固定大小线程池（Fixed Thread Pool）

固定大小线程池是一个拥有固定数量线程的线程池，当所有线程都在执行任务时，新的任务将被放入等待队列中，直到有线程可用为止。

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

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

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            fixedThreadPool.submit(() -> {
                System.out.println("任务 " + taskId + " 正在执行，线程名为：" + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        fixedThreadPool.shutdown(); // 关闭线程池
    }
}

2. 可缓存线程池（Cached Thread Pool）

可缓存线程池可以创建新线程来处理任务。如果之前有可用的线程，则复用它们。这个线程池适合于执行很多短期任务的场景。

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

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

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            cachedThreadPool.submit(() -> {
                System.out.println("任务 " + taskId + " 正在执行，线程名为：" + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        cachedThreadPool.shutdown(); // 关闭线程池
    }
}

3. 单线程池（Single Thread Executor）

单线程池是只有一个线程的线程池，对于需要按顺序执行的任务，单线程池非常合适。它可以保证任务的执行顺序。

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

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        // 创建一个单线程的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            singleThreadExecutor.submit(() -> {
                System.out.println("任务 " + taskId + " 正在执行，线程名为：" + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        singleThreadExecutor.shutdown(); // 关闭线程池
    }
}

4. Scheduled Thread Pool

调度线程池主要用于执行定期或延迟的任务。

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 scheduledExecutorService = Executors.newScheduledThreadPool(2);

        // 延迟1秒执行任务
        scheduledExecutorService.schedule(() -> {
            System.out.println("延迟1秒执行的任务，线程名为：" + Thread.currentThread().getName());
        }, 1, TimeUnit.SECONDS);

        // 每隔2秒执行一次任务
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("每隔2秒执行的任务，线程名为：" + Thread.currentThread().getName());
        }, 0, 2, TimeUnit.SECONDS);

        // 关闭线程池
        scheduledExecutorService.shutdown();
    }
}

总结

Java中的线程池通过Executors类提供了多种创建方式，包括固定大小线程池、可缓存线程池、单线程池以及调度线程池。每种线程池适应不同的场景和需求，合理选择线程池的类型对于提高应用程序的性能至关重要。同时，使用线程池可以减少资源消耗，避免频繁地创建和销毁线程带来的开销。