JavaSE-线程池（1）- 线程池概念

前提

使用多线程可以并发处理任务，提高程序执行效率。但同时创建和销毁线程会消耗操作系统资源，虽然java 使用线程的方式有多种，但是在实际使用过程中并不建议使用 new Thread 的方式手动创建线程。

线程池概念

线程池可以理解成一个存放线程的容器，当需要使用线程处理任务时从线程池中取，而并非直接创建一个线程

使用线程池的优势

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

来自《Java 并发编程的艺术》

线程池相关接口以及类

Runnable

可以理解成一个不需要获取返回结果的任务

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Callable

类似于 Runnable ，是一个有返回结果的任务

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

Future

异步任务提交后使用 Future 接收，从 Future get 方法可以获取异步任务的返回值

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);
    

    boolean isCancelled();

   
    boolean isDone();

    
    V get() throws InterruptedException, ExecutionException;

    
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

RunnableFuture

Runnable 和 Future 的结合体

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

FutureTask

RunnableFuture 接口的实现类

public class FutureTask<V> implements RunnableFuture<V> {
}

使用demo：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask(() -> {
            Thread.sleep(1000);
            return 100;
        });

        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}

Executor

执行器，用来执行 Runnable 任务，通过实现 Executor 接口可以自定义任务的执行方式，比方使用线程池来执行任务，避免使用 new Thread 的方式来执行

public interface Executor {

    /**
     * 执行方法，执行一个具体的 Runnable 任务
     */
    void execute(Runnable command);
}

ExecutorService

继承自 Executor ，提供更多的方法，实现线程池的类一般继承这个接口

public interface ExecutorService extends Executor {

    /**
     * 关闭执行器，但是会等待已经提交的任务执行完成，不再接收新的任务
     */
    void shutdown();

    /**
     * 尝试停止所有正在执行的任务，不再接收新的任务
     */
    List<Runnable> shutdownNow();

    /**
     *判断执行器是否关闭，如果此执行器已关闭，则返回true。
     */
    boolean isShutdown();

    /**
     * 如果关闭后（调用 shutdown 或 shutdownNow 方法）所有任务都已完成，则返回true。
     * 请注意，除非首先调用shutdown或shutdownNow，否则isTerminated       永远不会为true。
     */
    boolean isTerminated();

    /**
     * Blocks until all tasks have completed execution after a shutdown
     * request, or the timeout occurs, or the current thread is
     * interrupted, whichever happens first.
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 提交一个有返回值的任务并使用 Future 接收
     */
    <T> Future<T> submit(Callable<T> task);

    /**
     * Submits a Runnable task for execution and returns a Future
     * representing that task. The Future's {@code get} method will
     * return the given result upon successful completion.
     */
    <T> Future<T> submit(Runnable task, T result);

    /**
     * 提交任务并使用 Future 接收
     */
    Future<?> submit(Runnable task);

    /**
     * Executes the given tasks, returning a list of Futures holding
     * their status and results when all complete.
     * {@link Future#isDone} is {@code true} for each
     * element of the returned list.
     * Note that a <em>completed</em> task could have
     * terminated either normally or by throwing an exception.
     * The results of this method are undefined if the given
     * collection is modified while this operation is in progress.
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    /**
     * Executes the given tasks, returning a list of Futures holding
     * their status and results
     * when all complete or the timeout expires, whichever happens first.
     * {@link Future#isDone} is {@code true} for each
     * element of the returned list.
     * Upon return, tasks that have not completed are cancelled.
     * Note that a <em>completed</em> task could have
     * terminated either normally or by throwing an exception.
     * The results of this method are undefined if the given
     * collection is modified while this operation is in progress.
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * Executes the given tasks, returning the result
     * of one that has completed successfully (i.e., without throwing
     * an exception), if any do. Upon normal or exceptional return,
     * tasks that have not completed are cancelled.
     * The results of this method are undefined if the given
     * collection is modified while this operation is in progress.
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    /**
     * Executes the given tasks, returning the result
     * of one that has completed successfully (i.e., without throwing
     * an exception), if any do before the given timeout elapses.
     * Upon normal or exceptional return, tasks that have not
     * completed are cancelled.
     * The results of this method are undefined if the given
     * collection is modified while this operation is in progress.
     *
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

AbstractExecutorService

public abstract class AbstractExecutorService implements ExecutorService {
}

实现 ExecutorService 接口，提供ExecutorService执行方法的默认实现

ThreadPoolExecutor

public class ThreadPoolExecutor extends AbstractExecutorService {
}

线程池的具体实现类，继承自 AbstractExecutorService

类结构图：

ThreadPoolExecutor 使用方法

可以使用工具类 Executors 提供的方法创建线程池，比如：

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

public class ExecutorServiceTest1 {

    static class MyTask implements Runnable {

        private int i;

        public MyTask(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread() + " 任务" + i);
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        for (int i = 1; i <= 10; i++) {
            executorService.execute(new MyTask(i));
        }
        executorService.shutdown();
    }
}

以上 Executors.newFixedThreadPool 方法创建了一个拥有固定线程数的线城池

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

执行结果：

Thread[pool-1-thread-1,5,main] 任务1
Thread[pool-1-thread-2,5,main] 任务2
Thread[pool-1-thread-2,5,main] 任务4
Thread[pool-1-thread-1,5,main] 任务3
Thread[pool-1-thread-1,5,main] 任务6
Thread[pool-1-thread-2,5,main] 任务5
Thread[pool-1-thread-2,5,main] 任务8
Thread[pool-1-thread-1,5,main] 任务7
Thread[pool-1-thread-2,5,main] 任务9
Thread[pool-1-thread-1,5,main] 任务10

通过结果可以看出，10个任务都是由两个线程执行的，由于这两个线程一次只能处理两个任务，其他任务只有在线程空闲时才能被处理，实际上线程池不仅维护了一组线程的引用，还维护了这组任务，而任务则是放在队列中，即上文的 LinkedBlockingQueue 参数

参考：
https://blog.csdn.net/qq_36881887/article/details/125707550
https://www.mianshigee.com/note/detail/20134hnk/