接口的使用
java.lang.Runnable

使用 Runnable 的包

包	描述
java.awt	包含用于创建用户界面以及绘制图形和图像的所有类。
java.awt.event	提供用于处理 AWT 组件触发的不同类型事件的接口和类。
java.awt.image.renderable	提供用于生成与渲染无关的图像的类和接口。
java.lang	提供对 Java 编程语言的设计至关重要的类。
java.lang.foreign	提供对 Java 运行时之外的内存和函数的低级访问。
java.lang.ref	提供引用对象类，支持与垃圾收集器进行有限程度的交互。
java.util	包含集合框架、一些国际化支持类、服务加载器、属性、随机数生成、字符串解析和扫描类、base64 编码和解码、位数组和几个杂项实用程序类。
java.util.concurrent	通常在并发编程中有用的实用程序类。
java.util.logging	提供 Java 2 平台的核心日志记录工具的类和接口。
java.util.stream	支持对元素流进行函数式操作的类，例如对集合的 map-reduce 转换。
javax.net.ssl	为安全套接字包提供类。
javax.swing	提供一组“轻量级”（全 Java 语言）组件，尽可能在所有平台上以相同的方式工作。
javax.swing.text	提供处理可编辑和不可编辑文本组件的类和接口。
jdk.incubator.concurrent	为并发编程定义非最终 API。
jdk.jfr	这个包提供类来创建事件和控制飞行记录器。
jdk.jfr.consumer	此包包含用于使用 Flight Recorder 数据的类。
jdk.management.jfr	此包包含通过 Java 管理扩展 (JMX) 控制和监视 Flight Recorder 的类。

Runnable 在 java.awt 中的用法

java.awt 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
static void	EventQueue.invokeAndWait(Runnable runnable)	导致 runnable 在 the system EventQueue 的 dispatch thread 中调用其 run 方法。
static void	EventQueue.invokeLater(Runnable runnable)	导致 runnable 在 the system EventQueue 的 dispatch thread 中调用其 run 方法。

Runnable 在 java.awt.event 中的用法

java.awt.event 中的字段声明为 Runnable

修饰符和类型	Field	描述
protected Runnable	InvocationEvent.runnable	将调用其 run() 方法的 Runnable。

java.awt.event 中的构造函数，参数类型为 Runnable

修饰符	构造方法	描述
protected	InvocationEvent(Object source, int id, Runnable runnable, Object notifier, boolean catchThrowables)	构造一个具有指定源和 ID 的 InvocationEvent，它将在调度时执行 runnable 的 run() 方法。
	InvocationEvent(Object source, Runnable runnable)	构造一个具有指定源的 InvocationEvent，它将在分派时执行 runnable 的 run() 方法。
	InvocationEvent(Object source, Runnable runnable, Object notifier, boolean catchThrowables)	构造一个具有指定源的 InvocationEvent，它将在分派时执行 runnable 的 run() 方法。
	InvocationEvent(Object source, Runnable runnable, Runnable listener, boolean catchThrowables)	构造一个具有指定源的 InvocationEvent，它将在分派时执行 runnable 的 run() 方法。

Runnable 在 java.awt.image.renderable 中的用法

java.awt.image.renderable 中实现 Runnable 的类

修饰符和类型	类	描述
class	RenderableImageProducer	实现 ImageProducer 以允许异步生成 RenderableImage 的适配器类。

Runnable 在 java.lang 中的用法

java.lang 中实现 Runnable 的类

修饰符和类型	类	描述
class	Thread	A 线是程序中的执行线程。

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

修饰符和类型	方法	描述
Thread	Thread.Builder.start(Runnable task)	从构建器的当前状态创建一个新的 Thread 并安排它执行。
static Thread	Thread.startVirtualThread(Runnable task)	预览。 创建一个虚拟线程来执行任务并安排它执行。
Thread	Thread.Builder.unstarted(Runnable task)	从构建器的当前状态创建一个新的 Thread 来运行给定的任务。

java.lang 中的构造函数，参数类型为 Runnable

修饰符	构造方法	描述
	Thread(Runnable task)	初始化新平台 Thread 。
	Thread(Runnable task, String name)	初始化新平台 Thread 。
	Thread(ThreadGroup group, Runnable task)	初始化新平台 Thread 。
	Thread(ThreadGroup group, Runnable task, String name)	初始化新平台 Thread，使其运行对象为 task，名称为指定的 name，并且属于 group 引用的线程组。
	Thread(ThreadGroup group, Runnable task, String name, long stackSize)	初始化一个新的平台 Thread，使其具有 task 作为其运行对象，具有指定的 name 作为其名称，并且属于 group 引用的线程组，并且具有指定的堆栈大小.
	Thread(ThreadGroup group, Runnable task, String name, long stackSize, boolean inheritInheritableThreadLocals)	初始化一个新平台 Thread，使其具有 task 作为其运行对象，具有指定的 name 作为其名称，属于 group 引用的线程组，具有指定的 stackSize，并且如果 inheritThreadLocals 为 true，则继承 可继承线程本地 变量的初始值。

Runnable 在 java.lang.foreign 中的用法

java.lang.foreign 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
static MemorySegmentPREVIEW	MemorySegment.ofAddress(long address, long byteSize, SegmentScopePREVIEW scope, Runnable cleanupAction)	创建具有给定大小、地址和范围的本机段。
void	SegmentScope.whileAlive(Runnable action)	在此作用域保持活动状态时运行关键操作。

Runnable 在 java.lang.ref 中的用法

java.lang.ref 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
Cleaner.Cleanable	Cleaner.register(Object obj, Runnable action)	注册一个对象和一个清理操作，以便在对象变为幻象可达时运行。

Runnable 在 java.util 中的用法

java.util 中实现 Runnable 的类

修饰符和类型	类	描述
class	TimerTask	一项可以由 Timer 安排一次性或重复执行的任务。

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

修饰符和类型	方法	描述
void	Optional.ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)	如果存在值，则使用该值执行给定的操作，否则执行给定的基于空的操作。
void	OptionalDouble.ifPresentOrElse(DoubleConsumer action, Runnable emptyAction)	如果存在值，则使用该值执行给定的操作，否则执行给定的基于空的操作。
void	OptionalInt.ifPresentOrElse(IntConsumer action, Runnable emptyAction)	如果存在值，则使用该值执行给定的操作，否则执行给定的基于空的操作。
void	OptionalLong.ifPresentOrElse(LongConsumer action, Runnable emptyAction)	如果存在值，则使用该值执行给定的操作，否则执行给定的基于空的操作。

Runnable 在 java.util.concurrent 中的用法

java.util.concurrent 中 Runnable 的子接口

修饰符和类型	接口	描述
interface	RunnableFuture<V>	一个 Future 即 Runnable 。
interface	RunnableScheduledFuture<V>	一个 ScheduledFuture 即 Runnable 。

java.util.concurrent 中实现 Runnable 的类

修饰符和类型	类	描述
class	ForkJoinWorkerThread	由 ForkJoinPool 管理的线程，它执行 ForkJoinTask s。
class	FutureTask<V>	可取消的异步计算。

返回类型中包含 Runnable 类型参数的 java.util.concurrent 中的方法

修饰符和类型	方法	描述
BlockingQueue<Runnable>	ScheduledThreadPoolExecutor.getQueue()	返回此执行程序使用的任务队列。
BlockingQueue<Runnable>	ThreadPoolExecutor.getQueue()	返回此执行程序使用的任务队列。
List<Runnable>	ExecutorService.shutdownNow()	尝试停止所有正在执行的任务，停止等待任务的处理，并返回等待执行的任务列表。
List<Runnable>	ForkJoinPool.shutdownNow()	可能会尝试取消和/或停止所有任务，并拒绝所有随后提交的任务。
List<Runnable>	ScheduledThreadPoolExecutor.shutdownNow()	尝试停止所有正在执行的任务，停止等待任务的处理，并返回等待执行的任务列表。
List<Runnable>	ThreadPoolExecutor.shutdownNow()	尝试停止所有正在执行的任务，停止等待任务的处理，并返回等待执行的任务列表。

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

修饰符和类型	方法	描述
static ForkJoinTask<?>	ForkJoinTask.adapt(Runnable runnable)	返回一个新的 ForkJoinTask，它执行给定 Runnable 的 run 方法作为其操作，并在 ForkJoinTask.join() 上返回空结果。
static <T> ForkJoinTask<T>	ForkJoinTask.adapt(Runnable runnable, T result)	返回一个新的 ForkJoinTask，它执行给定 Runnable 的 run 方法作为其操作，并在 ForkJoinTask.join() 上返回给定结果。
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)	修改或替换用于执行可运行对象的任务。
void	Executor.execute(Runnable command)	在将来的某个时间执行给定的命令。
void	ForkJoinPool.execute(Runnable task)
void	ScheduledThreadPoolExecutor.execute(Runnable command)	执行 command 所需的延迟为零。
void	ThreadPoolExecutor.execute(Runnable command)	在将来的某个时间执行给定的任务。
protected <T> RunnableFuture<T>	AbstractExecutorService.newTaskFor(Runnable runnable, T value)	为给定的可运行和默认值返回一个 RunnableFuture。
Thread	ThreadFactory.newThread(Runnable r)	构造一个新的未启动的 Thread 来运行给定的 runnable。
void	RejectedExecutionHandler.rejectedExecution(Runnable r, ThreadPoolExecutor executor)	当 execute 无法接受任务时，ThreadPoolExecutor 可能调用的方法。
void	ThreadPoolExecutor.AbortPolicy.rejectedExecution(Runnable r, ThreadPoolExecutor e)	总是抛出 RejectedExecutionException。
void	ThreadPoolExecutor.CallerRunsPolicy.rejectedExecution(Runnable r, ThreadPoolExecutor e)	在调用者的线程中执行任务 r，除非执行者已关闭，在这种情况下任务将被丢弃。
void	ThreadPoolExecutor.DiscardOldestPolicy.rejectedExecution(Runnable r, ThreadPoolExecutor e)	获取并忽略执行器将执行的下一个任务（如果任务立即可用），然后重试执行任务 r，除非执行器关闭，在这种情况下任务 r 将被丢弃。
void	ThreadPoolExecutor.DiscardPolicy.rejectedExecution(Runnable r, ThreadPoolExecutor e)	什么都不做，这具有丢弃任务 r 的效果。
boolean	ThreadPoolExecutor.remove(Runnable task)	如果此任务存在，则从执行程序的内部队列中删除此任务，从而使其在尚未启动时不运行。
CompletableFuture<Void>	CompletableFuture.runAfterBoth(CompletionStage<?> other, Runnable action)
CompletionStage<Void>	CompletionStage.runAfterBoth(CompletionStage<?> other, Runnable action)	返回一个新的 CompletionStage，当这个阶段和另一个给定阶段都正常完成时，执行给定的操作。
CompletableFuture<Void>	CompletableFuture.runAfterBothAsync(CompletionStage<?> other, Runnable action)
CompletableFuture<Void>	CompletableFuture.runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor)
CompletionStage<Void>	CompletionStage.runAfterBothAsync(CompletionStage<?> other, Runnable action)	返回一个新的 CompletionStage，当这个和另一个给定阶段都正常完成时，使用这个阶段的默认异步执行工具执行给定的操作。
CompletionStage<Void>	CompletionStage.runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor)	返回一个新的 CompletionStage，当这个阶段和另一个给定阶段都正常完成时，使用提供的执行程序执行给定的操作。
CompletableFuture<Void>	CompletableFuture.runAfterEither(CompletionStage<?> other, Runnable action)
CompletionStage<Void>	CompletionStage.runAfterEither(CompletionStage<?> other, Runnable action)	返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，它会执行给定的操作。
CompletableFuture<Void>	CompletableFuture.runAfterEitherAsync(CompletionStage<?> other, Runnable action)
CompletableFuture<Void>	CompletableFuture.runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor)
CompletionStage<Void>	CompletionStage.runAfterEitherAsync(CompletionStage<?> other, Runnable action)	返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，使用这个阶段的默认异步执行工具执行给定的操作。
CompletionStage<Void>	CompletionStage.runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor)	返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，使用提供的执行程序执行给定的操作。
static CompletableFuture<Void>	CompletableFuture.runAsync(Runnable runnable)	返回一个新的 CompletableFuture，它在运行给定操作后由 ForkJoinPool.commonPool() 中运行的任务异步完成。
static CompletableFuture<Void>	CompletableFuture.runAsync(Runnable runnable, Executor executor)	返回一个新的 CompletableFuture，它在运行给定操作后由在给定执行器中运行的任务异步完成。
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)	提交一个周期性动作，该动作在给定的初始延迟后首先启用，然后在给定的周期内启用；也就是说，执行将在 initialDelay 之后开始，然后是 initialDelay + period ，然后是 initialDelay + 2 * period ，依此类推。
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)
<T> Future<T>	AbstractExecutorService.submit(Runnable task, T result)
Future<V>	CompletionService.submit(Runnable task, V result)	提交一个 Runnable 任务以供执行并返回一个代表该任务的 Future。
Future<V>	ExecutorCompletionService.submit(Runnable task, V result)
Future<?>	ExecutorService.submit(Runnable task)	提交一个 Runnable 任务以供执行并返回一个代表该任务的 Future。
<T> Future<T>	ExecutorService.submit(Runnable task, T result)	提交一个 Runnable 任务以供执行并返回一个代表该任务的 Future。
ForkJoinTask<?>	ForkJoinPool.submit(Runnable task)
<T> ForkJoinTask<T>	ForkJoinPool.submit(Runnable task, T result)
Future<?>	ScheduledThreadPoolExecutor.submit(Runnable task)
<T> Future<T>	ScheduledThreadPoolExecutor.submit(Runnable task, T result)
CompletableFuture<Void>	CompletableFuture.thenRun(Runnable action)
CompletionStage<Void>	CompletionStage.thenRun(Runnable action)	返回一个新的 CompletionStage，当这个阶段正常完成时，它会执行给定的操作。
CompletableFuture<Void>	CompletableFuture.thenRunAsync(Runnable action)
CompletableFuture<Void>	CompletableFuture.thenRunAsync(Runnable action, Executor executor)
CompletionStage<Void>	CompletionStage.thenRunAsync(Runnable action)	返回一个新的 CompletionStage，当此阶段正常完成时，使用此阶段的默认异步执行工具执行给定的操作。
CompletionStage<Void>	CompletionStage.thenRunAsync(Runnable action, Executor executor)	返回一个新的 CompletionStage，当这个阶段正常完成时，使用提供的执行器执行给定的操作。

java.util.concurrent 中的构造函数，参数类型为 Runnable

修饰符	构造方法	描述
	CyclicBarrier(int parties, Runnable barrierAction)	创建一个新的 CyclicBarrier，当给定数量的参与方（线程）等待它时，它将触发，并在触发障碍时执行给定的障碍操作，由进入障碍的最后一个线程执行。
	FutureTask(Runnable runnable, V result)	创建一个 FutureTask，它将在运行时执行给定的 Runnable，并安排 get 在成功完成时返回给定的结果。

java.util.concurrent 中的构造函数参数，类型参数为 Runnable

修饰符	构造方法	描述
	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。

Runnable 在 java.util.logging 中的用法

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

修饰符和类型	方法	描述
LogManager	LogManager.addConfigurationListener(Runnable listener)	添加一个配置监听，每次读取日志配置时都会调用它。
void	LogManager.removeConfigurationListener(Runnable listener)	删除以前注册的配置监听。

Runnable 在 java.util.stream 中的用法

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

修饰符和类型	方法	描述
S	BaseStream.onClose(Runnable closeHandler)	返回带有附加关闭处理程序的等效流。

Runnable 在 javax.net.ssl 中的用法

javax.net.ssl 中返回 Runnable 的方法

修饰符和类型	方法	描述
abstract Runnable	SSLEngine.getDelegatedTask()	返回此 SSLEngine 的委托 Runnable 任务。

Runnable 在 javax.swing 中的用法

javax.swing 中实现 Runnable 的类

修饰符和类型	类	描述
class	SwingWorker<T,V>	一个抽象类，用于在后台线程中执行冗长的 GUI 交互任务。

javax.swing 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
static void	SwingUtilities.invokeAndWait(Runnable doRun)	导致 doRun.run() 在 AWT 事件调度线程上同步执行。
static void	SwingUtilities.invokeLater(Runnable doRun)	成因doRun.run()在 AWT 事件调度线程上异步执行。

Runnable 在 javax.swing.text 中的用法

javax.swing.text 中实现 Runnable 的类

修饰符和类型	类	描述
class	AsyncBoxView.ChildState	表示子视图布局状态的记录。

javax.swing.text 中返回 Runnable 的方法

修饰符和类型	方法	描述
protected Runnable	LayoutQueue.waitForWork()	由工作线程用来获取要执行的新任务。

javax.swing.text 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
void	LayoutQueue.addTask(Runnable task)	添加一项不需要立即执行的任务，因为认为结果不可见。
void	AbstractDocument.render(Runnable r)	如果模型支持异步更新，这允许在存在货币的情况下安全地呈现模型。
void	Document.render(Runnable r)	如果模型支持异步更新，则允许模型在并发情况下安全呈现。

Runnable 在 jdk.incubator.concurrent 中的用法

jdk.incubator.concurrent 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
void	ScopedValue.Carrier.run(Runnable op)	运行一个操作，此map中的每个作用域值都绑定到它在当前线程中的值。
static <T> void	ScopedValue.where(ScopedValue<T> key, T value, Runnable op)	使用绑定到当前线程中的值的 ScopedValue 运行操作。

Runnable 在 jdk.jfr 中的用法

jdk.jfr 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
static void	FlightRecorder.addPeriodicEvent(Class<? extends Event> eventClass, Runnable hook)	为周期性事件添加一个挂钩。
static boolean	FlightRecorder.removePeriodicEvent(Runnable hook)	删除周期性事件的挂钩。

Runnable 在 jdk.jfr.consumer 中的用法

jdk.jfr.consumer 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
void	EventStream.onClose(Runnable action)	注册在流关闭时要执行的操作。
void	RecordingStream.onClose(Runnable action)
void	EventStream.onFlush(Runnable action)	注册在流被刷新后执行的操作。
void	RecordingStream.onFlush(Runnable action)

Runnable 在 jdk.management.jfr 中的用法

jdk.management.jfr 中的方法，参数类型为 Runnable

修饰符和类型	方法	描述
void	RemoteRecordingStream.onClose(Runnable action)
void	RemoteRecordingStream.onFlush(Runnable action)