Uses of Class
java.lang.InterruptedException

Packages that use InterruptedException

软件包	描述
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语言）组件，以最大可能的程度，在所有平台上工作。

Uses of InterruptedException in java.awt

Methods in java.awt that throw InterruptedException

Modifier and Type	Method and Description
AWTEvent	EventQueue.getNextEvent() 删除从 EventQueue事件并返回。
static void	EventQueue.invokeAndWait(Runnable runnable) 原因 runnable有其 run法在 the system EventQueue的 dispatch thread叫。
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	Method and Description
boolean	PixelGrabber.grabPixels() 请求的图像或imageproducer开始交付像素等所有感兴趣的矩形的像素将交付。
boolean	PixelGrabber.grabPixels(long ms) 请求的图像或imageproducer开始交付像素等所有感兴趣的矩形的像素被交付或在指定的超时时间。

Uses of InterruptedException in java.lang

Methods in java.lang that throw InterruptedException

Modifier and Type	Method and Description
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	Method and Description
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	Method and Description
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	Method and Description
WatchKey	WatchService.poll(long timeout, TimeUnit unit) 检索和删除下一个表键，如果需要的话，等待指定的等待时间，如果没有仍然存在。
WatchKey	WatchService.take() 检索和删除下一个表键，等待如果没有仍然存在。

Uses of InterruptedException in java.util.concurrent

Methods in java.util.concurrent that throw InterruptedException

Modifier and Type	Method and Description
void	Semaphore.acquire() 从这个信号获取许可证，阻塞直到有一个可用的线程，或是 interrupted。
void	Semaphore.acquire(int permits) 获得了从这个信号量许可证号码，阻塞直到所有的线程可用，或是 interrupted。
int	CyclicBarrier.await() 等到所有的 parties援引 await这个屏障。
void	CountDownLatch.await() 使当前线程等待直到锁向下计数为零，除非线程 interrupted。
int	CyclicBarrier.await(long timeout, TimeUnit unit) 等到所有的 parties援引 await这个障碍，或指定的等待时间的流逝。
boolean	CountDownLatch.await(long timeout, TimeUnit unit) 使当前线程等待直到锁向下计数为零，除非线程 interrupted，或指定的等待时间的流逝。
int	Phaser.awaitAdvanceInterruptibly(int phase) 等待着这个相位的相位提前从给定的相位值，扔 InterruptedException如果中断等待，或立即返回如果相电流不等于给定值或终止这种移相器的相。
int	Phaser.awaitAdvanceInterruptibly(int phase, long timeout, TimeUnit unit) 等待着这个相位的相位提前从给定的相位值或给定的超时时间，扔 InterruptedException如果中断等待，或立即返回如果相电流不等于给定值或终止这种移相器的相。
boolean	ThreadPoolExecutor.awaitTermination(long timeout, TimeUnit unit)
boolean	ExecutorService.awaitTermination(long timeout, TimeUnit unit) 直到所有的任务都完成后，关闭请求，或超时发生，或当前线程被中断，以先发生的情况。
boolean	ForkJoinPool.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或指定的等待时间的流逝），然后将给定对象，回报的对象。
V	ForkJoinTask.get() 等待，如果需要计算完成，然后检索其结果。
V	Future.get() 等待，如果需要计算完成，然后检索其结果。
T	CompletableFuture.get() 等待，如果必要的，为这个未来完成，然后返回其结果。
V	FutureTask.get()
V	ForkJoinTask.get(long timeout, TimeUnit unit) 如果需要的话，在大多数给定的计算时间完成，然后检索其结果，如果可用。
V	Future.get(long timeout, TimeUnit unit) 如果需要的话，在大多数给定的计算时间完成，然后检索其结果，如果可用。
T	CompletableFuture.get(long timeout, TimeUnit unit) 如果需要的话，在大多数给定的时间为这个未来完成，然后返回其结果，如果可用。
V	FutureTask.get(long timeout, TimeUnit unit)
<T> List<Future<T>>	AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)
<T> List<Future<T>>	ExecutorService.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, long timeout, TimeUnit unit) 执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完成或超时到期，以先发生的。
<T> T	AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)
<T> T	ExecutorService.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, long timeout, TimeUnit unit) 执行给定的任务，返回一个成功完成的结果（即，不抛出异常），如果做了超时之前经过。
static void	ForkJoinPool.managedBlock(ForkJoinPool.ManagedBlocker blocker) 块符合给定的阻滞剂。
boolean	LinkedBlockingDeque.offer(E e, long timeout, TimeUnit unit)
boolean	ArrayBlockingQueue.offer(E e, long timeout, TimeUnit unit) 在这个队列的尾部插入指定的元素，等待到指定的等待时间，如果队列已满，则等待可用空间可用的等待时间。
boolean	BlockingQueue.offer(E e, long timeout, TimeUnit unit) 将指定的元素插入到队列中，等待到指定的等待时间，如果需要的空间将成为可用的。
boolean	LinkedBlockingQueue.offer(E e, long timeout, TimeUnit unit) 在这个队列的尾部插入指定的元素，在必要时等待空间到指定的等待时间，以获得可用的空间。
boolean	BlockingDeque.offer(E e, long timeout, TimeUnit unit) 插入指定元素为代表的deque队列（换句话说，在这个队列的尾部），等待到指定的等待时间，如果空间成为必要。
boolean	SynchronousQueue.offer(E e, long timeout, TimeUnit unit) 将指定的元素插入到队列中，等待必要的时间到指定的等待另一个线程接收到的等待时间。
boolean	LinkedBlockingDeque.offerFirst(E e, long timeout, TimeUnit unit)
boolean	BlockingDeque.offerFirst(E e, long timeout, TimeUnit unit) 在这个队列的前面插入指定元素，等待到指定的等待时间，如果空间成为必要。
boolean	LinkedBlockingDeque.offerLast(E e, long timeout, TimeUnit unit)
boolean	BlockingDeque.offerLast(E e, long timeout, TimeUnit unit) 在这个队列的末尾插入指定元素，等待到指定的等待时间，如果空间成为必要。
E	LinkedTransferQueue.poll(long timeout, TimeUnit unit)
E	LinkedBlockingDeque.poll(long timeout, TimeUnit unit)
E	ArrayBlockingQueue.poll(long timeout, TimeUnit unit)
E	BlockingQueue.poll(long timeout, TimeUnit unit) 检索和删除此队列的头，等待指定的等待时间，如果需要的元素成为可用。
E	DelayQueue.poll(long timeout, TimeUnit unit) 检索并删除此队列的头，在必要时等待，直到该队列上有一个过期的延迟的元素，或指定的等待时间过期。
E	LinkedBlockingQueue.poll(long timeout, TimeUnit unit)
Future<V>	CompletionService.poll(long timeout, TimeUnit unit) 检索和删除表示下一个已完成的任务的未来，如果需要的话，在指定的等待时间，如果没有的话，等待。
Future<V>	ExecutorCompletionService.poll(long timeout, TimeUnit unit)
E	PriorityBlockingQueue.poll(long timeout, TimeUnit unit)
E	BlockingDeque.poll(long timeout, TimeUnit unit) 检索并移除该deque表示队列的头部（换句话说，这个容器的第一个元素），等待到指定的等待时间，如果一个元素成为必要。
E	SynchronousQueue.poll(long timeout, TimeUnit unit) 检索并删除此队列的头，等待必要时到指定的等待时间，另一个线程插入它。
E	LinkedBlockingDeque.pollFirst(long timeout, TimeUnit unit)
E	BlockingDeque.pollFirst(long timeout, TimeUnit unit) 检索并移除此队列的第一个元素，等待到指定的等待时间，如果一个元素成为必要。
E	LinkedBlockingDeque.pollLast(long timeout, TimeUnit unit)
E	BlockingDeque.pollLast(long timeout, TimeUnit unit) 检索并移除此队列的最后一个元素，等待到指定的等待时间，如果一个元素成为必要。
void	LinkedBlockingDeque.put(E e)
void	ArrayBlockingQueue.put(E e) 在这个队列的尾部插入指定的元素，如果队列已满，则等待空间可用。
void	BlockingQueue.put(E e) 将指定的元素插入到队列中，等待必要的空间，以获得可用的。
void	LinkedBlockingQueue.put(E e) 在这个队列的尾部插入指定的元素，在必要时等待空间可用。
void	BlockingDeque.put(E e) 插入指定元素为代表的deque队列（换句话说，在这个队列的尾部），如果空间成为提供必要的等待。
void	SynchronousQueue.put(E e) 将指定的元素添加到这个队列中，等待另一个线程接收它的必要。
void	LinkedBlockingDeque.putFirst(E e)
void	BlockingDeque.putFirst(E e) 在这个队列的前面插入指定元素，如果空间成为提供必要的等待。
void	LinkedBlockingDeque.putLast(E e)
void	BlockingDeque.putLast(E e) 在这个队列的末尾插入指定元素，如果空间成为提供必要的等待。
void	TimeUnit.sleep(long timeout) 执行 Thread.sleep利用这个时间单位。
E	LinkedTransferQueue.take()
E	LinkedBlockingDeque.take()
E	ArrayBlockingQueue.take()
E	BlockingQueue.take() 检索并移除此队列的头，在必要时等待，直到一个元素可用。
E	DelayQueue.take() 检索并删除此队列的头，在必要时等待，直到该队列上有一个过期的延迟的元素。
E	LinkedBlockingQueue.take()
Future<V>	CompletionService.take() 检索和删除表示下一个已完成的任务的未来，等待是否还存在。
Future<V>	ExecutorCompletionService.take()
E	PriorityBlockingQueue.take()
E	BlockingDeque.take() 检索并移除该deque表示队列的头部（换句话说，这个容器的第一个元素），必要时可用等待直到元。
E	SynchronousQueue.take() 检索并删除此队列的头，等待另一个线程是否需要插入它。
E	LinkedBlockingDeque.takeFirst()
E	BlockingDeque.takeFirst() 检索并移除此队列的第一个元素，如果有必要，直到一个元素可用等。
E	LinkedBlockingDeque.takeLast()
E	BlockingDeque.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	Method and Description
void	AbstractQueuedSynchronizer.acquireInterruptibly(int arg) 获取独占模式，如果中断中止。
void	AbstractQueuedLongSynchronizer.acquireInterruptibly(long arg) 获取独占模式，如果中断中止。
void	AbstractQueuedSynchronizer.acquireSharedInterruptibly(int arg) 获得在共享模式下，如果中断中止。
void	AbstractQueuedLongSynchronizer.acquireSharedInterruptibly(long arg) 获得在共享模式下，如果中断中止。
void	AbstractQueuedSynchronizer.ConditionObject.await() 实施可中断条件等。
void	AbstractQueuedLongSynchronizer.ConditionObject.await() 实施可中断条件等。
void	Condition.await() 使当前线程等待它暗示或 interrupted。
boolean	AbstractQueuedSynchronizer.ConditionObject.await(long time, TimeUnit unit) 实现定时等待状态。
boolean	AbstractQueuedLongSynchronizer.ConditionObject.await(long time, TimeUnit unit) 实现定时等待状态。
boolean	Condition.await(long time, TimeUnit unit) 使当前线程等待信号或中断，或指定的等待时间的流逝。
long	AbstractQueuedSynchronizer.ConditionObject.awaitNanos(long nanosTimeout) 实现定时等待状态。
long	AbstractQueuedLongSynchronizer.ConditionObject.awaitNanos(long nanosTimeout) 实现定时等待状态。
long	Condition.awaitNanos(long nanosTimeout) 使当前线程等待信号或中断，或指定的等待时间的流逝。
boolean	AbstractQueuedSynchronizer.ConditionObject.awaitUntil(Date deadline) 实现绝对定时条件等待。
boolean	AbstractQueuedLongSynchronizer.ConditionObject.awaitUntil(Date deadline) 实现绝对定时条件等待。
boolean	Condition.awaitUntil(Date deadline) 使当前线程等待信号或中断，或指定的期限结束。
void	ReentrantLock.lockInterruptibly() 获取该锁除非当前线程 interrupted。
void	ReentrantReadWriteLock.ReadLock.lockInterruptibly() 获取读锁，除非当前线程 interrupted。
void	ReentrantReadWriteLock.WriteLock.lockInterruptibly() 获得写锁除非当前线程 interrupted。
void	Lock.lockInterruptibly() 获取该锁除非当前线程 interrupted。
long	StampedLock.readLockInterruptibly() 非独占获取锁，如果必要，阻塞，直到可用或当前线程被中断。
boolean	AbstractQueuedSynchronizer.tryAcquireNanos(int arg, long nanosTimeout) 试图在独占模式下获得的，如果不中止中断，如果给定的超时时间流逝。
boolean	AbstractQueuedLongSynchronizer.tryAcquireNanos(long arg, long nanosTimeout) 试图在独占模式下获得的，如果不中止中断，如果给定的超时时间流逝。
boolean	AbstractQueuedSynchronizer.tryAcquireSharedNanos(int arg, long nanosTimeout) 试图在共享模式下获得的，如果不中止中断，如果给定的超时时间流逝。
boolean	AbstractQueuedLongSynchronizer.tryAcquireSharedNanos(long arg, long nanosTimeout) 试图在共享模式下获得的，如果不中止中断，如果给定的超时时间流逝。
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。
boolean	Lock.tryLock(long time, 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	Method and Description
T	SwingWorker.get() 等待，如果需要计算完成，然后检索其结果。
T	SwingWorker.get(long timeout, TimeUnit unit) 如果需要的话，在大多数给定的计算时间完成，然后检索其结果，如果可用。
static void	SwingUtilities.invokeAndWait(Runnable doRun) 原因 doRun.run()是同步执行的事件派发线程。