创建线程池的几种方式

创建线程池的几种方式

1. 使用 Executors 工厂方法

Executors 类提供了一些工厂方法来创建不同类型的线程池，下面是一些常用的方法：

固定大小的线程池: 使用 Executors.newFixedThreadPool(int nThreads) 创建一个固定大小的线程池。

单线程线程池: 使用 Executors.newSingleThreadExecutor() 创建一个只有一个工作线程的线程池。

缓存线程池: 使用 Executors.newCachedThreadPool() 创建一个可缓存的线程池，如果线程空闲，则会被回收。

调度线程池: 使用 Executors.newScheduledThreadPool(int corePoolSize) 创建一个可以执行延迟任务或周期性任务的线程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        
        // 创建单线程线程池
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        
        // 创建缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        
        // 创建调度线程池
        ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
    }
}

2. 使用 ThreadPoolExecutor 构造函数

你也可以通过调用 ThreadPoolExecutor 的构造函数直接创建一个线程池，这允许你更细粒度地控制线程池的行为。

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Main {
    public static void main(String[] args) {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
            2, // 核心线程数
            4, // 最大线程数
            60L, // 空闲线程存活时间
            TimeUnit.SECONDS, // 空闲线程存活时间的单位
            new LinkedBlockingQueue<Runnable>(), // 工作队列
            new ThreadFactoryBuilder().setNameFormat("threadpool%d").build() // 线程工厂
        );
    }
}

3. 使用第三方库

有些第三方库也提供了创建线程池的功能，Google Guava 和 Apache Commons Pool，这些库通常提供了更多的配置选项和额外的功能。

// 使用 Google Guava 创建线程池
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService threadPool = MoreExecutors.newDirectExecutorService();
    }
}

4. 使用自定义实现

你也可以自己实现一个线程池，虽然 Java 标准库已经提供了非常完善的线程池实现，但在某些特殊情况下，你可能需要自己实现一个线程池来满足特定的需求。

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
public class CustomThreadPool {
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final LinkedTransferQueue<Runnable> taskQueue = new LinkedTransferQueue<>();
    private final WorkerThread[] threads;
    public CustomThreadPool(int numberOfThreads) {
        threads = new WorkerThread[numberOfThreads];
        for (int i = 0; i < numberOfThreads; i++) {
            threads[i] = new WorkerThread("CustomThreadPool" + threadNumber.getAndIncrement());
            threads[i].start();
        }
    }
    public void execute(Runnable task) {
        taskQueue.offer(task);
    }
    private class WorkerThread extends Thread {
        public WorkerThread(String name) {
            super(name);
        }
        @Override
        public void run() {
            Runnable task;
            while (true) {
                try {
                    task = taskQueue.take();
                    task.run();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}