public class ConcurrentUtils extends Object
An utility class providing functionality related to the java.util.concurrent package.
| Modifier and Type | Method and Description |
|---|---|
static <T> Future<T> |
constantFuture(T value)
Gets an implementation of
Future that is immediately done
and returns the specified constant value. |
static <K,V> V |
createIfAbsent(ConcurrentMap<K,V> map,
K key,
ConcurrentInitializer<V> init)
Checks if a concurrent map contains a key and creates a corresponding
value if not.
|
static <K,V> V |
createIfAbsentUnchecked(ConcurrentMap<K,V> map,
K key,
ConcurrentInitializer<V> init)
Checks if a concurrent map contains a key and creates a corresponding
value if not, suppressing checked exceptions.
|
static ConcurrentException |
extractCause(ExecutionException ex)
Inspects the cause of the specified
ExecutionException and
creates a ConcurrentException with the checked cause if
necessary. |
static ConcurrentRuntimeException |
extractCauseUnchecked(ExecutionException ex)
Inspects the cause of the specified
ExecutionException and
creates a ConcurrentRuntimeException with the checked cause if
necessary. |
static void |
handleCause(ExecutionException ex)
Handles the specified
ExecutionException. |
static void |
handleCauseUnchecked(ExecutionException ex)
Handles the specified
ExecutionException and transforms it into a
runtime exception. |
static <T> T |
initialize(ConcurrentInitializer<T> initializer)
Invokes the specified
ConcurrentInitializer and returns the
object produced by the initializer. |
static <T> T |
initializeUnchecked(ConcurrentInitializer<T> initializer)
Invokes the specified
ConcurrentInitializer and transforms
occurring exceptions to runtime exceptions. |
static <K,V> V |
putIfAbsent(ConcurrentMap<K,V> map,
K key,
V value)
Puts a value in the specified
ConcurrentMap if the key is not yet
present. |
public static ConcurrentException extractCause(ExecutionException ex)
ExecutionException and
creates a ConcurrentException with the checked cause if
necessary. This method performs the following checks on the cause of the
passed in exception:
ConcurrentException, initializes it with the cause, and
returns it.ex - the exception to be processedConcurrentException with the checked causepublic static ConcurrentRuntimeException extractCauseUnchecked(ExecutionException ex)
ExecutionException and
creates a ConcurrentRuntimeException with the checked cause if
necessary. This method works exactly like
extractCause(ExecutionException). The only difference is that
the cause of the specified ExecutionException is extracted as a
runtime exception. This is an alternative for client code that does not
want to deal with checked exceptions.ex - the exception to be processedConcurrentRuntimeException with the checked causepublic static void handleCause(ExecutionException ex) throws ConcurrentException
ExecutionException. This method calls
extractCause(ExecutionException) for obtaining the cause of the
exception - which might already cause an unchecked exception or an error
being thrown. If the cause is a checked exception however, it is wrapped
in a ConcurrentException, which is thrown. If the passed in
exception is null or has no cause, the method simply returns
without throwing an exception.ex - the exception to be handledConcurrentException - if the cause of the ExecutionException is a checked exceptionpublic static void handleCauseUnchecked(ExecutionException ex)
ExecutionException and transforms it into a
runtime exception. This method works exactly like
handleCause(ExecutionException), but instead of a
ConcurrentException it throws a
ConcurrentRuntimeException. This is an alternative for client
code that does not want to deal with checked exceptions.ex - the exception to be handledConcurrentRuntimeException - if the cause of the ExecutionException is a checked exception; this exception is then
wrapped in the thrown runtime exceptionpublic static <T> T initialize(ConcurrentInitializer<T> initializer) throws ConcurrentException
ConcurrentInitializer and returns the
object produced by the initializer. This method just invokes the get() method of the given ConcurrentInitializer. It is
null-safe: if the argument is null, result is also
null.T - the type of the object produced by the initializerinitializer - the ConcurrentInitializer to be invokedConcurrentInitializerConcurrentException - if the ConcurrentInitializer throws
an exceptionpublic static <T> T initializeUnchecked(ConcurrentInitializer<T> initializer)
ConcurrentInitializer and transforms
occurring exceptions to runtime exceptions. This method works like
initialize(ConcurrentInitializer), but if the ConcurrentInitializer throws a ConcurrentException, it is
caught, and the cause is wrapped in a ConcurrentRuntimeException.
So client code does not have to deal with checked exceptions.T - the type of the object produced by the initializerinitializer - the ConcurrentInitializer to be invokedConcurrentInitializerConcurrentRuntimeException - if the initializer throws an exceptionpublic static <K,V> V putIfAbsent(ConcurrentMap<K,V> map, K key, V value)
Puts a value in the specified ConcurrentMap if the key is not yet
present. This method works similar to the putIfAbsent() method of
the ConcurrentMap interface, but the value returned is different.
Basically, this method is equivalent to the following code fragment:
if (!map.containsKey(key)) {
map.put(key, value);
return value;
} else {
return map.get(key);
}
except that the action is performed atomically. So this method always returns the value which is stored in the map.
This method is null-safe: It accepts a null map as input without throwing an exception. In this case the return value is null, too.
K - the type of the keys of the mapV - the type of the values of the mapmap - the map to be modifiedkey - the key of the value to be addedvalue - the value to be addedpublic static <K,V> V createIfAbsent(ConcurrentMap<K,V> map, K key, ConcurrentInitializer<V> init) throws ConcurrentException
get() method of the passed in ConcurrentInitializer
is called. With the resulting object
putIfAbsent(ConcurrentMap, Object, Object) is called. This
handles the case that in the meantime another thread has added the key to
the map. Both the map and the initializer can be null; in this
case this method simply returns null.K - the type of the keys of the mapV - the type of the values of the mapmap - the map to be modifiedkey - the key of the value to be addedinit - the ConcurrentInitializer for creating the valueConcurrentInitializerConcurrentException - if the initializer throws an exceptionpublic static <K,V> V createIfAbsentUnchecked(ConcurrentMap<K,V> map, K key, ConcurrentInitializer<V> init)
createIfAbsent(). If a ConcurrentException is thrown, it
is caught and re-thrown as a ConcurrentRuntimeException.K - the type of the keys of the mapV - the type of the values of the mapmap - the map to be modifiedkey - the key of the value to be addedinit - the ConcurrentInitializer for creating the valueConcurrentInitializerConcurrentRuntimeException - if the initializer throws an exceptionpublic static <T> Future<T> constantFuture(T value)
Gets an implementation of Future that is immediately done
and returns the specified constant value.
This can be useful to return a simple constant immediately from the concurrent processing, perhaps as part of avoiding nulls. A constant future can also be useful in testing.
T - the type of the value used by this Future objectvalue - the constant value to return, may be nullCopyright © 2001–2018 The Apache Software Foundation. All rights reserved.