线程池详解

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义实现线程工厂
 */
public class CustomThreadFactory implements ThreadFactory {
  private final AtomicInteger i = new AtomicInteger(1);

  @Override
  public Thread newThread(Runnable r) {
    // 创建线程
    Thread thread = new Thread(r);
    // 设置线程名称
    thread.setName("线程" + i.getAndIncrement());
    return thread;
  }
}

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.*;

/**
 * 线程池例子
 */
@Slf4j
public class ThreadPoolExample2 {

  public static void main(String[] args) {
    // 线程池的核心线程数
    int corePoolSize = 3;
    // 线程池的最大线程数
    int maximumPoolSize = 5;
    // 线程池的任务队列
    ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(3);
    // 线程池中工作线程（默认是非核心线程）保持空闲的时间
    long keepAliveTime = 60L;
    // 时间单位
    TimeUnit unit = TimeUnit.SECONDS;
    // 自定义线程工厂，不写会使用默认工厂
    ThreadFactory threadFactory = new CustomThreadFactory();
    // 线程池的拒绝策略
    RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
    // 创建线程池
    ThreadPoolExecutor executor = new ThreadPoolExecutor(
        corePoolSize,
        maximumPoolSize,
        keepAliveTime,
        unit,
        workQueue,
        threadFactory,
        handler
    );

    // 提交任务到线程池，最大线程5，队列3，所以最大支持8个线程，大于8会抛出异常，
    // 核心线程3，队列3，所以当线程为6的时候只会开3个线程，超过6才会开启新的线程，直到达到最大线程5
    for (int i = 0; i < 8; i++) {
      final int taskId = i;
      executor.execute(() -> {
        try {
          // 模拟业务处理时间
          Thread.sleep(2000);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
        log.info("Task " + taskId + " is running by " + Thread.currentThread().getName());
      });
    }

    // 关闭线程池，不再接受新任务
    executor.shutdown();
    // 关闭线程池后再提交新任务会报错
//    executor.execute(new Runnable() {
//      @Override
//      public void run() {
//        System.out.println("新任务");
//      }
//    });
    try {
      // 等待所有任务完成，阻塞当前线程，直到所有已提交的任务执行完毕，或者达到指定的等待时间
      if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        // 如果超时后任务仍未完成，则强制关闭线程池
        executor.shutdownNow();
      }
    } catch (InterruptedException e) {
      // 如果等待过程中被中断，也强制关闭线程池
      executor.shutdownNow();
    }
    System.out.println("All tasks are done or interrupted.");
  }
}

Executors—不推荐使用

Executors提供了各种线程池类型创建的静态方法，如常见的newFixedThreadPool、newSingleThreadExecutor、newCachedThreadPool、newSingleThreadScheduledExecutor。

以下是一个使用Java中的ExecutorService和Executors创建线程池的简单示例：

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池例子
 */
@Slf4j
public class ThreadPoolExample {

  public static void main(String[] args) {
    // 创建一个固定大小的线程池
    ExecutorService executor = Executors.newFixedThreadPool(5);
    // 提交任务到线程池
    for (int i = 0; i < 10; i++) {
      final int taskId = i;
      executor.execute(() -> {
        try {
          Thread.sleep(2000);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
        log.info("Task " + taskId + " is running by " + Thread.currentThread().getName());
      });
    }
    // 关闭线程池
    executor.shutdown();
    while (!executor.isTerminated()) {
      // 等待所有任务完成
    }
    System.out.println("All tasks are done.");
  }
}

但不提倡使用该种方式创建线程池，在阿里巴巴JAVA开发手册，对于线程池创建要求：

提交任务

线程池提交任务有两种方法：

无返回值的任务使用 public void execute(Runnable command) 方法提交；
有返回值的任务使用：
- Future submit(Runnable task) ：提交Runnable任务
- Future submit(Runnable task, T result)：提交Runnable任务并指定执行结果
- Future submit(Callable task) ：提交Callable任务

代码示例

import java.util.concurrent.*;

public class ThreadDemo {

  public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 创建任务
    Task task1 = new Task();
    Task task2 = new Task();
    Task task3 = new Task();

    // 创建一个只要一个线程的线程池
    ExecutorService threadpool = Executors.newSingleThreadExecutor();
    threadpool.submit(task1);
    threadpool.submit(task2);
    Future<String> future = threadpool.submit(task3, "执行完成");
    System.out.println("future：" + future.get());

    Callable callable = new Callable() {
      @Override
      public Object call() throws Exception {
        return "执行完成";
      }
    };
    Future future2 = threadpool.submit(callable);
    System.out.println("future2：" + future2.get());
  }
}

class Task implements Runnable {

  @Override
  public void run() {
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }
    System.out.println(Thread.currentThread().getName());
  }
}

如何执行批量任务

# 执行批量任务，返回它们的执行结果
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException
# 执行批量任务，返回指定时间内完成的执行结果，取消未完成的任务
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)
# 执行批量任务，返回最先完成的执行结果
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException
# 执行批量任务，返回指定时间内最先完成的执行结果，取消未完成的任务
public <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)

代码示例

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * 线程池批量提交任务示例
 */
public class InvokeAllDemo {

  public static void main(String[] args) {
    List<Task> tasks = new ArrayList<>();
    for (int i = 1; i <= 10; i++) {
      tasks.add(new Task(i));
    }
    // 创建线程池
    ExecutorService threadpool = Executors.newFixedThreadPool(5);
    try {
      // 批量提交任务
      List<Future<Integer>> futures = threadpool.invokeAll(tasks);
      for (Future<Integer> future : futures) {

最低0.47元/天解锁文章