類別 java.lang.InterruptedException
的使用

使用 InterruptedException 的軟體套件

java.awt	包含用於創建使用者介面和繪製圖形圖像的全部類別。
java.awt.image	提供創建和修改圖像的各種類別。
java.lang	提供利用 Java 程式語言進行程序設計的基礎類別。
java.lang.ref	提供了參考物件類別，支持在某種程度上與垃圾回收器之間的交互。
java.util.concurrent	在共時程式中很常用的實用工具類別。
java.util.concurrent.locks	為鎖和等待條件提供一個框架的介面和類別，它不同於內置同步和監視器。
javax.swing	提供一組“輕量級”（全部是 Java 語言）元件，盡量讓這些元件在所有平臺上的工作方式都相同。

java.awt 中 InterruptedException 的使用

拋出 InterruptedException 的 java.awt 中的方法

AWTEvent	EventQueue.getNextEvent() 從 EventQueue 中移除一個事件，並返回該事件。
static void	EventQueue.invokeAndWait(Runnable runnable) 導致 runnable 的 run 方法在 the system EventQueue 的指派執行緒中被調用。
void	MediaTracker.waitForAll() 開始載入由此媒體追蹤器追蹤的所有圖像。
boolean	MediaTracker.waitForAll(long ms) 開始載入由此媒體追蹤器追蹤的所有圖像。
void	MediaTracker.waitForID(int id) 開始載入由此媒體追蹤器追蹤且具有指定標識符的所有圖像。
boolean	MediaTracker.waitForID(int id, long ms) 開始載入由此媒體追蹤器追蹤且具有指定標識符的所有圖像。

java.awt.image 中 InterruptedException 的使用

拋出 InterruptedException 的 java.awt.image 中的方法

boolean	PixelGrabber.grabPixels() 請求 Image 或 ImageProducer 開始傳遞像素，並等待傳遞完相關矩形中的所有像素。
boolean	PixelGrabber.grabPixels(long ms) 請求 Image 或 ImageProducer 開始傳遞像素，並等待傳遞完相關矩形中的所有像素，或者等待到用完逾時期。

java.lang 中 InterruptedException 的使用

拋出 InterruptedException 的 java.lang 中的方法

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 物件表示的進程已經終止。

java.lang.ref 中 InterruptedException 的使用

拋出 InterruptedException 的 java.lang.ref 中的方法

Reference<? extends T>	ReferenceQueue.remove() 移除此佇列中的下一個參考物件，阻塞到某個物件變得可用為止。
Reference<? extends T>	ReferenceQueue.remove(long timeout) 移除此佇列中的下一個參考物件，阻塞到有一個物件變得可用或者給定的逾時期滿了為止。

java.util.concurrent 中 InterruptedException 的使用

拋出 InterruptedException 的 java.util.concurrent 中的方法

void	Semaphore.acquire() 從此信號量獲取一個許可，在提供一個許可前一直將執行緒阻塞，否則執行緒被中斷。
void	Semaphore.acquire(int permits) 從此信號量獲取給定數目的許可，在提供這些許可前一直將執行緒阻塞，或者執行緒已被中斷。
void	CountDownLatch.await() 使當前執行緒在鎖存器倒計數至零之前一直等待，除非執行緒被中斷。
int	CyclicBarrier.await() 在所有參與者都已經在此 barrier 上調用 await 方法之前，將一直等待。
boolean	CountDownLatch.await(long timeout, TimeUnit unit) 使當前執行緒在鎖存器倒計數至零之前一直等待，除非執行緒被中斷或超出了指定的等待時間。
int	CyclicBarrier.await(long timeout, TimeUnit unit) 在所有參與者都已經在此屏障上調用 await 方法之前將一直等待,或者超出了指定的等待時間。
boolean	ExecutorService.awaitTermination(long timeout, TimeUnit unit) 請求關閉、發生逾時或者當前執行緒中斷，無論哪一個首先發生之後，都將導致阻塞，直到所有任務完成執行。
boolean	ThreadPoolExecutor.awaitTermination(long timeout, TimeUnit unit)
V	Exchanger.exchange(V x) 等待另一個執行緒到達此交換點（除非當前執行緒被中斷），然後將給定的物件傳送給該執行緒，並接收該執行緒的物件。
V	Exchanger.exchange(V x, long timeout, TimeUnit unit) 等待另一個執行緒到達此交換點（除非當前執行緒被中斷，或者超出了指定的等待時間），然後將給定的物件傳送給該執行緒，同時接收該執行緒的物件。
V	Future.get() 如有必要，等待計算完成，然後獲取其結果。
V	FutureTask.get()
V	Future.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) 執行給定的任務，當所有任務完成時，返回保持任務狀態和結果的 Future 列表。
<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) 執行給定的任務，當所有任務完成或逾時期滿時（無論哪個首先發生），返回保持任務狀態和結果的 Future 列表。
<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) 執行給定的任務，如果在給定的逾時期滿前某個任務已成功完成（也就是未拋出異常），則返回其結果。
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 o, 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	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 o) 將指定元素添加到此佇列，如有必要則等待另一個執行緒接收它。
void	BlockingDeque.putFirst(E e) 將指定的元素插入此雙端佇列的開頭，必要時將一直等待可用空間。
void	LinkedBlockingDeque.putFirst(E e)
void	BlockingDeque.putLast(E e) 將指定的元素插入此雙端佇列的末尾，必要時將一直等待可用空間。
void	LinkedBlockingDeque.putLast(E e)
void	TimeUnit.sleep(long timeout) 使用此單元執行 Thread.sleep.這是將時間參數轉換為 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	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。
boolean	Semaphore.tryAcquire(int permits, long timeout, TimeUnit unit) 如果在給定的等待時間內此信號量有可用的所有許可，並且當前執行緒未被中斷，則從此信號量獲取給定數目的許可。
boolean	Semaphore.tryAcquire(long timeout, TimeUnit unit) 如果在給定的等待時間內，此信號量有可用的許可並且當前執行緒未被中斷，則從此信號量獲取一個許可。

java.util.concurrent.locks 中 InterruptedException 的使用

拋出 InterruptedException 的 java.util.concurrent.locks 中的方法

void	AbstractQueuedSynchronizer.acquireInterruptibly(int arg) 以獨佔網要獲取物件，如果被中斷則中止。
void	AbstractQueuedLongSynchronizer.acquireInterruptibly(long arg) 以獨佔網要獲取，如果被中斷則中止。
void	AbstractQueuedSynchronizer.acquireSharedInterruptibly(int arg) 以共享網要獲取物件，如果被中斷則中止。
void	AbstractQueuedLongSynchronizer.acquireSharedInterruptibly(long arg) 以共享網要獲取，如果被中斷則中止。
void	AbstractQueuedLongSynchronizer.ConditionObject.await() 實作可中斷的條件等待。
void	Condition.await() 造成當前執行緒在接到信號或被中斷之前一直處於等待狀態。
void	AbstractQueuedSynchronizer.ConditionObject.await() 實作不可中斷的條件等待。
boolean	AbstractQueuedLongSynchronizer.ConditionObject.await(long time, TimeUnit unit) 實作定時條件等待。
boolean	Condition.await(long time, TimeUnit unit) 造成當前執行緒在接到信號、被中斷或到達指定等待時間之前一直處於等待狀態。
boolean	AbstractQueuedSynchronizer.ConditionObject.await(long time, TimeUnit unit) 實作定時的條件等待。
long	AbstractQueuedLongSynchronizer.ConditionObject.awaitNanos(long nanosTimeout) 實作定時條件等待。
long	Condition.awaitNanos(long nanosTimeout) 造成當前執行緒在接到信號、被中斷或到達指定等待時間之前一直處於等待狀態。
long	AbstractQueuedSynchronizer.ConditionObject.awaitNanos(long nanosTimeout) 實作定時的條件等待。
boolean	AbstractQueuedLongSynchronizer.ConditionObject.awaitUntil(Date deadline) 實作絕對定時條件等待。
boolean	Condition.awaitUntil(Date deadline) 造成當前執行緒在接到信號、被中斷或到達指定最後期限之前一直處於等待狀態。
boolean	AbstractQueuedSynchronizer.ConditionObject.awaitUntil(Date deadline) 實作絕對定時條件等待。
void	ReentrantReadWriteLock.ReadLock.lockInterruptibly() 獲取讀取鎖，除非當前執行緒被中斷。
void	ReentrantReadWriteLock.WriteLock.lockInterruptibly() 獲取寫入鎖，除非當前執行緒被中斷。
void	ReentrantLock.lockInterruptibly() 如果當前執行緒未被中斷，則獲取鎖。
void	Lock.lockInterruptibly() 如果當前執行緒未被中斷，則獲取鎖。
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	ReentrantReadWriteLock.ReadLock.tryLock(long timeout, TimeUnit unit) 如果另一個執行緒在給定的等待時間內沒有保持寫入鎖，並且當前執行緒未被中斷，則獲取讀取鎖。
boolean	ReentrantReadWriteLock.WriteLock.tryLock(long timeout, TimeUnit unit) 如果另一個執行緒在給定的等待時間內沒有保持寫入鎖，並且當前執行緒未被中斷，則獲取寫入鎖。
boolean	ReentrantLock.tryLock(long timeout, TimeUnit unit) 如果鎖在給定等待時間內沒有被另一個執行緒保持，且當前執行緒未被中斷，則獲取該鎖。
boolean	Lock.tryLock(long time, TimeUnit unit) 如果鎖在給定的等待時間內空閒，並且當前執行緒未被中斷，則獲取鎖。

javax.swing 中 InterruptedException 的使用

拋出 InterruptedException 的 javax.swing 中的方法

T	SwingWorker.get() 如有必要，等待計算完成，然後獲取其結果。
T	SwingWorker.get(long timeout, TimeUnit unit) 如有必要，最多等待為使計算完成所給定的時間之後，獲取其結果（如果結果可用）。
static void	SwingUtilities.invokeAndWait(Runnable doRun) 導致 doRun.run() 在 AWT 事件指派執行緒上同步執行。