JavaTM 2 Platform
Standard Ed. 6

接口 java.lang.Runnable
的使用

使用 Runnable 的软件包
java.awt 包含用于创建用户界面和绘制图形图像的所有类。 
java.awt.event 提供处理由 AWT 组件所激发的各类事件的接口和类。 
java.awt.image.renderable 提供用于生成与呈现无关的图像的类和接口。 
java.lang 提供利用 Java 编程语言进行程序设计的基础类。 
java.util 包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类(字符串标记生成器、随机数生成器和位数组)。 
java.util.concurrent 在并发编程中很常用的实用工具类。 
javax.net.ssl 提供用于安全套接字包的类。 
javax.swing 提供一组“轻量级”(全部是 Java 语言)组件,尽量让这些组件在所有平台上的工作方式都相同。 
javax.swing.text 提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。 
 

java.awtRunnable 的使用
 

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

java.awt.eventRunnable 的使用
 

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

参数类型为 Runnablejava.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.renderableRunnable 的使用
 

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

java.langRunnable 的使用
 

实现 Runnablejava.lang 中的类
 class Thread
          线程 是程序中的执行线程。
 

参数类型为 Runnablejava.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.utilRunnable 的使用
 

实现 Runnablejava.util 中的类
 class TimerTask
          由 Timer 安排为一次执行或重复执行的任务。
 

java.util.concurrentRunnable 的使用
 

java.util.concurrentRunnable 的子接口
 interface RunnableFuture<V>
          作为 RunnableFuture
 interface RunnableScheduledFuture<V>
          作为 RunnableScheduledFuture
 

实现 Runnablejava.util.concurrent 中的类
 class FutureTask<V>
          可取消的异步计算。
 

返回变量类型为 Runnable 的类型的 java.util.concurrent 中的方法
 BlockingQueue<Runnable> ScheduledThreadPoolExecutor.getQueue()
          返回此执行程序使用的任务队列。
 BlockingQueue<Runnable> ThreadPoolExecutor.getQueue()
          返回此执行程序使用的任务队列。
 List<Runnable> ExecutorService.shutdownNow()
          试图停止所有正在执行的活动任务,暂停处理正在等待的任务,并返回等待执行的任务列表。
 List<Runnable> ScheduledThreadPoolExecutor.shutdownNow()
          尝试停止所有正在执行的任务、暂停等待任务的处理,并返回等待执行的任务列表。
 List<Runnable> ThreadPoolExecutor.shutdownNow()
          尝试停止所有的活动执行任务、暂停等待任务的处理,并返回等待执行的任务列表。
 

参数类型为 Runnablejava.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 对象,调用它时可运行给定的任务并返回给定的结果。
protected
<V> RunnableScheduledFuture<V>
ScheduledThreadPoolExecutor.decorateTask(Runnable runnable, RunnableScheduledFuture<V> task)
          修改或替换用于执行 runnable 的任务。
 void Executor.execute(Runnable command)
          在未来某个时间执行给定的命令。
 void ScheduledThreadPoolExecutor.execute(Runnable command)
          使用所要求的零延迟执行命令。
 void ThreadPoolExecutor.execute(Runnable command)
          在将来某个时间执行给定任务。
protected
<T> RunnableFuture<T>
AbstractExecutorService.newTaskFor(Runnable runnable, T value)
          为给定可运行任务和默认值返回一个 RunnableFuture
 Thread ThreadFactory.newThread(Runnable r)
          构造一个新 Thread
 void RejectedExecutionHandler.rejectedExecution(Runnable r, ThreadPoolExecutor executor)
          当 execute 不能接受某个任务时,可以由 ThreadPoolExecutor 调用的方法。
 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。
 boolean ScheduledThreadPoolExecutor.remove(Runnable task)
           
 boolean ThreadPoolExecutor.remove(Runnable task)
          从执行程序的内部队列中移除此任务(如果存在),从而如果尚未开始,则其不再运行。
 ScheduledFuture<?> ScheduledExecutorService.schedule(Runnable command, long delay, TimeUnit unit)
          创建并执行在给定延迟后启用的一次性操作。
 ScheduledFuture<?> ScheduledThreadPoolExecutor.schedule(Runnable command, long delay, TimeUnit unit)
           
 ScheduledFuture<?> ScheduledExecutorService.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
          创建并执行一个在给定初始延迟后首次启用的定期操作,后续操作具有给定的周期;也就是将在 initialDelay 后开始执行,然后在 initialDelay+period 后执行,接着在 initialDelay + 2 * period 后执行,依此类推。
 ScheduledFuture<?> ScheduledThreadPoolExecutor.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
           
 ScheduledFuture<?> ScheduledExecutorService.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
          创建并执行一个在给定初始延迟后首次启用的定期操作,随后,在每一次执行终止和下一次执行开始之间都存在给定的延迟。
 ScheduledFuture<?> ScheduledThreadPoolExecutor.scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
           
 Future<?> AbstractExecutorService.submit(Runnable task)
           
 Future<?> ExecutorService.submit(Runnable task)
          提交一个 Runnable 任务用于执行,并返回一个表示该任务的 Future。
 Future<?> ScheduledThreadPoolExecutor.submit(Runnable task)
           
<T> Future<T>
AbstractExecutorService.submit(Runnable task, T result)
           
<T> Future<T>
ExecutorService.submit(Runnable task, T result)
          提交一个 Runnable 任务用于执行,并返回一个表示该任务的 Future。
<T> Future<T>
ScheduledThreadPoolExecutor.submit(Runnable task, T result)
           
 Future<V> CompletionService.submit(Runnable task, V result)
          提交要执行的 Runnable 任务,并返回一个表示任务完成的 Future,可以提取或轮询此任务。
 Future<V> ExecutorCompletionService.submit(Runnable task, V result)
           
 

参数类型为 Runnablejava.util.concurrent 中的构造方法
CyclicBarrier(int parties, Runnable barrierAction)
          创建一个新的 CyclicBarrier,它将在给定数量的参与者(线程)处于等待状态时启动,并在启动 barrier 时执行给定的屏障操作,该操作由最后一个进入 barrier 的线程执行。
FutureTask(Runnable runnable, V result)
          创建一个 FutureTask,一旦运行就执行给定的 Runnable,并安排成功完成时 get 返回给定的结果 。
 

类型变量类型为 Runnablejava.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.sslRunnable 的使用
 

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

javax.swingRunnable 的使用
 

实现 Runnablejavax.swing 中的类
 class SwingWorker<T,V>
          在专用线程中执行长时间 GUI 交互任务的抽象类。
 

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

javax.swing.textRunnable 的使用
 

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

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

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


JavaTM 2 Platform
Standard Ed. 6

提交错误或意见

版权所有 2008 Sun Microsystems, Inc. 保留所有权利。请遵守GNU General Public License, version 2 only