类的用途
java.lang.InterruptedException

使用 InterruptedException 的包

包	描述
com.sun.jdi.event	这个包定义了 JDI 事件和事件处理。
java.awt	包含用于创建用户界面以及绘制图形和图像的所有类。
java.awt.image	提供用于创建和修改图像的类。
java.lang	提供对 Java 编程语言的设计至关重要的类。
java.lang.ref	提供引用对象类，支持与垃圾收集器进行有限程度的交互。
java.net.http	HTTP 客户端和 WebSocket API
java.nio.channels	定义通道，它表示与能够执行 I/O 操作的实体的连接，例如文件和套接字；定义选择器，用于多路复用、非阻塞 I/O 操作。
java.nio.file	定义Java虚拟机访问文件、文件属性和文件系统的接口和类。
java.util.concurrent	通常在并发编程中有用的实用程序类。
java.util.concurrent.locks	接口和类提供了一个框架，用于锁定和等待不同于内置同步和监视器的条件。
javax.swing	提供一组“轻量级”（全 Java 语言）组件，尽可能在所有平台上以相同的方式工作。
jdk.incubator.concurrent	为并发编程定义非最终 API。
jdk.jfr.consumer	此包包含用于使用 Flight Recorder 数据的类。
jdk.management.jfr	此包包含通过 Java 管理扩展 (JMX) 控制和监视 Flight Recorder 的类。

InterruptedException 在 com.sun.jdi.event 中的用法

在 com.sun.jdi.event 中抛出 InterruptedException

修饰符和类型	方法	描述
EventSet	EventQueue.remove()	永远等待下一个可用事件。
EventSet	EventQueue.remove(long timeout)	等待下一个可用事件的指定时间。

InterruptedException 在 java.awt 中的用法

在 java.awt 中抛出 InterruptedException

修饰符和类型	方法	描述
AWTEvent	EventQueue.getNextEvent()	从 EventQueue 中删除一个事件并返回它。
static void	EventQueue.invokeAndWait(Runnable runnable)	导致 runnable 在 the system EventQueue 的 dispatch thread 中调用其 run 方法。
void	MediaTracker.waitForAll()	开始加载此媒体跟踪器跟踪的所有图像。
boolean	MediaTracker.waitForAll(long ms)	开始加载此媒体跟踪器跟踪的所有图像。
void	MediaTracker.waitForID(int id)	开始加载此媒体跟踪器跟踪的具有指定标识符的所有图像。
boolean	MediaTracker.waitForID(int id, long ms)	开始加载此媒体跟踪器跟踪的具有指定标识符的所有图像。

InterruptedException 在 java.awt.image 中的用法

在 java.awt.image 中抛出 InterruptedException

修饰符和类型	方法	描述
boolean	PixelGrabber.grabPixels()	请求 Image 或 ImageProducer 开始传送像素并等待传送感兴趣矩形中的所有像素。
boolean	PixelGrabber.grabPixels(long ms)	请求 Image 或 ImageProducer 开始传送像素并等待传送感兴趣的矩形中的所有像素或直到指定的超时已过。

InterruptedException 在 java.lang 中的用法

在 java.lang 中抛出 InterruptedException

修饰符和类型	方法	描述
final void	Thread.join()	等待此线程终止。
final void	Thread.join(long millis)	此线程终止最多等待 millis 毫秒。
final void	Thread.join(long millis, int nanos)	最多等待 millis 毫秒加上 nanos 纳秒，以便此线程终止。
final boolean	Thread.join(Duration duration)	等待此线程终止直至给定的等待持续时间。
static void	Thread.sleep(long millis)	使当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。
static void	Thread.sleep(long millis, int nanos)	使当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，这取决于系统计时器和调度程序的精度和准确性。
static void	Thread.sleep(Duration duration)	根据系统计时器和调度程序的精度和准确性，使当前正在执行的线程在指定的持续时间内休眠（暂时停止执行）。
final void	Object.wait()	导致当前线程等待直到被唤醒，通常是 notified 或 interrupted 。
final void	Object.wait(long timeoutMillis)	导致当前线程等待直到它被唤醒，通常是被 notified 或 interrupted 唤醒，或者直到经过一定的实时时间。
final void	Object.wait(long timeoutMillis, int nanos)	导致当前线程等待直到它被唤醒，通常是被 notified 或 interrupted 唤醒，或者直到经过一定的实时时间。
abstract int	Process.waitFor()	如有必要，使当前线程等待，直到此 Process 对象表示的进程终止。
boolean	Process.waitFor(long timeout, TimeUnit unit)	如有必要，使当前线程等待，直到此 Process 对象表示的进程终止，或指定的等待时间结束。

InterruptedException 在 java.lang.ref 中的用法

在 java.lang.ref 中抛出 InterruptedException

修饰符和类型	方法	描述
Reference<? extends T>	ReferenceQueue.remove()	移除此队列中的下一个引用对象，阻塞直到一个可用。
Reference<? extends T>	ReferenceQueue.remove(long timeout)	移除此队列中的下一个引用对象，阻塞直到一个可用或给定的超时期限到期。

InterruptedException 在 java.net.http 中的用法

在 java.net.http 中抛出 InterruptedException

修饰符和类型	方法	描述
abstract <T> HttpResponse<T>	HttpClient.send(HttpRequest request, HttpResponse.BodyHandler<T> responseBodyHandler)	使用此客户端发送给定请求，必要时阻塞以获得响应。

InterruptedException 在 java.nio.channels 中的用法

在 java.nio.channels 中抛出 InterruptedException

修饰符和类型	方法	描述
abstract boolean	AsynchronousChannelGroup.awaitTermination(long timeout, TimeUnit unit)	等待组的终止。

InterruptedException 在 java.nio.file 中的用法

在 java.nio.file 中抛出 InterruptedException

修饰符和类型	方法	描述
WatchKey	WatchService.poll(long timeout, TimeUnit unit)	检索并删除下一个监视键，如果还没有，则在必要时等待指定的等待时间。
WatchKey	WatchService.take()	检索并删除下一个监视密钥，如果尚不存在则等待。

InterruptedException 在 java.util.concurrent 中的用法

在 java.util.concurrent 中抛出 InterruptedException

修饰符和类型	方法	描述
void	Semaphore.acquire()	从此信号量获取许可，阻塞直到一个可用，或者线程为 interrupted 。
void	Semaphore.acquire(int permits)	从此信号量获取给定数量的许可，阻塞直到所有许可都可用，或者线程为 interrupted 。
void	CountDownLatch.await()	导致当前线程等待，直到锁存器倒计时到零，除非线程是 interrupted 。
boolean	CountDownLatch.await(long timeout, TimeUnit unit)	导致当前线程等待，直到锁存器倒计时为零，除非线程为 interrupted 或指定的等待时间已过。
int	CyclicBarrier.await()	等待所有 parties 在此屏障上调用 await。
int	CyclicBarrier.await(long timeout, TimeUnit unit)	等待直到所有 parties 在此屏障上调用 await，或者指定的等待时间结束。
int	Phaser.awaitAdvanceInterruptibly(int phase)	等待此移相器的相位从给定的相位值前进，如果在等待期间被中断则抛出InterruptedException，或者如果当前相位不等于给定的相位值或此移相器终止则立即返回。
int	Phaser.awaitAdvanceInterruptibly(int phase, long timeout, TimeUnit unit)	等待此移相器的相位从给定的相位值前进或给定的超时时间过去，如果在等待时被中断则抛出 InterruptedException，或者如果当前相位不等于给定的相位值或此移相器终止则立即返回。
boolean	ExecutorService.awaitTermination(long timeout, TimeUnit unit)	阻塞直到所有任务在关闭请求后完成执行，或者发生超时，或者当前线程被中断，以先发生者为准。
boolean	ForkJoinPool.awaitTermination(long timeout, TimeUnit unit)	阻塞直到所有任务在关闭请求后完成执行，或者发生超时，或者当前线程被中断，以先发生者为准。
boolean	ThreadPoolExecutor.awaitTermination(long timeout, TimeUnit unit)
boolean	ForkJoinPool.ManagedBlocker.block()	可能阻塞当前线程，例如等待锁或条件。
V	Exchanger.exchange(V x)	等待另一个线程到达这个交换点（除非当前线程是 interrupted ），然后将给定的对象传输给它，接收它的对象作为回报。
V	Exchanger.exchange(V x, long timeout, TimeUnit unit)	等待另一个线程到达此交换点（除非当前线程是 interrupted 或指定的等待时间已过），然后将给定的对象传输给它，接收它的对象作为回报。
T	CompletableFuture.get()	如有必要，等待此未来完成，然后返回其结果。
T	CompletableFuture.get(long timeout, TimeUnit unit)	如有必要，最多等待此未来完成的给定时间，然后返回其结果（如果可用）。
final V	ForkJoinTask.get()	如有必要，等待计算完成，然后检索其结果。
final V	ForkJoinTask.get(long timeout, TimeUnit unit)	如有必要，最多等待计算完成的给定时间，然后检索其结果（如果可用）。
V	Future.get()	如有必要，等待计算完成，然后检索其结果。
V	Future.get(long timeout, TimeUnit unit)	如有必要，最多等待计算完成的给定时间，然后检索其结果（如果可用）。
V	FutureTask.get()
V	FutureTask.get(long timeout, TimeUnit unit)
<T> List<Future<T>>	AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)
<T> List<Future<T>>	AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
<T> List<Future<T>>	ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)	执行给定的任务，在所有任务完成时返回一个 Futures 列表，其中包含它们的状态和结果。
<T> List<Future<T>>	ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)	执行给定的任务，返回一个 Futures 列表，当所有任务完成或超时到期时（以先发生者为准），保存它们的状态和结果。
<T> T	AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)
<T> T	AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
<T> T	ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)	执行给定的任务，返回成功完成的任务的结果（即，没有抛出异常），如果有的话。
<T> T	ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)	执行给定的任务，返回已成功完成的任务的结果（即，没有抛出异常），如果在给定的超时结束之前有任何执行的话。
static void	ForkJoinPool.managedBlock(ForkJoinPool.ManagedBlocker blocker)	运行给定的可能阻塞任务。
boolean	ArrayBlockingQueue.offer(E e, long timeout, TimeUnit unit)	将指定的元素插入此队列的尾部，如果队列已满，则等待指定的等待时间让空间变得可用。
boolean	BlockingDeque.offer(E e, long timeout, TimeUnit unit)	将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如有必要，等待指定的等待时间以使空间可用。
boolean	BlockingQueue.offer(E e, long timeout, TimeUnit unit)	将指定的元素插入此队列，如有必要，等待指定的等待时间以获得可用空间。
boolean	LinkedBlockingDeque.offer(E e, long timeout, TimeUnit unit)
boolean	LinkedBlockingQueue.offer(E e, long timeout, TimeUnit unit)	将指定的元素插入此队列的尾部，如有必要，等待指定的等待时间以等待空间变为可用。
boolean	SynchronousQueue.offer(E e, long timeout, TimeUnit unit)	将指定的元素插入此队列，如有必要，等待指定的等待时间以等待另一个线程接收它。
boolean	BlockingDeque.offerFirst(E e, long timeout, TimeUnit unit)	将指定的元素插入此双端队列的前面，如有必要，等待指定的等待时间以使空间可用。
boolean	LinkedBlockingDeque.offerFirst(E e, long timeout, TimeUnit unit)
boolean	BlockingDeque.offerLast(E e, long timeout, TimeUnit unit)	在此双端队列的末尾插入指定的元素，如有必要，等待指定的等待时间以使空间可用。
boolean	LinkedBlockingDeque.offerLast(E e, long timeout, TimeUnit unit)
E	ArrayBlockingQueue.poll(long timeout, TimeUnit unit)
E	BlockingDeque.poll(long timeout, TimeUnit unit)	检索并删除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素），如有必要，等待指定的等待时间以使元素可用。
E	BlockingQueue.poll(long timeout, TimeUnit unit)	检索并删除此队列的头部，如有必要，等待指定的等待时间以使元素可用。
Future<V>	CompletionService.poll(long timeout, TimeUnit unit)	检索并删除表示下一个已完成任务的 Future，必要时等待指定的等待时间（如果尚不存在）。
E	DelayQueue.poll(long timeout, TimeUnit unit)	检索并移除此队列的头部，如有必要，等待直到此队列上有一个具有过期延迟的元素可用，或者指定的等待时间到期。
Future<V>	ExecutorCompletionService.poll(long timeout, TimeUnit unit)
E	LinkedBlockingDeque.poll(long timeout, TimeUnit unit)
E	LinkedBlockingQueue.poll(long timeout, TimeUnit unit)
E	LinkedTransferQueue.poll(long timeout, TimeUnit unit)
E	PriorityBlockingQueue.poll(long timeout, TimeUnit unit)
E	SynchronousQueue.poll(long timeout, TimeUnit unit)	检索并删除此队列的头部，必要时等待指定的等待时间，以等待另一个线程插入它。
E	BlockingDeque.pollFirst(long timeout, TimeUnit unit)	检索并删除此双端队列的第一个元素，如有必要，等待指定的等待时间以使元素可用。
E	LinkedBlockingDeque.pollFirst(long timeout, TimeUnit unit)
E	BlockingDeque.pollLast(long timeout, TimeUnit unit)	检索并删除此双端队列的最后一个元素，如有必要，等待指定的等待时间以使元素可用。
E	LinkedBlockingDeque.pollLast(long timeout, TimeUnit unit)
void	ArrayBlockingQueue.put(E e)	将指定元素插入此队列的尾部，如果队列已满，则等待可用空间。
void	BlockingDeque.put(E e)	将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如有必要，等待空间可用。
void	BlockingQueue.put(E e)	将指定元素插入此队列，必要时等待可用空间。
void	LinkedBlockingDeque.put(E e)
void	LinkedBlockingQueue.put(E e)	将指定元素插入此队列的尾部，必要时等待可用空间。
void	SynchronousQueue.put(E e)	将指定元素添加到此队列，必要时等待另一个线程接收它。
void	BlockingDeque.putFirst(E e)	将指定的元素插入此双端队列的前面，必要时等待空间可用。
void	LinkedBlockingDeque.putFirst(E e)
void	BlockingDeque.putLast(E e)	在此双端队列的末尾插入指定的元素，必要时等待空间可用。
void	LinkedBlockingDeque.putLast(E e)
final boolean	ForkJoinTask.quietlyJoin(long timeout, TimeUnit unit)	尝试加入此任务，如果它在给定超时之前完成（可能是异常情况）并且当前线程未被中断，则返回 true。
void	TimeUnit.sleep(long timeout)	使用此时间单位执行 Thread.sleep 。
E	ArrayBlockingQueue.take()
E	BlockingDeque.take()	检索并删除由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如有必要，等待直到元素可用。
E	BlockingQueue.take()	检索并删除此队列的头部，必要时等待直到元素可用。
Future<V>	CompletionService.take()	检索并删除代表下一个已完成任务的 Future，如果还没有任务则等待。
E	DelayQueue.take()	检索并删除此队列的头部，如有必要，等待直到此队列上有一个具有过期延迟的元素可用。
Future<V>	ExecutorCompletionService.take()
E	LinkedBlockingDeque.take()
E	LinkedBlockingQueue.take()
E	LinkedTransferQueue.take()
E	PriorityBlockingQueue.take()
E	SynchronousQueue.take()	检索并删除此队列的头部，必要时等待另一个线程插入它。
E	BlockingDeque.takeFirst()	检索并删除此双端队列的第一个元素，必要时等待直到元素可用。
E	LinkedBlockingDeque.takeFirst()
E	BlockingDeque.takeLast()	检索并删除此双端队列的最后一个元素，必要时等待元素可用。
E	LinkedBlockingDeque.takeLast()
void	TimeUnit.timedJoin(Thread thread, long timeout)	使用此时间单位执行定时 Thread.join 。
void	TimeUnit.timedWait(Object obj, long timeout)	使用此时间单位执行计时 Object.wait 。
void	LinkedTransferQueue.transfer(E e)	将元素传输给消费者，必要时等待。
void	TransferQueue.transfer(E e)	将元素传输给消费者，必要时等待。
boolean	Semaphore.tryAcquire(int permits, long timeout, TimeUnit unit)	如果在给定的等待时间内所有许可都可用并且当前线程尚未 interrupted ，则从该信号量获取给定数量的许可。
boolean	Semaphore.tryAcquire(long timeout, TimeUnit unit)	如果信号量在给定的等待时间内变得可用并且当前线程尚未 interrupted ，则从该信号量获取许可。
boolean	LinkedTransferQueue.tryTransfer(E e, long timeout, TimeUnit unit)	如果可以在超时结束前将元素传输给消费者。
boolean	TransferQueue.tryTransfer(E e, long timeout, TimeUnit unit)	如果可以在超时结束前将元素传输给消费者。

InterruptedException 在 java.util.concurrent.locks 中的用法

在 java.util.concurrent.locks 中抛出 InterruptedException

修饰符和类型	方法	描述
final void	AbstractQueuedLongSynchronizer.acquireInterruptibly(long arg)	以独占模式获取，如果中断则中止。
final void	AbstractQueuedSynchronizer.acquireInterruptibly(int arg)	以独占模式获取，如果中断则中止。
final void	AbstractQueuedLongSynchronizer.acquireSharedInterruptibly(long arg)	以共享模式获取，如果中断则中止。
final void	AbstractQueuedSynchronizer.acquireSharedInterruptibly(int arg)	以共享模式获取，如果中断则中止。
final void	AbstractQueuedLongSynchronizer.ConditionObject.await()	实现可中断条件等待。
final boolean	AbstractQueuedLongSynchronizer.ConditionObject.await(long time, TimeUnit unit)	实现定时条件等待。
final void	AbstractQueuedSynchronizer.ConditionObject.await()	实现可中断条件等待。
final boolean	AbstractQueuedSynchronizer.ConditionObject.await(long time, TimeUnit unit)	实现定时条件等待。
void	Condition.await()	导致当前线程等待，直到收到信号或 interrupted 。
boolean	Condition.await(long time, TimeUnit unit)	使当前线程等待，直到收到信号或中断，或者指定的等待时间结束。
final long	AbstractQueuedLongSynchronizer.ConditionObject.awaitNanos(long nanosTimeout)	实现定时条件等待。
final long	AbstractQueuedSynchronizer.ConditionObject.awaitNanos(long nanosTimeout)	实现定时条件等待。
long	Condition.awaitNanos(long nanosTimeout)	使当前线程等待，直到收到信号或中断，或者指定的等待时间结束。
final boolean	AbstractQueuedLongSynchronizer.ConditionObject.awaitUntil(Date deadline)	实现绝对定时条件等待。
final boolean	AbstractQueuedSynchronizer.ConditionObject.awaitUntil(Date deadline)	实现绝对定时条件等待。
boolean	Condition.awaitUntil(Date deadline)	使当前线程等待，直到它收到信号或被中断，或者指定的截止日期过去。
void	Lock.lockInterruptibly()	获取锁，除非当前线程是 interrupted 。
void	ReentrantLock.lockInterruptibly()	获取锁，除非当前线程是 interrupted 。
void	ReentrantReadWriteLock.ReadLock.lockInterruptibly()	获取读锁，除非当前线程是 interrupted 。
void	ReentrantReadWriteLock.WriteLock.lockInterruptibly()	获取写锁，除非当前线程是 interrupted 。
long	StampedLock.readLockInterruptibly()	非独占地获取锁，必要时阻塞直到可用或当前线程被中断。
final boolean	AbstractQueuedLongSynchronizer.tryAcquireNanos(long arg, long nanosTimeout)	尝试以独占模式获取，如果中断则中止，如果给定的超时已过则失败。
final boolean	AbstractQueuedSynchronizer.tryAcquireNanos(int arg, long nanosTimeout)	尝试以独占模式获取，如果中断则中止，如果给定的超时已过则失败。
final boolean	AbstractQueuedLongSynchronizer.tryAcquireSharedNanos(long arg, long nanosTimeout)	尝试以共享模式获取，如果中断则中止，如果给定的超时已过则失败。
final boolean	AbstractQueuedSynchronizer.tryAcquireSharedNanos(int arg, long nanosTimeout)	尝试以共享模式获取，如果中断则中止，如果给定的超时已过则失败。
boolean	Lock.tryLock(long time, TimeUnit unit)	如果在给定的等待时间内是空闲的并且当前线程还没有interrupted，则获取锁。
boolean	ReentrantLock.tryLock(long timeout, TimeUnit unit)	如果在给定的等待时间内没有被另一个线程持有并且当前线程尚未被 interrupted ，则获取锁。
boolean	ReentrantReadWriteLock.ReadLock.tryLock(long timeout, TimeUnit unit)	如果写锁在给定的等待时间内没有被另一个线程持有并且当前线程还没有interrupted，则获取读锁。
boolean	ReentrantReadWriteLock.WriteLock.tryLock(long timeout, TimeUnit unit)	如果在给定的等待时间内没有被另一个线程持有并且当前线程还没有interrupted，则获取写锁。
long	StampedLock.tryReadLock(long time, TimeUnit unit)	如果在给定时间内可用且当前线程未被中断，则非独占获取锁。
long	StampedLock.tryWriteLock(long time, TimeUnit unit)	如果在给定时间内可用且当前线程未被中断，则独占获取锁。
long	StampedLock.writeLockInterruptibly()	独占获取锁，必要时阻塞，直到可用或当前线程被中断。

InterruptedException 在 javax.swing 中的用法

在 javax.swing 中抛出 InterruptedException

修饰符和类型	方法	描述
final T	SwingWorker.get()	如有必要，等待计算完成，然后检索其结果。
final T	SwingWorker.get(long timeout, TimeUnit unit)	如有必要，最多等待计算完成的给定时间，然后检索其结果（如果可用）。
static void	SwingUtilities.invokeAndWait(Runnable doRun)	导致 doRun.run() 在 AWT 事件调度线程上同步执行。

InterruptedException 在 jdk.incubator.concurrent 中的用法

在 jdk.incubator.concurrent 中抛出 InterruptedException

修饰符和类型	方法	描述
StructuredTaskScope<T>	StructuredTaskScope.join()	等待所有线程完成或任务范围关闭。
StructuredTaskScope.ShutdownOnFailure	StructuredTaskScope.ShutdownOnFailure.join()	等待所有线程完成或任务范围关闭。
StructuredTaskScope.ShutdownOnSuccess<T>	StructuredTaskScope.ShutdownOnSuccess.join()	等待所有线程完成或任务范围关闭。
StructuredTaskScope<T>	StructuredTaskScope.joinUntil(Instant deadline)	等待所有线程完成或任务范围关闭，直到给定的截止日期。
StructuredTaskScope.ShutdownOnFailure	StructuredTaskScope.ShutdownOnFailure.joinUntil(Instant deadline)	等待所有线程完成或任务范围关闭，直到给定的截止日期。
StructuredTaskScope.ShutdownOnSuccess<T>	StructuredTaskScope.ShutdownOnSuccess.joinUntil(Instant deadline)	等待所有线程完成或任务范围关闭，直到给定的截止日期。

InterruptedException 在 jdk.jfr.consumer 中的用法

在 jdk.jfr.consumer 中抛出 InterruptedException

修饰符和类型	方法	描述
void	EventStream.awaitTermination()	阻塞直到所有操作完成，或者流关闭，或者当前线程被中断，以先发生者为准。
void	EventStream.awaitTermination(Duration timeout)	阻塞直到所有操作完成，或者流关闭，或者发生超时，或者当前线程被中断，以先发生者为准。
void	RecordingStream.awaitTermination()
void	RecordingStream.awaitTermination(Duration timeout)

InterruptedException 在 jdk.management.jfr 中的用法

在 jdk.management.jfr 中抛出 InterruptedException

修饰符和类型	方法	描述
void	RemoteRecordingStream.awaitTermination()
void	RemoteRecordingStream.awaitTermination(Duration timeout)