一）线程池
架构
图
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));
}
识别二维码关注个人微信公众号
本章完结，待续，欢迎转载！
本文说明：该文章属于原创，如需转载，请标明文章转载来源！