|
JavaTM Platform Standard Ed. 6 |
|||||||||
上一个 下一个 | 框架 无框架 |
使用 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)
|
|
|
AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)
|
|
|
ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks)
执行给定的任务,当所有任务完成时,返回保持任务状态和结果的 Future 列表。 |
|
|
AbstractExecutorService.invokeAll(Collection<? extends Callable<T>> tasks,
long timeout,
TimeUnit unit)
|
|
|
ExecutorService.invokeAll(Collection<? extends Callable<T>> tasks,
long timeout,
TimeUnit unit)
执行给定的任务,当所有任务完成或超时期满时(无论哪个首先发生),返回保持任务状态和结果的 Future 列表。 |
|
|
AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)
|
|
|
ExecutorService.invokeAny(Collection<? extends Callable<T>> tasks)
执行给定的任务,如果某个任务已成功完成(也就是未抛出异常),则返回其结果。 |
|
|
AbstractExecutorService.invokeAny(Collection<? extends Callable<T>> tasks,
long timeout,
TimeUnit unit)
|
|
|
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 事件指派线程上同步执行。 |
|
JavaTM Platform Standard Ed. 6 |
|||||||||
上一个 下一个 | 框架 无框架 |
版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。