Uses of Class
java.lang.InterruptedException

Packages that use InterruptedException

软件包	描述
com.sun.jdi.event	该包定义了JDI事件和事件处理。
java.awt	包含用于创建用户界面和绘制图形和图像的所有类。
java.awt.image	提供创建和修改图像的类。
java.lang	提供对Java编程语言设计至关重要的类。
java.lang.ref	提供参考对象类，它支持与垃圾收集器的有限度的交互。
java.nio.channels	定义通道，其表示与能够执行I / O操作的实体的连接，例如文件和套接字; 定义选择器，用于多路复用，非阻塞I / O操作。
java.nio.file	定义Java虚拟机访问文件，文件属性和文件系统的接口和类。
java.util.concurrent	实用程序类通常用于并发编程。
java.util.concurrent.locks	接口和类提供了一个框架，用于锁定和等待与内置同步和监视器不同的条件。
javax.swing	提供一套“轻量级”（全Java语言）组件，尽可能地在所有平台上工作。
jdk.incubator.http	高级HTTP和WebSocket API

Uses of InterruptedException in com.sun.jdi.event

Methods in com.sun.jdi.event that throw InterruptedException

Modifier and Type	方法	描述
EventSet	EventQueue.remove()	等待下一个可用的事件永远。
EventSet	EventQueue.remove(long timeout)	等待下一个可用事件的指定时间。

Uses of InterruptedException in java.awt

Methods in java.awt that throw InterruptedException

Modifier and Type	方法	描述
AWTEvent	EventQueue.getNextEvent()	从 EventQueue删除事件并返回。
static void	EventQueue.invokeAndWait(Runnable runnable)	导致 runnable在 dispatch thread的 dispatch thread中调用其 run方法。
void	MediaTracker.waitForAll()	开始加载此媒体跟踪器跟踪的所有图像。
boolean	MediaTracker.waitForAll(long ms)	开始加载此媒体跟踪器跟踪的所有图像。
void	MediaTracker.waitForID(int id)	开始使用指定的标识符加载由此媒体跟踪器跟踪的所有图像。
boolean	MediaTracker.waitForID(int id, long ms)	开始使用指定的标识符加载由此媒体跟踪器跟踪的所有图像。

Uses of InterruptedException in java.awt.image

Methods in java.awt.image that throw InterruptedException

Modifier and Type	方法	描述
boolean	PixelGrabber.grabPixels()	请求Image或ImageProducer开始传送像素，并等待感兴趣的矩形中的所有像素被传送。
boolean	PixelGrabber.grabPixels(long ms)	请求Image或ImageProducer开始传送像素，并等待感兴趣的矩形中的所有像素被传送，或者直到指定的超时过去。

Uses of InterruptedException in java.lang

Methods in java.lang that throw InterruptedException

Modifier and Type	方法	描述
void	Thread.join()	等待这个线程死亡。
void	Thread.join(long millis)	等待这个线程死亡 millis毫秒。
void	Thread.join(long millis, int nanos)	等待最多 millis毫秒加上这个线程死亡的 nanos纳秒。
static void	Thread.sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数，这取决于系统定时器和调度程序的精度和准确性。
static void	Thread.sleep(long millis, int nanos)	导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），这取决于系统定时器和调度器的精度和准确性。
void	Object.wait()	导致当前线程等待，直到另一个线程调用此对象的 Object.notify()方法或 Object.notifyAll()方法。
void	Object.wait(long timeout)	导致当前线程等待，直到另一个线程调用此对象的 Object.notify()方法或 Object.notifyAll()方法，或指定的时间已过。
void	Object.wait(long timeout, int nanos)	导致当前线程等待，直到另一个线程调用此对象的 Object.notify()方法或 Object.notifyAll()方法，或其他一些线程中断当前线程或一定量的实时时间。
abstract int	Process.waitFor()	使当前线程等待，如有必要，直到此 Process对象表示的进程已终止。
boolean	Process.waitFor(long timeout, TimeUnit unit)	导致当前线程等待，如有必要，直到由此 Process对象表示的进程已终止，或指定的等待时间过去。

Uses of InterruptedException in java.lang.ref

Methods in java.lang.ref that throw InterruptedException

Modifier and Type	方法	描述
Reference<? extends T>	ReferenceQueue.remove()	删除此队列中的下一个参考对象，阻塞直到可用。
Reference<? extends T>	ReferenceQueue.remove(long timeout)	删除此队列中的下一个参考对象，阻塞，直到任何一个可用或给定的超时期限到期。

Uses of InterruptedException in java.nio.channels

Methods in java.nio.channels that throw InterruptedException

Modifier and Type	方法	描述
abstract boolean	AsynchronousChannelGroup.awaitTermination(long timeout, TimeUnit unit)	等待该组终止。

Uses of InterruptedException in java.nio.file

Methods in java.nio.file that throw InterruptedException

Modifier and Type	方法	描述
WatchKey	WatchService.poll(long timeout, TimeUnit unit)	检索并删除下一个watch键，如果还没有，则等待必要时直到指定的等待时间。
WatchKey	WatchService.take()	检索并删除下一个Watch键，等待是否还没有。

Uses of InterruptedException in java.util.concurrent

Methods in java.util.concurrent that throw InterruptedException

Modifier and Type	方法	描述
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 ，或者指定的等待时间 await 。
int	Phaser.awaitAdvanceInterruptibly(int phase)	等待相移器的相位从给定的相位值推进，抛出 InterruptedException如果在等待时中断，或者如果当前相位不等于给定的相位值，则立即返回，否则该移相器被终止。
int	Phaser.awaitAdvanceInterruptibly(int phase, long timeout, TimeUnit unit)	等待该移相器的阶段从给定的相位值或给定的超时 InterruptedException到等待时抛出 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)	如果有必要等待这个未来完成的给定时间，然后返回其结果（如果有的话）。
V	ForkJoinTask.get()	等待计算完成，然后检索其结果。
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)	执行给定的任务，返回持有他们的状态和结果的所有完成的期货列表。
<T> List<Future<T>>	ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)	执行给定的任务，返回在所有完成或超时到期时持有其状态和结果的期货列表，以先发生者为准。
<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)	将指定的元素插入由此deque表示的队列中（换句话说，在该deque的尾部），等待指定的等待时间（如果需要空间可用）。
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)	在此deque的前面插入指定的元素，等待指定的等待时间（如果需要空间可用）。
boolean	LinkedBlockingDeque.offerFirst(E e, long timeout, TimeUnit unit)
boolean	BlockingDeque.offerLast(E e, long timeout, TimeUnit unit)	在此deque的末尾插入指定的元素，如果需要空间可用，等待指定的等待时间。
boolean	LinkedBlockingDeque.offerLast(E e, long timeout, TimeUnit unit)
E	ArrayBlockingQueue.poll(long timeout, TimeUnit unit)
E	BlockingDeque.poll(long timeout, TimeUnit unit)	检索并删除由此deque（换句话说，该deque的第一个元素）表示的队列的头部，等待到指定的等待时间（如有必要）使元素变为可用。
E	BlockingQueue.poll(long timeout, TimeUnit unit)	检索并删除此队列的头，等待指定的等待时间（如有必要）使元素变为可用。
Future<V>	CompletionService.poll(long timeout, TimeUnit unit)	检索并删除表示下一个完成的任务的未来，如果还没有，则等待必要时直到指定的等待时间。
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)	检索并删除此deque的第一个元素，等待到指定的等待时间（如有必要）使元素变为可用。
E	LinkedBlockingDeque.pollFirst(long timeout, TimeUnit unit)
E	BlockingDeque.pollLast(long timeout, TimeUnit unit)	检索并删除此deque的最后一个元素，等待到指定的等待时间，如果需要，元素可用。
E	LinkedBlockingDeque.pollLast(long timeout, TimeUnit unit)
void	ArrayBlockingQueue.put(E e)	在该队列的尾部插入指定的元素，如果队列已满，则等待空间变为可用。
void	BlockingDeque.put(E e)	将指定的元素插入由此deque表示的队列（换句话说，在该deque的尾部），等待空格变为可用时。
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)	在此deque的前面插入指定的元素，如有必要，等待空格变为可用。
void	LinkedBlockingDeque.putFirst(E e)
void	BlockingDeque.putLast(E e)	在此deque的末尾插入指定的元素，如有必要，等待空格变为可用。
void	LinkedBlockingDeque.putLast(E e)
void	TimeUnit.sleep(long timeout)	使用此时间单位执行 Thread.sleep 。
E	ArrayBlockingQueue.take()
E	BlockingDeque.take()	检索并删除由此deque（换句话说，该deque的第一个元素）表示的队列的头部，如果需要，等待，直到元素可用。
E	BlockingQueue.take()	检索并删除此队列的头，如有必要，等待元素可用。
Future<V>	CompletionService.take()	检索并删除代表下一个完成任务的未来，等待是否还没有任务。
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()	检索并删除此deque的第一个元素，如有必要等待，直到元素可用。
E	LinkedBlockingDeque.takeFirst()
E	BlockingDeque.takeLast()	检索并删除此deque的最后一个元素，如有必要等待，直到元素可用。
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)	如果可以在超时过程之前将元素传送给消费者。

Uses of InterruptedException in java.util.concurrent.locks

Methods in java.util.concurrent.locks that throw InterruptedException

Modifier and Type	方法	描述
void	AbstractQueuedLongSynchronizer.acquireInterruptibly(long arg)	以独占方式获得，如果中断，中止。
void	AbstractQueuedSynchronizer.acquireInterruptibly(int arg)	以独占方式获得，如果中断，中止。
void	AbstractQueuedLongSynchronizer.acquireSharedInterruptibly(long arg)	以共享方式获取，如果中断，中止。
void	AbstractQueuedSynchronizer.acquireSharedInterruptibly(int arg)	以共享方式获取，如果中断，中止。
void	AbstractQueuedLongSynchronizer.ConditionObject.await()	实现可中断条件等待。
boolean	AbstractQueuedLongSynchronizer.ConditionObject.await(long time, TimeUnit unit)	实现定时状态等待。
void	AbstractQueuedSynchronizer.ConditionObject.await()	实现可中断条件等待。
boolean	AbstractQueuedSynchronizer.ConditionObject.await(long time, TimeUnit unit)	实现定时状态等待。
void	Condition.await()	导致当前线程等到发信号或 interrupted 。
boolean	Condition.await(long time, TimeUnit unit)	使当前线程等待直到发出信号或中断，或指定的等待时间过去。
long	AbstractQueuedLongSynchronizer.ConditionObject.awaitNanos(long nanosTimeout)	实现定时状态等待。
long	AbstractQueuedSynchronizer.ConditionObject.awaitNanos(long nanosTimeout)	实现定时状态等待。
long	Condition.awaitNanos(long nanosTimeout)	使当前线程等待直到发出信号或中断，或指定的等待时间过去。
boolean	AbstractQueuedLongSynchronizer.ConditionObject.awaitUntil(Date deadline)	实现绝对定时条件等待。
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()	非排他性地获取锁定，如有必要，阻塞，直到可用或当前线程中断。
boolean	AbstractQueuedLongSynchronizer.tryAcquireNanos(long arg, long nanosTimeout)	尝试以独占模式获取，如果中断则中止，如果给定的超时时间失败。
boolean	AbstractQueuedSynchronizer.tryAcquireNanos(int arg, long nanosTimeout)	尝试以独占模式获取，如果中断则中止，如果给定的超时时间失败。
boolean	AbstractQueuedLongSynchronizer.tryAcquireSharedNanos(long arg, long nanosTimeout)	尝试以共享模式获取，如果中断则中止，如果给定的时间超过，则失败。
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()	专门获取锁定，如有必要，阻塞，直到可用或当前线程中断。

Uses of InterruptedException in javax.swing

Methods in javax.swing that throw InterruptedException

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

Uses of InterruptedException in jdk.incubator.http

Methods in jdk.incubator.http that throw InterruptedException

Modifier and Type	方法	描述
abstract <T> HttpResponse<T>	HttpClient.send(HttpRequest req, HttpResponse.BodyHandler<T> responseBodyHandler)	Sends the given request using this client, blocking if necessary to get the response.