Concurrent 六

 

十三、FutureTask 未来任务
一共有下面几个公有和保护方法:
1.public FutureTask(Callable<V> callable) 构造函数
callable和runnable接口很相似.callable使用call()方法,call()方法有返回结果.runnable使用run()方法.
2.public FutureTask(Runnable runnable,V result) 构造函数
可以传入一个作为计算结果的引用.
3.public boolean cancel(boolean mayInterruptIfRunning)
取消此未来任务,参数如果填写true则不管线程是否正在执行都要打断它.
4.public V get() throws InterruptedException,ExecutionException
取回计算结果.
5.public V get(long timeout,
             TimeUnit unit)
      throws InterruptedException,
             ExecutionException,
             TimeoutException
在设定的时间内取回计算结果.
6.protected void done()
结束任务,和cance()方法很相似,大多时候请考虑使用cance.
7.protected void set(V v)
给传入的结果重新赋值.
8.protected void setException(Throwable t)
给任务设置一个异常,如果它出现该异常的话就抛出来.
9.public void run()
运行该线程.
10.protected boolean runAndReset()
运行该任务,结束之后将结果重置,这个protected方法用在多次执行的任务中.

 

十四、ExecutorCompletionService 执行者计算服务群
一共有下面几个公有和保护方法:
1.ExecutorCompletionService(Executor executor)
给一个执行者来创建一个计算服务群,使用task来做计算线程,使用LinkedBlockingQueue来做计算队列.
2.ExecutorCompletionService(Executor executor, BlockingQueue<Future<V>> completionQueue)
给一个执行者来创建一个计算服务群,使用task来做计算线程,使用给定的堵塞队列来做计算队列.
3.public Future<V> poll()
取回一个计算任务,同时从计算服务群里面将它删除.
4.public Future<V> poll(long timeout,
                      TimeUnit unit)
               throws InterruptedException
在等待的时间之内取回一个计算任务,同时从计算服务群里面将它删除.
5.public Future<V> submit(Callable<V> task)
递交一个计算任务.
6.public Future<V> submit(Runnable task,
                        V result)
递交一个计算任务,传入一个对计算结果的引用.
7.public Future<V> take()
               throws InterruptedException
取回一个计算任务,如果当前服务群里面没有任务,则等待任务出现.

十五、abstract class AbstractExecutorService 计算服务群
有下面一些公有和保护方法:
1.public <T> List<Future<T>> invokeAll(Collection<Callable<T>> tasks)
                          throws InterruptedException
运行任务容器里面的所有任务,结束之后返回一个具有状态的未来任务队列.
2.public <T> List<Future<T>> invokeAll(Collection<Callable<T>> tasks,
                                     long timeout,
                                     TimeUnit unit)
                          throws InterruptedException
在有限的时间内运行任务容器里面的所有任务,结束之后返回一个具有状态的未来任务队列.
3.public <T> T invokeAny(Collection<Callable<T>> tasks)
            throws InterruptedException,
                   ExecutionException
运行任务容器里面的所有有返回结果的任务,结束之后返回最先结束的具有状态的未来任务.
4.public <T> T invokeAny(Collection<Callable<T>> tasks,
                       long timeout,
                       TimeUnit unit)
            throws InterruptedException,
                   ExecutionException,
                   TimeoutException
在有限的时间内运行任务容器里面的所有有返回结果的任务,结束之后返回最先结束的具有状态的未来任务.
5.public <T> Future<T> submit(Callable<T> task)
递交一个有返回结果的计算任务,返回一个未来任务.
6.public Future<?> submit(Runnable task)
递交一个计算任务,返回一个未来任务.
7.public <T> Future<T> submit(Runnable task,
                            T result)
递交一个计算任务,返回一个未来任务,传入一个对计算结果的引用.

十六、public class Executors 一个 Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable 类的生产工厂和管理工具
一共有下面一些公有和保护方法:
1.public static Callable<Object> callable(PrivilegedAction action)
创建一个Callable线程类,当这些类的call()方法被调用时,执行action,并返回计算结果.
2.public static Callable<Object> callable(PrivilegedExceptionAction action)
创建一个Callable线程类,当这些类的call()方法被调用时,抛出该异常,并返回计算结果.
3.public static Callable<Object> callable(Runnable task)
创建一个Callable线程类,当call()方法被调用时,运行task.
4.public static <T> Callable<T> callable(Runnable task,
                                       T result)
创建一个Callable线程类,当call()方法被调用时,运行task,并返回计算结果result.
5.public static ThreadFactory defaultThreadFactory()
创建一个缺省的线程工厂类.
6.public static ExecutorService newCachedThreadPool()
创建一个线程池.
7.public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
为threadFactory里面的线程群创建线程池.
8.public static ExecutorService newFixedThreadPool(int nThreads)
创建一个定义大小的线程池.
9.public static ExecutorService newFixedThreadPool(int nThreads,
                                                 ThreadFactory threadFactory)
为threadFactory里面的线程创建一个定义大小的线程池.
10.public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个定义大小的具有时间安排的线程池.
11.public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize,                                                              ThreadFactory threadFactory)
为threadFactory里面的线程创建一个定义大小的时间安排的线程池.
12.public static ExecutorService newSingleThreadExecutor()
创建一个只有一个计算任务的Executor.
13.public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)
创建一个只有一个计算任务的Executor,如果需要的话使用threadFactory的线程来创建多个任务.

public class ThreadPoolExecutor extends AbstractExecutorService

public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService