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  Futurethat 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  ExecutionExceptionand
 creates aConcurrentExceptionwith the checked cause if
 necessary. | 
| static ConcurrentRuntimeException | extractCauseUnchecked(ExecutionException ex)Inspects the cause of the specified  ExecutionExceptionand
 creates aConcurrentRuntimeExceptionwith the checked cause if
 necessary. | 
| static void | handleCause(ExecutionException ex)Handles the specified  ExecutionException. | 
| static void | handleCauseUnchecked(ExecutionException ex)Handles the specified  ExecutionExceptionand transforms it into a
 runtime exception. | 
| static <T> T | initialize(ConcurrentInitializer<T> initializer)Invokes the specified  ConcurrentInitializerand returns the
 object produced by the initializer. | 
| static <T> T | initializeUnchecked(ConcurrentInitializer<T> initializer)Invokes the specified  ConcurrentInitializerand 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  ConcurrentMapif 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–2016 The Apache Software Foundation. All rights reserved.