|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
ExecutorService
execution methods.Queue
operations.Deque
interface.interrupted
.
Deque
that additionally supports blocking operations that wait
for the deque to become non-empty when retrieving an element, and wait for
space to become available in the deque when storing an element.Queue
that additionally supports operations
that wait for the queue to become non-empty when retrieving an
element, and wait for space to become available in the queue when
storing an element.FutureTask
, cannot be retrieved because the task
was cancelled.Collections
with methods added in Java 5.0
and higher.CompressedOutputStream
.Map
providing additional atomic
putIfAbsent, remove, and replace methods.ConcurrentMap
supporting NavigableMap
operations,
and recursively so for its navigable sub-maps.ConcurrentNavigableMap
implementation.NavigableSet
implementation based on
a ConcurrentSkipListMap
.wait
, notify
and notifyAll
) into distinct objects to
give the effect of having multiple wait-sets per object, by
combining them with the use of arbitrary Lock
implementations.Set
that uses an internal CopyOnWriteArrayList
for all of its operations.Callable
object that, when
called, runs the given task and returns the given result.
Callable
object that, when
called, runs the given task and returns null.
Callable
object that, when
called, runs the given privileged action and returns its result.
Callable
object that, when
called, runs the given privileged exception action and returns
its result.
AsyncTask.Cancellable
.
SecureByteArrayOutputStream.reset()
,
that is, all data is discarded.
completion callback
.
Delayed
instances.
InheritableThreadLocal
that can be propagated to
worker threads by means of ThreadContext
.Allocator
interface which allocates fresh
data array at each request and has no memory usage control.ThreadContext
.
ThreadContext
.
ThreadContext
.
ThreadContext
.
NavigableSet
view of the keys contained in this map.
NavigableSet
view of the keys contained in this map.
Runnable
tasks.CompletionService
that uses a supplied Executor
to execute tasks.LinkedBlockingQueue
as a completion queue.
Executor
that provides methods to manage termination and
methods that can produce a Future
for tracking progress of
one or more asynchronous tasks.Executor
, ExecutorService
, ScheduledExecutorService
, ThreadFactory
, and Callable
classes defined in this
package.Set
view of the mappings contained in this map.
Set
view of the mappings contained in this map.
interrupted
),
and then transfers the given object to it, receiving its object
in return.
interrupted
or
the specified waiting time elapses), and then transfers the given
object to it, receiving its object in return.
default macros
.
FragmentInputStream.STAY_ON_CLOSE
closing policy.
completion callback
.
FinalizationGroup.registerFinalizer(Object referrent, Finalizer finalizer)
.
handles
as well as load classes, resources and libraries using abstract
ResourceFinder
entity encapsulating the searching approach.ResourceFinder
to find resources and having specified
parent class loader.
ResourceFinder
to find resources and with default
parent class loader.
PropertyUtils.expand(java.lang.String)
method.
InProcSocketAddress
holding local port number, as
obtained via InProcSocket.getLocalPort()
.
SocketAddress
holding local port number, as
obtained via TunnelSocket.getLocalPort()
.
InProcSocketAddress
.
InProcSocketAddress
.
handle
of it.
resource handles
.
JarURLConnection.JarOpener
that caches downloaded
JAR files in a local file system.JarURLConnection
which
supports customizable JAR caching policies.JarProxy
instance.
Set
view of the keys contained in this map.
NavigableSet
view of the keys contained in this map.
NavigableSet
view of the keys contained in this map.
Integer.MAX_VALUE
.
Integer.MAX_VALUE
, initially containing the elements of
the given collection, added in traversal order of the
collection's iterator.
Integer.MAX_VALUE
.
Integer.MAX_VALUE
, initially containing the elements of the
given collection,
added in traversal order of the collection's iterator.
If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.
Implementation Considerations
A implementation may be able to detect erroneous use of the lock, such as an invocation that would cause deadlock, and may throw an (unchecked) exception in such circumstances. The circumstances and the exception type must be documented by that implementation.
Acquires the lock if it is available and returns immediately.
If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happens:
If the current thread:
InterruptedException
is thrown and the current thread's
interrupted status is cleared.
Implementation Considerations
The ability to interrupt a lock acquisition in some implementations may not be possible, and if possible may be an expensive operation. The programmer should be aware that this may be the case. An implementation should document when this is the case.
An implementation can favor responding to an interrupt over normal method return.
A implementation may be able to detect erroneous use of the lock, such as an invocation that would cause deadlock, and may throw an (unchecked) exception in such circumstances. The circumstances and the exception type must be documented by that implementation.
System.mapLibraryName(java.lang.String)
.
SortedMap
extended with navigation methods returning the
closest matches for given search targets.SortedSet
extended with navigation methods reporting
closest matches for given search targets.NavigableSet
view of the keys contained in this map.
NavigableSet
view of the keys contained in this map.
Condition
instance that is bound to this
instance.
Condition
instance for use with this
Lock
instance.
Condition
instance for use with this
Lock
instance.
Condition
instance that is bound to this
instance.
Before waiting on the condition the lock must be held by the
current thread.
A call to Condition.await()
will atomically release the lock
before waiting and re-acquire the lock before the wait returns.
Implementation Considerations
The exact operation of the Condition
instance depends on
the implementation and must be documented by that
implementation.
get() would return this object.
- offerAtHead(Object, int, TimeUnit) -
Method in class edu.emory.mathcs.util.concurrent.DynamicArrayBlockingQueue
- Inserts specified object at the top of the queue, so the next call
to
get() would return this object, with specified timeout
and returns true if operation succeeded, false otherwise.
- offerFirst(Object) -
Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
- Inserts the specified element at the front of this deque.
- offerFirst(Object) -
Method in interface edu.emory.mathcs.backport.java.util.Deque
- Inserts the specified element at the front of this deque unless it would
violate capacity restrictions.
- offerFirst(Object) -
Method in class edu.emory.mathcs.backport.java.util.LinkedList
-
- offerFirst(Object) -
Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque
- Inserts the specified element at the front of this deque if it is
possible to do so immediately without violating capacity restrictions,
returning true upon success and false if no space is
currently available.
- offerFirst(Object, long, TimeUnit) -
Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque
- Inserts the specified element at the front of this deque,
waiting up to the specified wait time if necessary for space to
become available.
- offerFirst(Object) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
-
- offerFirst(Object, long, TimeUnit) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
-
- offerLast(Object) -
Method in class edu.emory.mathcs.backport.java.util.ArrayDeque
- Inserts the specified element at the end of this deque.
- offerLast(Object) -
Method in interface edu.emory.mathcs.backport.java.util.Deque
- Inserts the specified element at the end of this deque unless it would
violate capacity restrictions.
- offerLast(Object) -
Method in class edu.emory.mathcs.backport.java.util.LinkedList
-
- offerLast(Object) -
Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque
- Inserts the specified element at the end of this deque if it is
possible to do so immediately without violating capacity restrictions,
returning true upon success and false if no space is
currently available.
- offerLast(Object, long, TimeUnit) -
Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque
- Inserts the specified element at the end of this deque,
waiting up to the specified wait time if necessary for space to
become available.
- offerLast(Object) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
-
- offerLast(Object, long, TimeUnit) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
-
- onUndelegated(Object) -
Method in class edu.emory.mathcs.util.concurrent.DelegatableThreadLocal
-
- openConnection(URL) -
Method in class edu.emory.mathcs.util.classloader.jar.JarURLStreamHandler
-
- openJarFile(JarURLConnection) -
Method in class edu.emory.mathcs.util.classloader.jar.JarProxy
-
- openJarFile(JarURLConnection) -
Method in interface edu.emory.mathcs.util.classloader.jar.JarURLConnection.JarOpener
- Given the URL connection (not yet connected), return JarFile
representing the resource.
Allocator
using memory buffer pool.PriorityQueue
and supplies
blocking retrieval operations.Callable
object that will, when
called, execute the given callable under the current
access control context.
Callable
object that will, when
called, execute the given callable under the current
access control context, with the current context class loader
as the context class loader.
Future
tasks that have been cancelled.
poll() or take()
would return this object.
- putBack(WaitQueue.WaitNode) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.FIFOWaitQueue
-
- putBack(WaitQueue.WaitNode) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.helpers.WaitQueue
-
- putFirst(Object) -
Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque
- Inserts the specified element at the front of this deque,
waiting if necessary for space to become available.
- putFirst(Object) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
-
- putIfAbsent(Object, Object) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap
- If the specified key is not already associated
with a value, associate it with the given value.
This is equivalent to
if (!map.containsKey(key))
return map.put(key, value);
else
return map.get(key);
except that the action is performed atomically.
- putIfAbsent(Object, Object) -
Method in interface edu.emory.mathcs.backport.java.util.concurrent.ConcurrentMap
- If the specified key is not already associated
with a value, associate it with the given value.
- putIfAbsent(Object, Object) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.ConcurrentSkipListMap
- If the specified key is not already associated
with a value, associate it with the given value.
This is equivalent to
if (!map.containsKey(key))
return map.put(key, value);
else
return map.get(key);
except that the action is performed atomically.
- putLast(Object) -
Method in interface edu.emory.mathcs.backport.java.util.concurrent.BlockingDeque
- Inserts the specified element at the end of this deque,
waiting if necessary for space to become available.
- putLast(Object) -
Method in class edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingDeque
-
locks
, one for read-only operations and one for writing.Lock
with the same basic
behavior and semantics as the implicit monitor lock accessed using
methods and statements, but with extended
capabilities.ReadWriteLock
supporting similar
semantics to ReentrantLock
.ReentrantReadWriteLock.readLock()
.ReentrantReadWriteLock.writeLock()
.Executor
when a task cannot be
accepted for execution.ThreadPoolExecutor
.Future
that is Runnable
.ScheduledFuture
that is Runnable
.len
bytes of data to a
specified output stream.
len
characters to a
specified writer.
ThreadPoolExecutor
when
execute cannot accept a task.
if (map.containsKey(key) && map.get(key).equals(value)) { map.remove(key); return true; } else return false;except that the action is performed atomically.
if (map.containsKey(key) && map.get(key).equals(value)) { map.remove(key); return true; } else return false;except that the action is performed atomically.
if (map.containsKey(key) && map.get(key).equals(oldValue)) { map.put(key, newValue); return true; } else return false;except that the action is performed atomically.
if (map.containsKey(key)) { return map.put(key, value); } else return null;except that the action is performed atomically.
if (map.containsKey(key) && map.get(key).equals(oldValue)) { map.put(key, newValue); return true; } else return false;except that the action is performed atomically.
if (map.containsKey(key)) { return map.put(key, value); } else return null;except that the action is performed atomically.
count
field of this byte array output
stream to zero and clears up the entire buffer with zeros, so that all
currently accumulated output in the
ouput stream is discarded.
ExecutorService
that can schedule commands to run after a given
delay, or to execute periodically.ThreadPoolExecutor
that can additionally schedule
commands to run after a given delay, or to execute
periodically.AsyncTask
that overrides method
createPerformer
so that
it always runs with a fixed access control context and
thread context
inherited from the caller of
createPerformer method.thread context
from call initiator to the
thread executing the call.ExecutorService
that executes each submitted task using
one of possibly several pooled threads, normally configured
using Executors
factory methods.len
bytes of data from the input stream into
an array of bytes.
len
bytes of
data to a specified output stream.
Acquires the lock if it is available and returns immediately with the value . If the lock is not available then this method will return immediately with the value .
A typical usage idiom for this method would be:
Lock lock = ...; if (lock.tryLock()) { try { // manipulate protected state } finally { lock.unlock(); } } else { // perform alternative actions }This usage ensures that the lock is unlocked if it was acquired, and doesn't try to unlock if the lock was not acquired.
If the lock is available this method returns immediately with the value . If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happens:
If the lock is acquired then the value is returned.
If the current thread:
InterruptedException
is thrown and the current thread's
interrupted status is cleared.
If the specified waiting time elapses then the value is returned. If the time is less than or equal to zero, the method will not wait at all.
Implementation Considerations
The ability to interrupt a lock acquisition in some implementations may not be possible, and if possible may be an expensive operation. The programmer should be aware that this may be the case. An implementation should document when this is the case.
An implementation can favor responding to an interrupt over normal method return, or reporting a timeout.
A implementation may be able to detect erroneous use of the lock, such as an invocation that would cause deadlock, and may throw an (unchecked) exception in such circumstances. The circumstances and the exception type must be documented by that implementation.
ExecutorService
methods to the given executor, but not any
other methods that might otherwise be accessible using
casts.
ScheduledExecutorService
methods to the given executor, but
not any other methods that might otherwise be accessible using
casts.
Implementation Considerations
A implementation will usually impose restrictions on which thread can release a lock (typically only the holder of the lock can release it) and may throw an (unchecked) exception if the restriction is violated. Any restrictions and the exception type must be documented by that implementation.
Collection
view of the values contained in this map.
Collection
view of the values contained in this map.
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |