51、java.util.concurrent 包及其常用类

一、软件包 java.util.concurrent 

 

• 在并发编程中很常用的实用工具类。

二、java.util.concurrent.Executors

/**
 * Executors
 * 此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
 * 全是静态方法
 */
public class Executors
{
	//返回用于创建新线程的默认线程工厂。此工厂创建同一 ThreadGroup 中 Executor 使用的所有新线程。
	public static ThreadFactory defaultThreadFactory(){}

	/**
	 * 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。
	 * 对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。
	 * 调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。
	 * 终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
	 * 因此，长时间保持空闲的线程池不会使用任何资源
	 */
	public static ExecutorService newCachedThreadPool(){}

	//创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
	public static ExecutorService newFixedThreadPool(int nThreads){}

	//创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
	public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize){}

	/**
	 * 创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
	 * （注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。
	 */
	public static ExecutorService newSingleThreadExecutor(){}

	//创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行
	public static ScheduledExecutorService newSingleThreadScheduledExecutor(){}
}

 

三、java.util.concurrent.ThreadFactory

/**
 * ThreadFactory
 * 根据需要创建新线程的对象。使用线程工厂就无需再手工编写对 new Thread 的调用了，从而允许应用程序使用特殊的线程子类、属性等等。 
 */
public interface ThreadFactory
{
	//构造一个新 Thread。实现也可能初始化属性、名称、守护程序状态、ThreadGroup 等等
	Thread newThread(Runnable r);
}

 

四、java.util.concurrent.Executor

 /**
 * Executor
 * 执行已提交的 Runnable 任务的对象
 * 此接口提供一种将任务提交与每个任务将如何运行的机制（包括线程使用的细节、调度等）分离开来的方法。
 * 通常使用 Executor 而不是显式地创建线程。
 * 此包中提供的 Executor 实现实现了 ExecutorService，这是一个使用更广泛的接口。
 * ThreadPoolExecutor 类提供一个可扩展的线程池实现。
 * Executors 类为这些 Executor 提供了便捷的工厂方法。
 */
public interface Executor
{
	//在未来某个时间执行给定的命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。
	void execute(Runnable command);
}

 

五、java.util.concurrent.ExecutorService

/**
 * ExecutorService
 * 可以关闭 ExecutorService，这将导致其拒绝新任务。
 * 方法 invokeAny 和 invokeAll 是批量执行的最常用形式，它们执行任务 collection，然后等待至少一个，或全部任务完成
 */ 
public interface ExecutorService extends Executor
{
	/**
	 * 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表
	 * 如果正在进行此操作时修改了给定的 collection，则此方法的结果是不确定的。 
	 */
	<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
                          throws InterruptedException;

	//执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表
	<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                              long timeout,
                              TimeUnit unit)
                          throws InterruptedException;

	/**
	 * 执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果。
	 * 一旦正常或异常返回后，则取消尚未完成的任务。
	 * 如果此操作正在进行时修改了给定的 collection，则此方法的结果是不确定的。
	 */
	<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;

	//启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
	void shutdown();

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

	//提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。该 Future 的 get 方法在成功完成时将会返回该任务的结果。
	<T> Future<T> submit(Callable<T> task);

	//提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。该 Future 的 get 方法在成功完成时将会返回给定的结果。
	<T> Future<T> submit(Runnable task,
                     T result);

	//提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。该 Future 的 get 方法在成功 完成时将会返回 null。
	Future<?> submit(Runnable task);
}

 

六、java.util.concurrent.Callable<V>

/**
 * Callable<V>
 * 返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法
 * Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
 * Executors 类包含一些从其他普通形式转换成 Callable 类的实用方法。
 */
public interface Callable<V>
{
	//计算结果，如果无法计算结果，则抛出一个异常
	V call()
       throws Exception;
}

 

七、java.util.concurrent.Future<V>

/**
 * Future<V>
 * V - 此 Future 的 get 方法所返回的结果类型
 * Future 表示异步计算的结果。
 * 它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。
 * 计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。
 * 取消则由 cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。
 * 如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。 
 */
public interface Future<V>
{
	/**
	 * 试图取消对此任务的执行。如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败。
	 * 当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。
	 * 如果任务已经启动，则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程。 
	 * mayInterruptIfRunning - 如果应该中断执行此任务的线程，则为 true；否则允许正在运行的任务运行完成 
	 */
	boolean cancel(boolean mayInterruptIfRunning);

	//如有必要，等待计算完成，然后获取其结果
	V get()
      throws InterruptedException,
             ExecutionException;

	V get(long timeout,
      TimeUnit unit)
      throws InterruptedException,
             ExecutionException,
             TimeoutException;

	//如果在任务正常完成前将其取消，则返回 true。 
	boolean isCancelled();

	//如果任务已完成，则返回 true。 可能由于正常终止、异常或取消而完成，在所有这些情况中，此方法都将返回 true
	boolean isDone();
}