`

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();
}

 

分享到:
评论

相关推荐

    java核心知识点整理.pdf

    25 JAVA8 与元数据.................................................................................................................................25 2.4. 垃圾回收与算法 .................................

    Java 面试宝典

    1、一个".java"源文件中是否可以包括多个类(不是内部类)?有什么限制? ...... 7 2、Java 有没有 goto? .......................................................................................................

    JAVA核心知识点整理(有效)

    25 JAVA8 与元数据.................................................................................................................................25 2.4. 垃圾回收与算法 .................................

    java concurrency programming in practice

    14.6.AQSinJava.util.concurrentSynchronizerClasses 192 Summary 194 Chapter 15. Atomic Variables and Non-blocking Synchronization 195 15.1.DisadvantagesofLocking 195 15.2.HardwareSupportforConcurrency ...

    java面试题

    14. 简述synchronized和java.util.concurrent.locks.Lock的异同 ? 11 15. 当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 11 16. abstract class和interface有什么区别? 12...

    JAVA面试题最全集

    简述synchronized和java.util.concurrent.locks.Lock的异同 ? 34.EJB规范规定EJB中禁止的操作有哪些? 35.java除了8种基本类型外,在虚拟机里还有哪一种,有什么作用? 36.除了使用new关键字创建对象意外,试列举...

    java基础题 很全面

    50. 简述synchronized和java.util.concurrent.locks.Lock的异同 ? 13 51. 排序都有哪几种方法?请列举。用JAVA实现一个快速排序。 13 52. JAVA语言如何进行异常处理,关键字:throws,throw,try,catch,finally分别代表...

    java面试宝典2012版.pdf

    54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 55、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。 56、子线程循环10次,接着主线程循环100,接着又回到子线程...

    java 面试题 总结

    java.lang.String类是final类型的,因此不可以继承这个类、不能修改这个类。为了提高效率节省空间,我们应该用StringBuffer类 3、int 和 Integer 有什么区别 Java 提供两种不同的类型:引用类型和原始类型(或内置...

    Java面试宝典-经典

    54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 34 55、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。 36 56、子线程循环10次,接着主线程循环100,接着又回到...

    java面试题大全(2012版)

    54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 34 55、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。 36 56、子线程循环10次,接着主线程循环100,接着又回到...

    最新Java面试宝典pdf版

    54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 34 55、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。 36 56、子线程循环10次,接着主线程循环100,接着又回到...

    Java面试笔试资料大全

    54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 34 55、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。 36 56、子线程循环10次,接着主线程循环100,接着又回到...

    java面试宝典2012

    54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 38 55、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。 40 56、子线程循环10次,接着主线程循环100,接着又回到...

    JAVA面试宝典2010

    54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 34 55、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。 36 56、子线程循环10次,接着主线程循环100,接着又回到...

Global site tag (gtag.js) - Google Analytics