|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
上一个 下一个 | 框架 无框架 |
使用 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 方法在 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)
从此信号量获取给定数目的许可,在提供这些许可前一直将线程阻塞,否则线程是 已中断的 。 |
|
int |
CyclicBarrier.await()
在所有 参与者 都已经在此 barrier 上调用 await 方法之前,将一直等待。 |
|
void |
CountDownLatch.await()
使当前线程在锁存器倒计数至零之前一直等待,除非线程被 中断 。 |
|
int |
CyclicBarrier.await(long timeout,
TimeUnit unit)
在所有 参与者 都已经在此屏障上调用 await 方法之前,将一直等待。 |
|
boolean |
CountDownLatch.await(long timeout,
TimeUnit unit)
使当前线程在锁存器倒计数至零之前一直等待,除非线程被 中断 或超出了指定的等待时间。 |
|
boolean |
ThreadPoolExecutor.awaitTermination(long timeout,
TimeUnit unit)
|
|
boolean |
ExecutorService.awaitTermination(long timeout,
TimeUnit unit)
请求关闭、发生超时或者当前线程中断,无论哪一个首先发生之后,都将导致阻塞,直到所有任务完成执行。 |
|
V |
Exchanger.exchange(V x)
等待另一个线程到达此交换点(除非它被 中断 ),然后将给定的对象传送给该线程,并接收该线程的对象。 |
|
V |
Exchanger.exchange(V x,
long timeout,
TimeUnit unit)
等待另一个线程到达此交换点(除非它被 中断 ,或者超出了指定的等待时间),然后将给定的对象传送给该线程,同时接收该线程的对象。 |
|
V |
FutureTask.get()
|
|
V |
Future.get()
如有必要,等待计算完成,然后检索其结果。 |
|
V |
FutureTask.get(long timeout,
TimeUnit unit)
|
|
V |
Future.get(long timeout,
TimeUnit unit)
如有必要,最多等待为使计算完成所给定的时间之后,检索其结果(如果结果可用)。 |
|
|
ExecutorService.invokeAll(Collection<Callable<T>> tasks)
执行给定的任务,当所有任务完成时,返回保持任务状态和结果的 Future 列表。 |
|
|
AbstractExecutorService.invokeAll(Collection<Callable<T>> tasks)
|
|
|
ExecutorService.invokeAll(Collection<Callable<T>> tasks,
long timeout,
TimeUnit unit)
执行给定的任务,当所有任务完成或超时期满时(无论哪个首先发生),返回保持任务状态和结果的 Future 列表。 |
|
|
AbstractExecutorService.invokeAll(Collection<Callable<T>> tasks,
long timeout,
TimeUnit unit)
|
|
|
ExecutorService.invokeAny(Collection<Callable<T>> tasks)
执行给定的任务,如果某个任务已成功完成(也就是未抛出异常),则返回其结果。 |
|
|
AbstractExecutorService.invokeAny(Collection<Callable<T>> tasks)
|
|
|
ExecutorService.invokeAny(Collection<Callable<T>> tasks,
long timeout,
TimeUnit unit)
执行给定的任务,如果在给定的超时期满前某个任务已成功完成(也就是未抛出异常),则返回其结果。 |
|
|
AbstractExecutorService.invokeAny(Collection<Callable<T>> tasks,
long timeout,
TimeUnit unit)
|
|
boolean |
SynchronousQueue.offer(E o,
long timeout,
TimeUnit unit)
将指定的元素插入到此队列,如有必要则等待指定的时间,以便另一个线程接收它。 |
|
boolean |
LinkedBlockingQueue.offer(E o,
long timeout,
TimeUnit unit)
在队列尾插入指定的元素,如有必要,则等待指定的时间以使空间变得可用。 |
|
boolean |
BlockingQueue.offer(E o,
long timeout,
TimeUnit unit)
将指定的元素插入此队列中,如果没有可用空间,将等待指定的等待时间(如果有必要)。 |
|
boolean |
ArrayBlockingQueue.offer(E o,
long timeout,
TimeUnit unit)
将指定的元素插入到此队列的尾部,如果没有可用空间,将等待指定的等待时间(如果有必要)。 |
|
E |
SynchronousQueue.poll(long timeout,
TimeUnit unit)
检索并移除此队列的头,如有必要则等待指定的时间,以便另一个线程插入它。 |
|
E |
PriorityBlockingQueue.poll(long timeout,
TimeUnit unit)
|
|
E |
LinkedBlockingQueue.poll(long timeout,
TimeUnit unit)
|
|
Future<V> |
ExecutorCompletionService.poll(long timeout,
TimeUnit unit)
|
|
E |
DelayQueue.poll(long timeout,
TimeUnit unit)
检索并移除此队列的头部,如果此队列不存在未到期延迟的元素,则在到达指定的等待时间之前,一直等待(如果有必要)。 |
|
Future<V> |
CompletionService.poll(long timeout,
TimeUnit unit)
检索并移除表示下一个已完成任务的 Future,如果目前不存在这样的任务,则将等待指定的时间(如果有必要)。 |
|
E |
BlockingQueue.poll(long timeout,
TimeUnit unit)
检索并移除此队列的头部,如果此队列中没有任何元素,则等待指定等待的时间(如果有必要)。 |
|
E |
ArrayBlockingQueue.poll(long timeout,
TimeUnit unit)
|
|
void |
SynchronousQueue.put(E o)
将指定的元素添加到此队列,如有必要则等待另一个线程接收它。 |
|
void |
LinkedBlockingQueue.put(E o)
将指定的元素添加到队列的尾部,如有必要,则等待空间变得可用。 |
|
void |
BlockingQueue.put(E o)
将指定元素添加到此队列中,如果没有可用空间,将一直等待(如果有必要)。 |
|
void |
ArrayBlockingQueue.put(E o)
将指定的元素添加到此队列的尾部,如果必要,将等待可用的空间。 |
|
void |
TimeUnit.sleep(long timeout)
使用此单元执行 Thread.sleep.这是将时间参数转换为 Thread.sleep 方法所需格式的便捷方法。 |
|
E |
SynchronousQueue.take()
检索并移除此队列的头,如有必要则等待另一个线程插入它。 |
|
E |
PriorityBlockingQueue.take()
|
|
E |
LinkedBlockingQueue.take()
|
|
Future<V> |
ExecutorCompletionService.take()
|
|
E |
DelayQueue.take()
检索并移除此队列的头部,如果此队列不存在未到期延迟的元素,则等待它。 |
|
Future<V> |
CompletionService.take()
检索并移除表示下一个已完成任务的 Future,如果目前不存在这样的任务,则等待。 |
|
E |
BlockingQueue.take()
检索并移除此队列的头部,如果此队列不存在任何元素,则一直等待。 |
|
E |
ArrayBlockingQueue.take()
|
|
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 |
AbstractQueuedSynchronizer.acquireSharedInterruptibly(int arg)
以共享模式获取对象,如果被中断则中止。 |
void |
AbstractQueuedSynchronizer.ConditionObject.await()
实现不可中断的条件等待。 |
void |
Condition.await()
造成当前线程在接到信号或被 中断 之前一直处于等待状态。 |
boolean |
AbstractQueuedSynchronizer.ConditionObject.await(long time,
TimeUnit unit)
实现定时的条件等待。 |
boolean |
Condition.await(long time,
TimeUnit unit)
造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。 |
long |
AbstractQueuedSynchronizer.ConditionObject.awaitNanos(long nanosTimeout)
实现定时的条件等待。 |
long |
Condition.awaitNanos(long nanosTimeout)
造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。 |
boolean |
AbstractQueuedSynchronizer.ConditionObject.awaitUntil(Date deadline)
实现绝对定时条件等待。 |
boolean |
Condition.awaitUntil(Date deadline)
造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。 |
void |
Lock.lockInterruptibly()
如果当前线程未被 中断 ,则获取锁定。 |
void |
ReentrantLock.lockInterruptibly()
如果当前线程未被 中断 ,则获取锁定。 |
void |
ReentrantReadWriteLock.ReadLock.lockInterruptibly()
获取读取锁定,除非当前线程被 中断 。 |
void |
ReentrantReadWriteLock.WriteLock.lockInterruptibly()
获取写入锁定,除非当前线程被 中断 。 |
boolean |
AbstractQueuedSynchronizer.tryAcquireNanos(int arg,
long nanosTimeout)
试图以独占模式获取对象,如果被中断则中止,如果到了给定超时时间,则会失败。 |
boolean |
AbstractQueuedSynchronizer.tryAcquireSharedNanos(int arg,
long nanosTimeout)
试图以共享模式获取对象,如果被中断则中止,如果到了给定超时时间,则会失败。 |
boolean |
Lock.tryLock(long time,
TimeUnit unit)
如果锁定在给定的等待时间内空闲,并且当前线程未被 中断 ,则获取锁定。 |
boolean |
ReentrantLock.tryLock(long timeout,
TimeUnit unit)
如果锁定在给定等待时间内没有被另一个线程保持,且当前线程未被 中断 ,则获取该锁定。 |
boolean |
ReentrantReadWriteLock.ReadLock.tryLock(long timeout,
TimeUnit unit)
如果另一个线程在给定的等待时间内没有保持写入锁定,并且当前线程未被 中断 ,则获取读取锁定。 |
boolean |
ReentrantReadWriteLock.WriteLock.tryLock(long timeout,
TimeUnit unit)
如果另一个线程在给定的等待时间内没有保持写入锁定,并且当前线程未被 中断 ,则获取写入锁定。 |
javax.swing 中 InterruptedException 的使用 |
---|
抛出 InterruptedException 的 javax.swing 中的方法 | |
---|---|
static void |
SwingUtilities.invokeAndWait(Runnable doRun)
导致 doRun.run() 在 AWT 事件指派线程上同步执行。 |
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
上一个 下一个 | 框架 无框架 |
版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。