Interface ExecutorService
-
All Superinterfaces:
All Known Subinterfaces:
所有已知实现类：
AbstractExecutorService，ForkJoinPool，ScheduledThreadPoolExecutor，ThreadPoolExecutorpublic interface ExecutorServiceextends Executor
Executor ，提供管理终止的方法和可生成Future以跟踪一个或多个异步任务进度的方法。
可以关闭ExecutorService ，这将导致它拒绝新任务。 关闭ExecutorService提供了两种不同的方法。 shutdown()方法将允许先前提交的任务在终止之前执行，而shutdownNow()方法可防止等待任务启动并尝试停止当前正在执行的任务。 终止时，执行程序没有正在执行的任务，没有等待执行的任务，也没有任何新任务可以提交。 应关闭未使用的ExecutorService以允许回收其资源。
方法submit延伸的基方法Executor.execute(Runnable)通过创建并返回一个Future ，可用于取消执行和/或等待完成。 方法invokeAny和invokeAll执行最常用的批量执行形式，执行一组任务，然后等待至少一个或全部完成。 （ ExecutorCompletionService类可用于编写这些方法的自定义变体。）
Executors类为此包中提供的执行程序服务提供工厂方法。
用法示例
下面是网络服务的草图，其中线程池中的线程为传入请求提供服务。 它使用预先配置的Executors.newFixedThreadPool(int)工厂方法：
class NetworkService implements Runnable { private final ServerSocket serverSocket; private final ExecutorService pool; public NetworkService(int port, int poolSize) throws IOException { serverSocket = new ServerSocket(port); pool = Executors.newFixedThreadPool(poolSize); } public void run() { // run the service try { for (;;) { pool.execute(new Handler(serverSocket.accept())); } } catch (IOException ex) { pool.shutdown(); } } } class Handler implements Runnable { private final Socket socket; Handler(Socket socket) { this.socket = socket; } public void run() { // read and service request on socket } }
以下方法ExecutorService两个阶段关闭ExecutorService ，首先调用shutdown拒绝传入任务，然后根据需要调用shutdownNow以取消任何延迟任务：
void shutdownAndAwaitTermination(ExecutorService pool) { pool.shutdown(); // Disable new tasks from being submitted try { // Wait a while for existing tasks to terminate if (!pool.awaitTermination(60, TimeUnit.SECONDS)) { pool.shutdownNow(); // Cancel currently executing tasks // Wait a while for tasks to respond to being cancelled if (!pool.awaitTermination(60, TimeUnit.SECONDS)) System.err.println("Pool did not terminate"); } } catch (InterruptedException ie) { // (Re-)Cancel if current thread also interrupted pool.shutdownNow(); // Preserve interrupt status Thread.currentThread().interrupt(); } }
内存一致性效果：在将Runnable或Callable任务提交到ExecutorService happen-before之前的一个线程中的操作，该任务采取的任何操作都会发生 - 在通过Future.get()检索结果之前 。
从以下版本开始：
1.5
变量和类型
方法
描述
boolean
awaitTermination(long timeout, TimeUnit unit)
阻止所有任务在关闭请求之后完成执行，或发生超时，或者当前线程被中断，以先发生者为准。
invokeAll(Collection<? extends Callable<T>> tasks)
执行给定的任务，返回完成所有状态和结果的Futures列表。
invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
执行给定的任务，返回一个Futures列表，在完成或超时到期时保持其状态和结果，以先发生者为准。
<T> T
invokeAny(Collection<? extends Callable<T>> tasks)
执行给定的任务，返回已成功完成的任务的结果（即，不抛出异常），如果有的话。
<T> T
invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
执行给定的任务，返回已成功完成的任务的结果（即，不抛出异常），如果在给定的超时之前已经执行了任何操作。
boolean
如果此执行程序已关闭，则返回 true 。
boolean
如果关闭后所有任务都已完成，则返回 true 。
void
shutdown()
启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
尝试停止所有正在执行的任务，停止等待任务的处理，并返回等待执行的任务列表。
Future<?>
提交Runnable任务以执行并返回表示该任务的Future。
<T> Future<T>
提交Runnable任务以执行并返回表示该任务的Future。
<T> Future<T>
提交值返回任务以执行并返回表示任务的挂起结果的Future。
Class Executors（线程池创建工厂类）
java.lang.Objectjava.util.concurrent.Executors
-
public class Executorsextends Object
工厂和工具方法Executor ， ExecutorService ， ScheduledExecutorService ， ThreadFactory ，和Callable此包中定义的类。 该类支持以下几种方法：
-
使用常用配置设置创建和返回ExecutorService设置的方法。
-
创建和返回ScheduledExecutorService设置的方法，使用常用的配置设置。
-
创建并返回“包装”ExecutorService的方法，通过使特定于实现的方法不可访问来禁用重新配置。
-
创建并返回将新创建的线程设置为已知状态的ThreadFactory的方法。
-
创建并返回一个方法Callable出来的其他闭包形式，这样他们就可以在需要的执行方法使用Callable 。
从以下版本开始：
1.5
变量和类型
方法
描述
返回一个Callable对象，该对象在调用时运行给定任务并返回null 。
static <T> Callable<T>
返回一个Callable对象，该对象在调用时运行给定任务并返回给定结果。
callable(PrivilegedAction<?> action)
返回一个Callable对象，该对象在调用时运行给定的特权操作并返回其结果。
callable(PrivilegedExceptionAction<?> action)
返回一个Callable对象，该对象在调用时运行给定的特权异常操作并返回其结果。
static ThreadFactory
返回用于创建新线程的默认线程工厂。
static ExecutorService
创建一个根据需要创建新线程的线程池，但在它们可用时将重用以前构造的线程。
static ExecutorService
newCachedThreadPool(ThreadFactory threadFactory)
创建一个根据需要创建新线程的线程池，但在它们可用时将重用以前构造的线程，并在需要时使用提供的ThreadFactory创建新线程。
static ExecutorService
newFixedThreadPool(int nThreads)
创建一个线程池，该池重用在共享的无界队列中运行的固定数量的线程。
static ExecutorService
newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
创建一个线程池，该线程池重用在共享的无界队列中运行的固定数量的线程，使用提供的ThreadFactory在需要时创建新线程。
static ScheduledExecutorService
newScheduledThreadPool(int corePoolSize)
创建一个线程池，可以调度命令在给定的延迟后运行，或者定期执行。
static ScheduledExecutorService
newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
创建一个线程池，可以调度命令在给定的延迟后运行，或者定期执行。
static ExecutorService
创建一个Executor，它使用一个在无界队列中运行的工作线程。
static ExecutorService
newSingleThreadExecutor(ThreadFactory threadFactory)
创建一个Executor，它使用一个在无界队列中运行的工作线程，并在需要时使用提供的ThreadFactory创建一个新线程。
static ScheduledExecutorService
创建一个单线程执行程序，可以调度命令在给定的延迟后运行，或定期执行。
static ScheduledExecutorService
newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
创建一个单线程执行程序，可以调度命令在给定的延迟后运行，或定期执行。
static ExecutorService
使用 available processors的数量作为其目标并行度级别创建工作窃取线程池。
static ExecutorService
newWorkStealingPool(int parallelism)
创建一个线程池，该线程池维护足够的线程以支持给定的并行度级别，并可以使用多个队列来减少争用。
static <T> Callable<T>
privilegedCallable(Callable<T> callable)
返回一个Callable对象，在调用时，将在当前访问控制上下文下执行给定的callable 。
static <T> Callable<T>
privilegedCallableUsingCurrentClassLoader(Callable<T> callable)
返回一个Callable对象，当调用该对象时，将在当前访问控制上下文下执行给定的callable ，并将当前上下文类加载器作为上下文类加载器。
static ThreadFactory
返回一个线程工厂，用于创建与当前线程具有相同权限的新线程。
static ExecutorService
unconfigurableExecutorService(ExecutorService executor)
返回一个对象，该对象将所有已定义的ExecutorService方法委派给给定的执行程序，但不能使用强制转换可以访问的任何其他方法。
static ScheduledExecutorService
unconfigurableScheduledExecutorService(ScheduledExecutorService executor)
返回一个对象，该对象将所有已定义的ScheduledExecutorService方法委托给给定的执行程序，但不能使用强制转换可以访问的任何其他方法。
-
方法摘要
-
示例：
| import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @author Administrator *线程池 *线程池的创建方式： 1. newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 2. newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 3. newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。 4. newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。 *线程池执行： - execute(Runnable) 方法接收一个Runnable实例，并且异步的执行 - submit(Runnable) 方法接收一个Runnable实例，并且异步的执行，并返回的Future对象 get()【阻塞】方法获取返回结果 - submit(Callable) 方法submit(Callable)和submit(Runnable)类似，也会返回一个Future对象，但是除此之外，submit(Callable)接收的是一个Callable的实现，Callable接口中的call()方法有一个返回值，可以返回任务的执行结果，而Runnable接口中的run()方法是void的，没有返回值 - invokeAny(...) - invokeAll(...) */ public class Demo6 { static int count = 0; public static void main(String[] args) { /// ExecutorService threadPool = Executors.newCachedThreadPool(); for (int i = 0; i < 1000; i++) { threadPool.execute(new Runnable() { @Override public void run() { if("pool-1-thread-1".equals(Thread.currentThread().getName())) { count++; } // System.out.println(Thread.currentThread().getName()); } }); } //关闭线程池 threadPool.shutdown(); } } |
506
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
