java如何新建一个线程池

在Java中，新建一个线程池的方法包括：通过Executors工厂类、使用ThreadPoolExecutor类、通过ScheduledThreadPoolExecutor类、配置线程池参数等。 在这些方法中，使用ThreadPoolExecutor类可以实现更灵活的线程池配置。下面将详细介绍如何在Java中创建一个线程池，以及相关的配置和注意事项。

一、通过`Executors`工厂类创建线程池

Executors类提供了一些静态工厂方法来创建常见类型的线程池。这些方法包括：

1、固定大小线程池（FixedThreadPool）

固定大小线程池可以通过Executors.newFixedThreadPool(int nThreads)方法创建。在这种线程池中，线程的数量是固定的，如果所有线程都在工作，新的任务将会在队列中等待。

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++) {
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is executing task.");
        }
    }
}

2、单线程池（SingleThreadExecutor）

单线程池可以通过Executors.newSingleThreadExecutor()方法创建。这个线程池只有一个线程，如果这个线程异常终止，会有一个新的线程替代它继续执行后续的任务。

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++) {
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is executing task.");
        }
    }
}

3、缓存线程池（CachedThreadPool）

缓存线程池可以通过Executors.newCachedThreadPool()方法创建。这个线程池会根据需要创建新线程，线程空闲时间超过60秒将被终止并移除。

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++) {
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is executing task.");
        }
    }
}

4、定时线程池（ScheduledThreadPool）

定时线程池可以通过Executors.newScheduledThreadPool(int corePoolSize)方法创建。这个线程池支持定时和周期性任务执行。

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(5);
        scheduledExecutorService.schedule(new Task(), 5, TimeUnit.SECONDS);
        scheduledExecutorService.shutdown();
    }
    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is executing task.");
        }
    }
}

二、使用`ThreadPoolExecutor`类创建线程池

ThreadPoolExecutor类是Java中最核心的线程池实现类，可以通过它来创建高度定制化的线程池。

1、基础构造方法

ThreadPoolExecutor类提供了多个构造方法，其中最基本的构造方法如下：

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue
)

参数说明：

corePoolSize：核心线程数，线程池中始终保留的线程数量。
maximumPoolSize：最大线程数，线程池中允许的最大线程数量。
keepAliveTime：空闲线程的存活时间，超过这个时间的空闲线程将被终止。
unit：keepAliveTime的时间单位。
workQueue：任务队列，用于存放等待执行的任务。

2、实例化`ThreadPoolExecutor`

import java.util.concurrent.*;
public class ThreadPoolExecutorExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 5, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(10)
        );
        for (int i = 0; i < 15; i++) {
            executor.execute(new Task());
        }
        executor.shutdown();
    }
    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is executing task.");
        }
    }
}

3、配置线程池参数

配置线程池参数时，需要根据实际业务需求进行调整。以下是一些常见的配置策略：

核心线程数（corePoolSize）：通常设置为处理器核心数或核心数的两倍。
最大线程数（maximumPoolSize）：根据系统资源和任务特性设置。
空闲线程存活时间（keepAliveTime）：根据任务执行频率和系统资源设置。
任务队列（workQueue）：可以选择ArrayBlockingQueue、LinkedBlockingQueue等不同类型的队列。

4、线程工厂和拒绝策略

ThreadPoolExecutor类还提供了配置线程工厂和拒绝策略的构造方法：

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
    RejectedExecutionHandler handler
)

线程工厂（ThreadFactory）：用于创建新线程，可以自定义线程的名称、优先级等。
拒绝策略（RejectedExecutionHandler）：当任务队列已满且线程数量已达到最大线程数时，如何处理新任务。

常见的拒绝策略有：

AbortPolicy：抛出RejectedExecutionException异常。
CallerRunsPolicy：由调用线程执行任务。
DiscardPolicy：直接丢弃任务。
DiscardOldestPolicy：丢弃最旧的任务。

import java.util.concurrent.*;
public class CustomThreadPoolExecutorExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 5, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(10),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()
        );
        for (int i = 0; i < 15; i++) {
            executor.execute(new Task());
        }
        executor.shutdown();
    }
    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is executing task.");
        }
    }
}

三、通过`ScheduledThreadPoolExecutor`创建定时任务线程池

ScheduledThreadPoolExecutor是ThreadPoolExecutor的子类，专门用于调度任务。可以通过new ScheduledThreadPoolExecutor(corePoolSize)方法创建。

1、实例化`ScheduledThreadPoolExecutor`

import java.util.concurrent.*;
public class ScheduledThreadPoolExecutorExample {
    public static void main(String[] args) {
        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(5);
        executor.schedule(new Task(), 5, TimeUnit.SECONDS);
        executor.scheduleAtFixedRate(new Task(), 0, 10, TimeUnit.SECONDS);
        executor.scheduleWithFixedDelay(new Task(), 0, 10, TimeUnit.SECONDS);
        executor.shutdown();
    }
    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is executing task.");
        }
    }
}

2、定时任务调度方法

schedule(Runnable command, long delay, TimeUnit unit)：延迟执行任务。
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)：按固定频率执行任务。
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)：按固定延迟执行任务。

四、线程池的最佳实践

1、合理配置线程池参数

合理配置线程池参数可以提高系统性能，避免资源浪费和任务堆积。具体配置策略需要根据业务需求和系统资源进行调整。

2、使用线程池工厂

使用线程池工厂可以方便地创建不同类型的线程池，简化代码和维护。

3、监控和管理线程池

使用ThreadPoolExecutor提供的监控方法，如getPoolSize、getActiveCount、getCompletedTaskCount等，可以获取线程池的状态信息，及时发现和解决问题。

4、优雅地关闭线程池

使用shutdown或shutdownNow方法优雅地关闭线程池，确保所有任务执行完毕或立即终止。

5、处理异常

在任务执行过程中，捕获和处理异常，避免线程池中的线程因异常退出。

public class ExceptionHandlingTask implements Runnable {
    @Override
    public void run() {
        try {
            // 任务逻辑
        } catch (Exception e) {
            System.err.println("Task encountered an exception: " + e.getMessage());
        }
    }
}

通过以上方法，可以在Java中创建和管理线程池，提升多线程编程的效率和稳定性。合理配置线程池参数、使用线程池工厂、监控和管理线程池、优雅地关闭线程池以及处理任务异常是实现高效线程池的关键。