Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JavaTM 2 Platform Standard Ed. 5.0
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
java.lang.InterruptedException

Packages that use InterruptedException
java.awt | Contains all of the classes for creating user interfaces and for painting graphics and images.
java.awt.image | Provides classes for creating and modifying images.
java.lang | Provides classes that are fundamental to the design of the Java programming language.
java.lang.ref | Provides reference-object classes, which support a limited degree of interaction with the garbage collector.
java.util.concurrent | Utility classes commonly useful in concurrent programming.
java.util.concurrent.locks | Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.
javax.swing | Provides a set of "lightweight" (all-Java language) components that, to the maximum degree possible, work the same on all platforms.

Uses of InterruptedException in java.awt

Methods in java.awt that throw InterruptedException
`AWTEvent` | `EventQueue.getNextEvent()` Removes an event from the `EventQueue` and returns it.
`static void` | `EventQueue.invokeAndWait(Runnable runnable)` Causes `runnable` to have its `run` method called in the dispatch thread of the `EventQueue`.
`void` | `MediaTracker.waitForAll()` Starts loading all images tracked by this media tracker.
`boolean` | `MediaTracker.waitForAll(long ms)` Starts loading all images tracked by this media tracker.
`void` | `MediaTracker.waitForID(int id)` Starts loading all images tracked by this media tracker with the specified identifier.
`boolean` | `MediaTracker.waitForID(int id, long ms)` Starts loading all images tracked by this media tracker with the specified identifier.

Uses of InterruptedException in java.awt.image

Methods in java.awt.image that throw InterruptedException
`boolean` | `PixelGrabber.grabPixels()` Request the Image or ImageProducer to start delivering pixels and wait for all of the pixels in the rectangle of interest to be delivered.
`boolean` | `PixelGrabber.grabPixels(long ms)` Request the Image or ImageProducer to start delivering pixels and wait for all of the pixels in the rectangle of interest to be delivered or until the specified timeout has elapsed.

Uses of InterruptedException in java.lang

Methods in java.lang that throw InterruptedException
`void` | `Thread.join()` Waits for this thread to die.
`void` | `Thread.join(long millis)` Waits at most `millis` milliseconds for this thread to die.
`void` | `Thread.join(long millis, int nanos)` Waits at most `millis` milliseconds plus `nanos` nanoseconds for this thread to die.
`static void` | `Thread.sleep(long millis)` Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds.
`static void` | `Thread.sleep(long millis, int nanos)` Causes the currently executing thread to sleep (cease execution) for the specified number of milliseconds plus the specified number of nanoseconds.
`void` | `Object.wait()` Causes current thread to wait until another thread invokes the `Object.notify()` method or the `Object.notifyAll()` method for this object.
`void` | `Object.wait(long timeout)` Causes current thread to wait until either another thread invokes the `Object.notify()` method or the `Object.notifyAll()` method for this object, or a specified amount of time has elapsed.
`void` | `Object.wait(long timeout, int nanos)` Causes current thread to wait until another thread invokes the `Object.notify()` method or the `Object.notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
`abstract int` | `Process.waitFor()` causes the current thread to wait, if necessary, until the process represented by this `Process` object has terminated.

Uses of InterruptedException in java.lang.ref

Methods in java.lang.ref that throw InterruptedException
`Reference<? extends T>` | `ReferenceQueue.remove()` Removes the next reference object in this queue, blocking until one becomes available.
`Reference<? extends T>` | `ReferenceQueue.remove(long timeout)` Removes the next reference object in this queue, blocking until either one becomes available or the given timeout period expires.

Uses of InterruptedException in java.util.concurrent

Methods in java.util.concurrent that throw InterruptedException
`void` | `Semaphore.acquire()` Acquires a permit from this semaphore, blocking until one is available, or the thread is `interrupted`.
`void` | `Semaphore.acquire(int permits)` Acquires the given number of permits from this semaphore, blocking until all are available, or the thread is `interrupted`.
`int` | `CyclicBarrier.await()` Waits until all `parties` have invoked `await` on this barrier.
`void` | `CountDownLatch.await()` Causes the current thread to wait until the latch has counted down to zero, unless the thread is `interrupted`.
`int` | `CyclicBarrier.await(long timeout, TimeUnit unit)` Waits until all `parties` have invoked `await` on this barrier.
`boolean` | `CountDownLatch.await(long timeout, TimeUnit unit)` Causes the current thread to wait until the latch has counted down to zero, unless the thread is `interrupted`, or the specified waiting time elapses.
`boolean` | `ThreadPoolExecutor.awaitTermination(long timeout, TimeUnit unit)`
`boolean` | `ExecutorService.awaitTermination(long timeout, TimeUnit unit)` Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.
`V` | `Exchanger.exchange(V x)` Waits for another thread to arrive at this exchange point (unless it is `interrupted`), and then transfers the given object to it, receiving its object in return.
`V` | `Exchanger.exchange(V x, long timeout, TimeUnit unit)` Waits for another thread to arrive at this exchange point (unless it is `interrupted`, or the specified waiting time elapses), and then transfers the given object to it, receiving its object in return.
`V` | `FutureTask.get()`
`V` | `Future.get()` Waits if necessary for the computation to complete, and then retrieves its result.
`V` | `FutureTask.get(long timeout, TimeUnit unit)`
`V` | `Future.get(long timeout, TimeUnit unit)` Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
`
`<T> List<Future<T>>`
` | `ExecutorService.invokeAll(Collection<Callable<T>> tasks)` Executes the given tasks, returning a list of Futures holding their status and results when all complete.
`
`<T> List<Future<T>>`
` | `AbstractExecutorService.invokeAll(Collection<Callable<T>> tasks)`
`
`<T> List<Future<T>>`
` | `ExecutorService.invokeAll(Collection<Callable<T>> tasks, long timeout, TimeUnit unit)` Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first.
`
`<T> List<Future<T>>`
` | `AbstractExecutorService.invokeAll(Collection<Callable<T>> tasks, long timeout, TimeUnit unit)`
`
`<T> T`
` | `ExecutorService.invokeAny(Collection<Callable<T>> tasks)` Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do.
`
`<T> T`
` | `AbstractExecutorService.invokeAny(Collection<Callable<T>> tasks)`
`
`<T> T`
` | `ExecutorService.invokeAny(Collection<Callable<T>> tasks, long timeout, TimeUnit unit)` Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do before the given timeout elapses.
`
`<T> T`
` | `AbstractExecutorService.invokeAny(Collection<Callable<T>> tasks, long timeout, TimeUnit unit)`
`boolean` | `SynchronousQueue.offer(E o, long timeout, TimeUnit unit)` Inserts the specified element into this queue, waiting if necessary up to the specified wait time for another thread to receive it.
`boolean` | `LinkedBlockingQueue.offer(E o, long timeout, TimeUnit unit)` Inserts the specified element at the tail of this queue, waiting if necessary up to the specified wait time for space to become available.
`boolean` | `BlockingQueue.offer(E o, long timeout, TimeUnit unit)` Inserts the specified element into this queue, waiting if necessary up to the specified wait time for space to become available.
`boolean` | `ArrayBlockingQueue.offer(E o, long timeout, TimeUnit unit)` Inserts the specified element at the tail of this queue, waiting if necessary up to the specified wait time for space to become available.
`E` | `SynchronousQueue.poll(long timeout, TimeUnit unit)` Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time, for another thread to insert it.
`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)` Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements with an unexpired delay are present on this queue.
`Future<V>` | `CompletionService.poll(long timeout, TimeUnit unit)` Retrieves and removes the Future representing the next completed task, waiting if necessary up to the specified wait time if none are yet present.
`E` | `BlockingQueue.poll(long timeout, TimeUnit unit)` Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements are present on this queue.
`E` | `ArrayBlockingQueue.poll(long timeout, TimeUnit unit)`
`void` | `SynchronousQueue.put(E o)` Adds the specified element to this queue, waiting if necessary for another thread to receive it.
`void` | `LinkedBlockingQueue.put(E o)` Adds the specified element to the tail of this queue, waiting if necessary for space to become available.
`void` | `BlockingQueue.put(E o)` Adds the specified element to this queue, waiting if necessary for space to become available.
`void` | `ArrayBlockingQueue.put(E o)` Adds the specified element to the tail of this queue, waiting if necessary for space to become available.
`void` | `TimeUnit.sleep(long timeout)` Perform a `Thread.sleep` using this unit.
`E` | `SynchronousQueue.take()` Retrieves and removes the head of this queue, waiting if necessary for another thread to insert it.
`E` | `PriorityBlockingQueue.take()`
`E` | `LinkedBlockingQueue.take()`
`Future<V>` | `ExecutorCompletionService.take()`
`E` | `DelayQueue.take()` Retrieves and removes the head of this queue, waiting if no elements with an unexpired delay are present on this queue.
`Future<V>` | `CompletionService.take()` Retrieves and removes the Future representing the next completed task, waiting if none are yet present.
`E` | `BlockingQueue.take()` Retrieves and removes the head of this queue, waiting if no elements are present on this queue.
`E` | `ArrayBlockingQueue.take()`
`void` | `TimeUnit.timedJoin(Thread thread, long timeout)` Perform a timed `Thread.join` using this time unit.
`void` | `TimeUnit.timedWait(Object obj, long timeout)` Perform a timed `Object.wait` using this time unit.
`boolean` | `Semaphore.tryAcquire(int permits, long timeout, TimeUnit unit)` Acquires the given number of permits from this semaphore, if all become available within the given waiting time and the current thread has not been `interrupted`.
`boolean` | `Semaphore.tryAcquire(long timeout, TimeUnit unit)` Acquires a permit from this semaphore, if one becomes available within the given waiting time and the current thread has not been `interrupted`.

Uses of InterruptedException in java.util.concurrent.locks

Methods in java.util.concurrent.locks that throw InterruptedException
`void` | `AbstractQueuedSynchronizer.acquireInterruptibly(int arg)` Acquires in exclusive mode, aborting if interrupted.
`void` | `AbstractQueuedSynchronizer.acquireSharedInterruptibly(int arg)` Acquires in shared mode, aborting if interrupted.
`void` | `AbstractQueuedSynchronizer.ConditionObject.await()` Implements interruptible condition wait.
`void` | `Condition.await()` Causes the current thread to wait until it is signalled or `interrupted`.
`boolean` | `AbstractQueuedSynchronizer.ConditionObject.await(long time, TimeUnit unit)` Implements timed condition wait.
`boolean` | `Condition.await(long time, TimeUnit unit)` Causes the current thread to wait until it is signalled or interrupted, or the specified waiting time elapses.
`long` | `AbstractQueuedSynchronizer.ConditionObject.awaitNanos(long nanosTimeout)` Implements timed condition wait.
`long` | `Condition.awaitNanos(long nanosTimeout)` Causes the current thread to wait until it is signalled or interrupted, or the specified waiting time elapses.
`boolean` | `AbstractQueuedSynchronizer.ConditionObject.awaitUntil(Date deadline)` Implements absolute timed condition wait.
`boolean` | `Condition.awaitUntil(Date deadline)` Causes the current thread to wait until it is signalled or interrupted, or the specified deadline elapses.
`void` | `ReentrantReadWriteLock.ReadLock.lockInterruptibly()` Acquires the read lock unless the current thread is `interrupted`.
`void` | `ReentrantReadWriteLock.WriteLock.lockInterruptibly()` Acquires the write lock unless the current thread is `interrupted`.
`void` | `Lock.lockInterruptibly()` Acquires the lock unless the current thread is `interrupted`.
`void` | `ReentrantLock.lockInterruptibly()` Acquires the lock unless the current thread is `interrupted`.
`boolean` | `AbstractQueuedSynchronizer.tryAcquireNanos(int arg, long nanosTimeout)` Attempts to acquire in exclusive mode, aborting if interrupted, and failing if the given timeout elapses.
`boolean` | `AbstractQueuedSynchronizer.tryAcquireSharedNanos(int arg, long nanosTimeout)` Attempts to acquire in shared mode, aborting if interrupted, and failing if the given timeout elapses.
`boolean` | `ReentrantReadWriteLock.ReadLock.tryLock(long timeout, TimeUnit unit)` Acquires the read lock if the write lock is not held by another thread within the given waiting time and the current thread has not been `interrupted`.
`boolean` | `ReentrantReadWriteLock.WriteLock.tryLock(long timeout, TimeUnit unit)` Acquires the write lock if it is not held by another thread within the given waiting time and the current thread has not been `interrupted`.
`boolean` | `Lock.tryLock(long time, TimeUnit unit)` Acquires the lock if it is free within the given waiting time and the current thread has not been `interrupted`.
`boolean` | `ReentrantLock.tryLock(long timeout, TimeUnit unit)` Acquires the lock if it is not held by another thread within the given waiting time and the current thread has not been `interrupted`.

Uses of InterruptedException in javax.swing

Methods in javax.swing that throw InterruptedException
`static void` | `SwingUtilities.invokeAndWait(Runnable doRun)` Causes `doRun.run()` to be executed synchronously on the AWT event dispatching thread.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JavaTM 2 Platform Standard Ed. 5.0
PREV NEXT | FRAMES NO FRAMES

Submit a bug or feature
For further API reference and developer documentation, see Java 2 SDK SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Copyright 2004 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.