接口 java.lang.Runnable
的使用

使用 Runnable 的软件包

java.lang	提供利用 Java 编程语言进行程序设计的基础类。
java.util	包含集合框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。
java.util.concurrent	在并发编程中很常用的实用工具类。

java.lang 中 Runnable 的使用

实现 Runnable 的 java.lang 中的类

class

Thread 线程 是程序中的执行线程。

参数类型为 Runnable 的 java.lang 中的构造方法

Thread(Runnable target)
分配新的 Thread 对象。

Thread(Runnable target, String name)
分配新的 Thread 对象。

Thread(ThreadGroup group, Runnable target)
分配新的 Thread 对象。

Thread(ThreadGroup group, Runnable target, String name)
分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，并作为 group 所引用的线程组的一员。

Thread(ThreadGroup group, Runnable target, String name, long stackSize)
分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，作为 group 所引用的线程组的一员，并具有指定的堆栈尺寸。

java.util 中 Runnable 的使用

实现 Runnable 的 java.util 中的类

class

TimerTask 由 Timer 安排为一次执行或重复执行的任务。

java.util.concurrent 中 Runnable 的使用

实现 Runnable 的 java.util.concurrent 中的类

class

FutureTask<V> 可取消的异步计算。

返回变量类型为 Runnable 的类型的 java.util.concurrent 中的方法

BlockingQueue<Runnable>	ThreadPoolExecutor.getQueue() 返回此执行程序使用的任务队列。
BlockingQueue<Runnable>	ScheduledThreadPoolExecutor.getQueue() 返回此执行程序使用的任务队列。
List<Runnable>	ThreadPoolExecutor.shutdownNow() 尝试停止所有的活动执行任务、暂停等待任务的处理，并返回等待执行的任务列表。
List<Runnable>	ScheduledThreadPoolExecutor.shutdownNow() 尝试停止所有正在执行的任务、暂停等待任务的处理，并返回等待执行的任务列表。
List<Runnable>	ExecutorService.shutdownNow() 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。

参数类型为 Runnable 的 java.util.concurrent 中的方法

protected void	ThreadPoolExecutor.afterExecute(Runnable r, Throwable t) 基于完成执行给定 Runnable 所调用的方法。
protected void	ThreadPoolExecutor.beforeExecute(Thread t, Runnable r) 在执行给定线程中的给定 Runnable 之前调用的方法。
static Callable<Object>	Executors.callable(Runnable task) 返回 Callable 对象，调用它时可运行给定的任务并返回 null。
static <T> Callable<T>	Executors.callable(Runnable task, T result) 返回 Callable 对象，调用它时可运行给定的任务并返回给定的结果。
void	ThreadPoolExecutor.execute(Runnable command) 在将来某个时间执行给定任务。
void	ScheduledThreadPoolExecutor.execute(Runnable command) 使用所要求的零延迟执行命令。
void	Executor.execute(Runnable command) 在未来某个时间执行给定的命令。
Thread	ThreadFactory.newThread(Runnable r) 构造一个新 Thread。
void	ThreadPoolExecutor.CallerRunsPolicy.rejectedExecution(Runnable r, ThreadPoolExecutor e) 调用方线程中的执行任务 r；如果执行程序已关闭，则会丢弃该任务。
void	ThreadPoolExecutor.AbortPolicy.rejectedExecution(Runnable r, ThreadPoolExecutor e) 总是抛出 RejectedExecutionException。
void	ThreadPoolExecutor.DiscardPolicy.rejectedExecution(Runnable r, ThreadPoolExecutor e) 不执行任何操作，在这种情况下将放弃任务 r。
void	ThreadPoolExecutor.DiscardOldestPolicy.rejectedExecution(Runnable r, ThreadPoolExecutor e) 获取并忽略下一个任务，否则如果该任务立即可用，执行程序将执行该任务，然后再试图重新执行任务 r；如果执行程序已关闭，则会丢弃任务 r。
void	RejectedExecutionHandler.rejectedExecution(Runnable r, ThreadPoolExecutor executor) 当 execute 不能接受某个任务时，可以由 ThreadPoolExecutor 调用的方法。
boolean	ThreadPoolExecutor.remove(Runnable task) 从执行程序的内部队列中移除此任务（如果出现），这样如果尚未开始，则其不再运行。
boolean	ScheduledThreadPoolExecutor.remove(Runnable task)
ScheduledFuture<?>	ScheduledThreadPoolExecutor.schedule(Runnable command, long delay, TimeUnit unit)
ScheduledFuture<?>	ScheduledExecutorService.schedule(Runnable command, long delay, TimeUnit unit) 创建并执行在给定延迟后启用的一次性操作。
ScheduledFuture<?>	ScheduledThreadPoolExecutor.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
ScheduledFuture<?>	ScheduledExecutorService.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
ScheduledFuture<?>	ScheduledThreadPoolExecutor.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
ScheduledFuture<?>	ScheduledExecutorService.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
Future<?>	ScheduledThreadPoolExecutor.submit(Runnable task)
Future<?>	ExecutorService.submit(Runnable task) 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
Future<?>	AbstractExecutorService.submit(Runnable task)
<T> Future<T>	ScheduledThreadPoolExecutor.submit(Runnable task, T result)
<T> Future<T>	ExecutorService.submit(Runnable task, T result) 提交一个 Runnable 任务用于执行，并返回一个 Future，该 Future 表示任务一旦完成后即返回给定的结果。
<T> Future<T>	AbstractExecutorService.submit(Runnable task, T result)
Future<V>	ExecutorCompletionService.submit(Runnable task, V result)
Future<V>	CompletionService.submit(Runnable task, V result) 提交要执行的 Runnable 任务，并返回一个表示任务完成的 Future，可以提取或轮询此任务。

参数类型为 Runnable 的 java.util.concurrent 中的构造方法

CyclicBarrier(int parties, Runnable barrierAction)
创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。

FutureTask(Runnable runnable, V result)
创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。

类型变量类型为 Runnable 的 java.util.concurrent 中的构造方法参数

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)
用给定的初始参数创建新的 ThreadPoolExecutor。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)
用给定的初始参数创建新的 ThreadPoolExecutor。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
用给定的初始参数创建新的 ThreadPoolExecutor。