Java多线程-线程池架构

一）线程池架构图

Java多线程中线程池架构图如下：

 

二）Executor

Executor是一个接口，接口中只有一个execute()方法。

package java.util.concurrent;

public interface Executor {
    void execute(Runnable command);
}

Executor接口提供execute()方法来执行提交的Runnable任务对象。

Executor接口主要目的是提供一种将“任务提交”和“任务运行”分离开的机制，包括线程使用，调度等的Executor。

 

三）ExecutorService

ExecutorService是一个接口，继承了Executor接口，提供了一些管理Executor的方法。

package java.util.concurrent;
import java.util.List;
import java.util.Collection;

public interface ExecutorService extends Executor {

    // 启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
    void shutdown();

    // 尝试停止所有主动执行的任务，停止等待任务的处理，并返回正在等待执行的任务列表。
    List<Runnable> shutdownNow();

    // 如果此执行者已关闭，则返回 true。
    boolean isShutdown();

    // 如果所有任务在关闭后完成，则返回 true。 
    boolean isTerminated();

    // 阻止所有任务在关闭请求完成后执行，或发生超时，或当前线程中断，以先到者为准。
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    // 提交值返回任务以执行，并返回代表任务待处理结果的Future。
    <T> Future<T> submit(Callable<T> task);

    // 提交一个可运行的任务执行，并返回一个表示该任务的未来。
    <T> Future<T> submit(Runnable task, T result);

    // 提交一个可运行的任务执行，并返回一个表示该任务的未来。
    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

AbstractExecutorService是一个抽象类，提供ExecutorService执行方法的默认实现。

该类实现submit，invokeAny和invokeAll等方法，并使用RunnableFuture接口返回newTaskFor，其默认实现为FutureTask类中提供。

 

五）ThreadPoolExecutor

ThreadPoolExecutor是线程池具体实现类，继承了AbstractExecutorService抽象类。

该类提供了四种线程池创建方式。

// 第一种：创建一个新的ThreadPoolExecutor与给定的初始参数和默认线程工厂和拒绝执行处理程序。
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
}

// 第二种：创建一个新的ThreadPoolExecutor与给定的初始参数和默认拒绝执行处理程序。 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
}

// 第三种：创建一个新的 ThreadPoolExecutor与给定的初始参数和默认线程工厂。
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
}

// 第四种：创建一个新 ThreadPoolExecutor给定的初始参数。最终都是调用该方法。
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
             null :
             AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

 

该类提供了四种线程池拒绝策略。

1）ThreadPoolExecutor.AbortPolicy：当任务添加到线程池中被拒绝时，它将抛出 RejectedExecutionException异常。

2）ThreadPoolExecutor.CallerRunsPolicy：当任务添加到线程池中被拒绝时，会在线程池当前正在运行的Thread线程池中处理被拒绝的任务。

3）ThreadPoolExecutor.DiscardOldestPolicy：当任务添加到线程池中被拒绝时，线程池会放弃等待队列中最旧的未处理任务，然后将被拒绝的任务添加到等待队列中。

4）ThreadPoolExecutor.DiscardPolicy：当任务添加到线程池中被拒绝时，线程池将丢弃被拒绝的任务。

 

六）ScheduledExecutorService

ScheduledExecutorService是一个接口，继承了ExecutorService。它相当于提供了“延迟”或“定期执行”ExecutorService。

ScheduledExecutorService提供了一些函数方法来实现“延迟”或“定期执行”功能。

 

七）ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor实现了ScheduledExecutorService接口的相关函数方法，并继承了ThreadPoolExecutor类。

ScheduledThreadPoolExecutor提供了具体实现“延迟”或“定期执行”功能代码。相当于一个定时器。

 

八）Executors

Executors是一个静态工厂类，类中都是static的函数方法。它通过静态工厂方法返回ExecutorService、ScheduledExecutorService、ThreadFactory和Callable等类的对象。

一般情况，不需要通过ThreadPoolExecutor类中提供的四种线程创建方式来创建线程，可通过该类的静态方法创建。

 

1）newCachedThreadPool()：创建一个线程池，如果线程池中的线程数量过大，它可以有效的回收多余的线程，如果线程数不足，那么它可以创建新的线程。相当于一个缓存线程池。

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}

 

2）newFixedThreadPool()：创建一个固定大小的线程池，如果线程超过固定大小，会进入阻塞状态，是一个阻塞线程池。该方式1秒钟最多支持1000个线程同时运行。

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

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

 

3）newScheduledThreadPool()：该线程池支持定时，以及周期性的任务执行，我们可以延迟任务的执行时间，也可以设置一个周期性的时间让任务重复执行。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public static ScheduledExecutorService newScheduledThreadPool(
        int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}

 

4）newSingleThreadExecutor()：该方式会创建一个固定大小为1的单线程，是一个单线程池，只会有一个线程运行，其它线程都会进入阻塞状态，等待线程池的释放和调用。

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}

 

识别二维码关注个人微信公众号

本章完结，待续，欢迎转载！
 
本文说明：该文章属于原创，如需转载，请标明文章转载来源！