Java多线程系列--“JUC线程池”01之 线程池架构

 

概要

前面分别介绍了"Java多线程基础"、"JUC原子类"和"JUC锁"。本章介绍JUC的最后一部分的内容——线程池。内容包括：
线程池架构图
线程池示例

转载请注明出处：http://www.cnblogs.com/skywang12345/p/3509903.html

 

线程池架构图

线程池的架构图以下：

 

 

1. Executor

它是"执行者"接口，它是来执行任务的。准确的说，Executor提供了execute()接口来执行已提交的 Runnable 任务的对象。Executor存在的目的是提供一种将"任务提交"与"任务如何运行"分离开来的机制。
它只包含一个函数接口：

void execute(Runnable command)

 

2. ExecutorService

ExecutorService继承于Executor。它是"执行者服务"接口，它是为"执行者接口Executor"服务而存在的；准确的话，ExecutorService提供了"将任务提交给执行者的接口(submit方法)"，"让执行者执行任务(invokeAll, invokeAny方法)"的接口等等。

ExecutorService的函数列表

 1 // 请求关闭、发生超时或者当前线程中断，不管哪个首先发生以后，都将致使阻塞，直到全部任务完成执行。
 2 boolean awaitTermination(long timeout, TimeUnit unit)
 3 // 执行给定的任务，当全部任务完成时，返回保持任务状态和结果的 Future 列表。
 4 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
 5 // 执行给定的任务，当全部任务完成或超时期满时（不管哪一个首先发生），返回保持任务状态和结果的 Future 列表。
 6 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
 7 // 执行给定的任务，若是某个任务已成功完成（也就是未抛出异常），则返回其结果。
 8 <T> T invokeAny(Collection<? extends Callable<T>> tasks)
 9 // 执行给定的任务，若是在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。
10 <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
11 // 若是此执行程序已关闭，则返回 true。
12 boolean isShutdown()
13 // 若是关闭后全部任务都已完成，则返回 true。
14 boolean isTerminated()
15 // 启动一次顺序关闭，执行之前提交的任务，但不接受新任务。
16 void shutdown()
17 // 试图中止全部正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
18 List<Runnable> shutdownNow()
19 // 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。
20 <T> Future<T> submit(Callable<T> task)
21 // 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
22 Future<?> submit(Runnable task)
23 // 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
24 <T> Future<T> submit(Runnable task, T result)

View Code

 

3. AbstractExecutorService

AbstractExecutorService是一个抽象类，它实现了ExecutorService接口。
AbstractExecutorService存在的目的是为ExecutorService中的函数接口提供了默认实现。

AbstractExecutorService函数列表
因为它的函数列表和ExecutorService同样，这里就再也不重复列举了。

 

4. ThreadPoolExecutor

ThreadPoolExecutor就是大名鼎鼎的"线程池"。它继承于AbstractExecutorService抽象类。

ThreadPoolExecutor函数列表

 1 // 用给定的初始参数和默认的线程工厂及被拒绝的执行处理程序建立新的 ThreadPoolExecutor。
 2 ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
 3 // 用给定的初始参数和默认的线程工厂建立新的 ThreadPoolExecutor。
 4 ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)
 5 // 用给定的初始参数和默认被拒绝的执行处理程序建立新的 ThreadPoolExecutor。
 6 ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)
 7 // 用给定的初始参数建立新的 ThreadPoolExecutor。
 8 ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
 9 
10 // 基于完成执行给定 Runnable 所调用的方法。
11 protected void afterExecute(Runnable r, Throwable t)
12 // 若是在保持活动时间内没有任务到达，新任务到达时正在替换（若是须要），则设置控制核心线程是超时仍是终止的策略。
13 void allowCoreThreadTimeOut(boolean value)
14 // 若是此池容许核心线程超时和终止，若是在 keepAlive 时间内没有任务到达，新任务到达时正在替换（若是须要），则返回 true。
15 boolean allowsCoreThreadTimeOut()
16 // 请求关闭、发生超时或者当前线程中断，不管哪个首先发生以后，都将致使阻塞，直到全部任务完成执行。
17 boolean awaitTermination(long timeout, TimeUnit unit)
18 // 在执行给定线程中的给定 Runnable 以前调用的方法。
19 protected void beforeExecute(Thread t, Runnable r)
20 // 在未来某个时间执行给定任务。
21 void execute(Runnable command)
22 // 当再也不引用此执行程序时，调用 shutdown。
23 protected void finalize()
24 // 返回主动执行任务的近似线程数。
25 int getActiveCount()
26 // 返回已完成执行的近似任务总数。
27 long getCompletedTaskCount()
28 // 返回核心线程数。
29 int getCorePoolSize()
30 // 返回线程保持活动的时间，该时间就是超过核心池大小的线程能够在终止前保持空闲的时间值。
31 long getKeepAliveTime(TimeUnit unit)
32 // 返回曾经同时位于池中的最大线程数。
33 int getLargestPoolSize()
34 // 返回容许的最大线程数。
35 int getMaximumPoolSize()
36 // 返回池中的当前线程数。
37 int getPoolSize()
38 // 返回此执行程序使用的任务队列。
39 BlockingQueue<Runnable> getQueue()
40 // 返回用于未执行任务的当前处理程序。
41 RejectedExecutionHandler getRejectedExecutionHandler()
42 // 返回曾计划执行的近似任务总数。
43 long getTaskCount()
44 // 返回用于建立新线程的线程工厂。
45 ThreadFactory getThreadFactory()
46 // 若是此执行程序已关闭，则返回 true。
47 boolean isShutdown()
48 // 若是关闭后全部任务都已完成，则返回 true。
49 boolean isTerminated()
50 // 若是此执行程序处于在 shutdown 或 shutdownNow 以后正在终止但还没有彻底终止的过程当中，则返回 true。
51 boolean isTerminating()
52 // 启动全部核心线程，使其处于等待工做的空闲状态。
53 int prestartAllCoreThreads()
54 // 启动核心线程，使其处于等待工做的空闲状态。
55 boolean prestartCoreThread()
56 // 尝试从工做队列移除全部已取消的 Future 任务。
57 void purge()
58 // 从执行程序的内部队列中移除此任务（若是存在），从而若是还没有开始，则其再也不运行。
59 boolean remove(Runnable task)
60 // 设置核心线程数。
61 void setCorePoolSize(int corePoolSize)
62 // 设置线程在终止前能够保持空闲的时间限制。
63 void setKeepAliveTime(long time, TimeUnit unit)
64 // 设置容许的最大线程数。
65 void setMaximumPoolSize(int maximumPoolSize)
66 // 设置用于未执行任务的新处理程序。
67 void setRejectedExecutionHandler(RejectedExecutionHandler handler)
68 // 设置用于建立新线程的线程工厂。
69 void setThreadFactory(ThreadFactory threadFactory)
70 // 按过去执行已提交任务的顺序发起一个有序的关闭，可是不接受新任务。
71 void shutdown()
72 // 尝试中止全部的活动执行任务、暂停等待任务的处理，并返回等待执行的任务列表。
73 List<Runnable> shutdownNow()
74 // 当 Executor 已经终止时调用的方法。
75 protected void terminated()

View Code

 

5. ScheduledExecutorService

ScheduledExecutorService是一个接口，它继承于于ExecutorService。它至关于提供了"延时"和"周期执行"功能的ExecutorService。
ScheduledExecutorService提供了相应的函数接口，能够安排任务在给定的延迟后执行，也可让任务周期的执行。

ScheduledExecutorService函数列表

1 // 建立并执行在给定延迟后启用的 ScheduledFuture。
2 <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
3 // 建立并执行在给定延迟后启用的一次性操做。
4 ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
5 // 建立并执行一个在给定初始延迟后首次启用的按期操做，后续操做具备给定的周期；也就是将在 initialDelay 后开始执行，而后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
6 ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
7 // 建立并执行一个在给定初始延迟后首次启用的按期操做，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
8 ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

View Code

 

6. ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor继承于ThreadPoolExecutor，而且实现了ScheduledExecutorService接口。它至关于提供了"延时"和"周期执行"功能的ScheduledExecutorService。
ScheduledThreadPoolExecutor相似于Timer，可是在高并发程序中，ScheduledThreadPoolExecutor的性能要优于Timer。

ScheduledThreadPoolExecutor函数列表

 1 // 使用给定核心池大小建立一个新 ScheduledThreadPoolExecutor。
 2 ScheduledThreadPoolExecutor(int corePoolSize)
 3 // 使用给定初始参数建立一个新 ScheduledThreadPoolExecutor。
 4 ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)
 5 // 使用给定的初始参数建立一个新 ScheduledThreadPoolExecutor。
 6 ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)
 7 // 使用给定初始参数建立一个新 ScheduledThreadPoolExecutor。
 8 ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler)
 9 
10 // 修改或替换用于执行 callable 的任务。
11 protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task)
12 // 修改或替换用于执行 runnable 的任务。
13 protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, RunnableScheduledFuture<V> task)
14 // 使用所要求的零延迟执行命令。
15 void execute(Runnable command)
16 // 获取有关在此执行程序已 shutdown 的状况下、是否继续执行现有按期任务的策略。
17 boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()
18 // 获取有关在此执行程序已 shutdown 的状况下是否继续执行现有延迟任务的策略。
19 boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()
20 // 返回此执行程序使用的任务队列。
21 BlockingQueue<Runnable> getQueue()
22 // 从执行程序的内部队列中移除此任务（若是存在），从而若是还没有开始，则其再也不运行。
23 boolean remove(Runnable task)
24 // 建立并执行在给定延迟后启用的 ScheduledFuture。
25 <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
26 // 建立并执行在给定延迟后启用的一次性操做。
27 ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
28 // 建立并执行一个在给定初始延迟后首次启用的按期操做，后续操做具备给定的周期；也就是将在 initialDelay 后开始执行，而后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
29 ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
30 // 建立并执行一个在给定初始延迟后首次启用的按期操做，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
31 ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
32 // 设置有关在此执行程序已 shutdown 的状况下是否继续执行现有按期任务的策略。
33 void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)
34 // 设置有关在此执行程序已 shutdown 的状况下是否继续执行现有延迟任务的策略。
35 void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
36 // 在之前已提交任务的执行中发起一个有序的关闭，可是不接受新任务。
37 void shutdown()
38 // 尝试中止全部正在执行的任务、暂停等待任务的处理，并返回等待执行的任务列表。
39 List<Runnable> shutdownNow()
40 // 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。
41 <T> Future<T> submit(Callable<T> task)
42 // 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
43 Future<?> submit(Runnable task)
44 // 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
45 <T> Future<T> submit(Runnable task, T result)

View Code

 

7. Executors

Executors是个静态工厂类。它经过静态工厂方法返回ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 等类的对象。

Executors函数列表

 1 // 返回 Callable 对象，调用它时可运行给定特权的操做并返回其结果。
 2 static Callable<Object> callable(PrivilegedAction<?> action)
 3 // 返回 Callable 对象，调用它时可运行给定特权的异常操做并返回其结果。
 4 static Callable<Object> callable(PrivilegedExceptionAction<?> action)
 5 // 返回 Callable 对象，调用它时可运行给定的任务并返回 null。
 6 static Callable<Object> callable(Runnable task)
 7 // 返回 Callable 对象，调用它时可运行给定的任务并返回给定的结果。
 8 static <T> Callable<T> callable(Runnable task, T result)
 9 // 返回用于建立新线程的默认线程工厂。
10 static ThreadFactory defaultThreadFactory()
11 // 建立一个可根据须要建立新线程的线程池，可是在之前构造的线程可用时将重用它们。
12 static ExecutorService newCachedThreadPool()
13 // 建立一个可根据须要建立新线程的线程池，可是在之前构造的线程可用时将重用它们，并在须要时使用提供的 ThreadFactory 建立新线程。
14 static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
15 // 建立一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
16 static ExecutorService newFixedThreadPool(int nThreads)
17 // 建立一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，在须要时使用提供的 ThreadFactory 建立新线程。
18 static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
19 // 建立一个线程池，它可安排在给定延迟后运行命令或者按期地执行。
20 static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
21 // 建立一个线程池，它可安排在给定延迟后运行命令或者按期地执行。
22 static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
23 // 建立一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
24 static ExecutorService newSingleThreadExecutor()
25 // 建立一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程，并在须要时使用提供的 ThreadFactory 建立新线程。
26 static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)
27 // 建立一个单线程执行程序，它可安排在给定延迟后运行命令或者按期地执行。
28 static ScheduledExecutorService newSingleThreadScheduledExecutor()
29 // 建立一个单线程执行程序，它可安排在给定延迟后运行命令或者按期地执行。
30 static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
31 // 返回 Callable 对象，调用它时可在当前的访问控制上下文中执行给定的 callable 对象。
32 static <T> Callable<T> privilegedCallable(Callable<T> callable)
33 // 返回 Callable 对象，调用它时可在当前的访问控制上下文中，使用当前上下文类加载器做为上下文类加载器来执行给定的 callable 对象。
34 static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable)
35 // 返回用于建立新线程的线程工厂，这些新线程与当前线程具备相同的权限。
36 static ThreadFactory privilegedThreadFactory()
37 // 返回一个将全部已定义的 ExecutorService 方法委托给指定执行程序的对象，可是使用强制转换可能没法访问其余方法。
38 static ExecutorService unconfigurableExecutorService(ExecutorService executor)
39 // 返回一个将全部已定义的 ExecutorService 方法委托给指定执行程序的对象，可是使用强制转换可能没法访问其余方法。
40 static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor)

View Code

 

线程池示例

下面经过示例来对线程池的使用作简单演示。

 1 import java.util.concurrent.Executors;
 2 import java.util.concurrent.ExecutorService;
 3 
 4 public class ThreadPoolDemo1 {
 5 
 6     public static void main(String[] args) {
 7         // 建立一个可重用固定线程数的线程池
 8         ExecutorService pool = Executors.newFixedThreadPool(2);
 9         // 建立实现了Runnable接口对象，Thread对象固然也实现了Runnable接口
10         Thread ta = new MyThread();
11         Thread tb = new MyThread();
12         Thread tc = new MyThread();
13         Thread td = new MyThread();
14         Thread te = new MyThread();
15         // 将线程放入池中进行执行
16         pool.execute(ta);
17         pool.execute(tb);
18         pool.execute(tc);
19         pool.execute(td);
20         pool.execute(te);
21         // 关闭线程池
22         pool.shutdown();
23     }
24 }
25 
26 class MyThread extends Thread {
27 
28     @Override
29     public void run() {
30         System.out.println(Thread.currentThread().getName()+ " is running.");
31     }
32 }

运行结果：

pool-1-thread-1 is running.
pool-1-thread-2 is running.
pool-1-thread-1 is running.
pool-1-thread-2 is running.
pool-1-thread-1 is running.

结果说明：
主线程中建立了线程池pool，线程池的容量是2。即，线程池中最多能同时运行2个线程。
紧接着，将ta,tb,tc,td,te这3个线程添加到线程池中运行。
最后，经过shutdown()关闭线程池。

 

---

更多内容

1. Java多线程系列目录(共xx篇)