概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 6
 上一个   下一个 框架    无框架    

类 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 事件指派线程上同步执行。
 

概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 6
 上一个   下一个 框架    无框架    
提交错误或意见

版权所有 2008 Sun Microsystems, Inc. 保留所有权利。请遵守GNU General Public License, version 2 only。