接口 java.lang.Runnable 的使用 (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

java.awt 中 Runnable 的使用

 

参数类型为 Runnable 的 java.awt 中的方法
static void	EventQueue.invokeAndWait(Runnable runnable)           导致 runnable 的 run 方法在 EventQueue 的指派线程上被调用。
static void	EventQueue.invokeLater(Runnable runnable)           导致 runnable 的 run 方法在 EventQueue 的指派线程上被调用。

 

java.awt.event 中 Runnable 的使用

 

声明为 Runnable 的 java.awt.event 中的字段
protected  Runnable	InvocationEvent.runnable           调用其 run() 方法的 Runnable。

 

参数类型为 Runnable 的 java.awt.event 中的构造方法
InvocationEvent(Object source, int id, Runnable runnable, Object notifier, boolean catchThrowables)           构造一个具有指定源和 ID 的 InvocationEvent，此源和 ID 将在被指派时执行 runnable 的 run 方法。
InvocationEvent(Object source, Runnable runnable)           构造一个具有指定源的 InvocationEvent，此源将在被指派时执行 runnable 的 run 方法。
InvocationEvent(Object source, Runnable runnable, Object notifier, boolean catchThrowables)           构造一个具有指定源的 InvocationEvent，此源将在被指派时执行 runnable 的 run 方法。

 

java.awt.image.renderable 中 Runnable 的使用

 

实现 Runnable 的 java.awt.image.renderable 中的类
class	RenderableImageProducer           实现 ImageProducer 以允许异步生成 RenderableImage 的适配器类。

 

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。

 

javax.net.ssl 中 Runnable 的使用

 

返回 Runnable 的 javax.net.ssl 中的方法
abstract  Runnable	SSLEngine.getDelegatedTask()           返回此 SSLEngine 的一个委托 Runnable 任务。

 

javax.swing 中 Runnable 的使用

 

参数类型为 Runnable 的 javax.swing 中的方法
static void	SwingUtilities.invokeAndWait(Runnable doRun)           导致 doRun.run() 在 AWT 事件指派线程上同步执行。
static void	SwingUtilities.invokeLater(Runnable doRun)           导致 doRun.run() 在 AWT 事件指派线程上异步执行。

 

javax.swing.text 中 Runnable 的使用

 

实现 Runnable 的 javax.swing.text 中的类
class	AsyncBoxView.ChildState           表示子视图布局状态的记录。

 

返回 Runnable 的 javax.swing.text 中的方法
protected  Runnable	LayoutQueue.waitForWork()           由 worker 线程使用以获取一个要执行的新任务

 

参数类型为 Runnable 的 javax.swing.text 中的方法
void	LayoutQueue.addTask(Runnable task)           添加一个任务，该任务不必立即执行，原因是其结果可能是不可见的。
void	Document.render(Runnable r)           如果模型支持异步更新，则允许在并发情况下安全呈现模型。
void	AbstractDocument.render(Runnable r)           如果模型支持被异步更新，则此方法允许在并发情况下安全地呈现该模型。

 

版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。