线程---线程池

线程池

• 什么是线程池？

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后执行，主要实现：创建线程和管理线程，并且给线程分配任务。线程池中的线程是并发执行的。

• 线程池的组成部分：

一个比较简单的线程池至少应包含线程池管理器、工作线程、任务列队、任务接口等部分。

其中线程池管理器的作用是创建、销毁并管理线程池，将工作线程放入线程池中；

工作线程是一个可以循环执行任务的线程，在没有任务是进行等待；

任务列队的作用是提供一种缓冲机制，将没有处理的任务放在任务列队中；

任务接口是每个任务必须实现的接口，主要用来规定任务的入口、任务执行完后的收尾工作、任务的执行状态等，工作线程通过该接口调度任务的执行。

线程池管理器至少有下列功能：创建线程池，销毁线程池，添加新任务。

• 作用：

  （1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

  （2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。减少创建和销毁线程的次数，多个任务重复使用线程，线程创建的开销被多个任务分担，请求到达时线程已经存在，消除线程创建带来的延迟，应用程序响应加快；

  （3）提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
  还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用
  线程池，必须对其实现原理了如指掌。可根据系统情况调整执行的线程数量，防止消耗过多内存，资源不足问题。 《java并发编程艺术》

• 线程池的类的继承关系:
  如图：
  

Executor接口：（void execute(Runnable command)）该接口定义执行Runnable任务的方式;

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the <tt>Executor</tt> implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution.
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

ThreadPoolExecutor类：线程池具体实现；

public class ThreadPoolExecutor extends AbstractExecutorService 

Executors类：提供工厂方法用于创建线程池，线程池工厂类,提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口；

public class Executors 

ScheduledExecutorService定时调度接口

public interface ScheduledExecutorService extends ExecutorService{
/**
 * 在给定延时后，创建并执行一个一次性的Runnable任务
 * 任务执行完毕后，ScheduledFuture#get()方法会返回null
 */
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

/**
 * 在给定延时后，创建并执行一个ScheduledFutureTask
 * ScheduledFuture 可以获取结果或取消任务
 */
public <V> ScheduledFuture<V> schedule(Callable<V> callable, ong delay, TimeUnit unit);

/**
 * 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期
 * 也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推
 * 如果执行任务发生异常，随后的任务将被禁止，否则任务只会在被取消或者Executor被终止后停止
 * 如果任何执行的任务超过了周期，随后的执行会延时，不会并发执行
 */
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
        long initialDelay,
        long period,
        TimeUnit unit);

/**
 * 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟
 * 如果执行任务发生异常，随后的任务将被禁止，否则任务只会在被取消或者Executor被终止后停止
 */
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
        long initialDelay,
        long delay,
        TimeUnit unit);
}

ExecutorService接口：增加Executor的行为,是Executor实现类的最直接的接口,该接口定义提供对Executor的服务；

public interface ExecutorService extends Executor {

管理任务如何终止的 shutdown相关方法：

/**
 * 启动一次有序的关闭，之前提交的任务执行，但不接受新任务
 * 这个方法不会等待之前提交的任务执行完毕
 */
    void shutdown();
/**
 * 试图停止所有正在执行的任务，暂停处理正在等待的任务，返回一个等待执行的任务列表
 * 这个方法不会等待正在执行的任务终止
 */
    List<Runnable> shutdownNow();
/**
 * 如果已经被shutdown，返回true
 */
    boolean isShutdown();
/**
 * 如果所有任务都已经被终止，返回true
 * 是否为终止状态
 */
    boolean isTerminated();
/**
 * 在一个shutdown请求后，阻塞的等待所有任务执行完毕
 * 或者到达超时时间，或者当前线程被中断
 */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;


可以生成用于追踪一个或多个异步任务执行结果的Future对象的 submit()相关方法：

/**
 * 提交一个可执行的任务，返回一个Future代表这个任务
 * 等到任务成功执行，Future#get()方法会返回null
 */
    <T> Future<T> submit(Callable<T> task);
/**
 * 提交一个可以执行的任务，返回一个Future代表这个任务
 * 等到任务执行结束，Future#get()方法会返回这个给定的result
 */
    <T> Future<T> submit(Runnable task, T result);
/**
 * 提交一个有返回值的任务，并返回一个Future代表等待的任务执行的结果
 * 等到任务成功执行，Future#get()方法会返回任务执行的结果
 */
    Future<?> submit(Runnable task);

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

   
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

AbstractExecutorService抽象类：
实现ExecutorService接口，并且提供了一些方法的默认实现，例如submit方法、invokeAny方法、invokeAll方法。像execute方法、线程池的关闭方法（shutdown、shutdownNow等等）就没有提供默认的实现。

public abstract class AbstractExecutorService implements ExecutorService {

    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }

    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                              boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {...}

    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)
        throws InterruptedException, ExecutionException, TimeoutException {...}

    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)
        throws InterruptedException {...}

}

 线程池的主要实现执行都具体在ThreadPoolExecutor这个类的方法中，请点击https://blog.csdn.net/nn1__2970/article/details/89952576 转至下一篇查看*-*。