java.lang.ClassValue<T>
|
FlexDoc/Javadoc 2.0 Demo Java Doc |
|||||||||||||||
java.lang.ClassValue<T>Constructor Summary |
||
protected |
Sole constructor.
|
|
Method Summary |
||
protected abstract T |
computeValue(Class<?> type)
Computes the given class's derived value for this ClassValue.
|
|
|
Returns the value for the given class.
|
||
void |
Removes the associated value for the given class.
|
|
Methods inherited from class java.lang.Object |
protected ClassValue |
() |
protected abstract T computeValue |
(Class<?> type) |
This method will be invoked within the first thread that accesses the value with the get method.
Normally, this method is invoked at most once per class, but it may be invoked again if there has been a call to remove.
If this method throws an exception, the corresponding call to get will terminate abnormally with that exception, and no class value will be recorded.
public T get |
(Class<?> type) |
The actual installation of the value on the class is performed atomically. At that point, if several racing threads have computed values, one is chosen, and returned to all the racing threads.
The type parameter is typically a class, but it may be any type, such as an interface, a primitive type (like int.class), or void.class.
In the absence of remove calls, a class value has a simple state diagram: uninitialized and initialized. When remove calls are made, the rules for value observation are more complex. See the documentation for remove for more information.
public void remove |
(Class<?> type) |
In order to explain the interaction between get and remove calls, we must model the state transitions of a class value to take into account the alternation between uninitialized and initialized states. To do this, number these states sequentially from zero, and note that uninitialized (or removed) states are numbered with even numbers, while initialized (or re-initialized) states have odd numbers.
When a thread T removes a class value in state 2N, nothing happens, since the class value is already uninitialized. Otherwise, the state is advanced atomically to 2N+1.
When a thread T queries a class value in state 2N, the thread first attempts to initialize the class value to state 2N+1 by invoking computeValue and installing the resulting value.
When T attempts to install the newly computed value, if the state is still at 2N, the class value will be initialized with the computed value, advancing it to state 2N+1.
Otherwise, whether the new state is even or odd, T will discard the newly computed value and retry the get operation.
Discarding and retrying is an important proviso, since otherwise T could potentially install a disastrously stale value. For example:
|
FlexDoc/Javadoc 2.0 Demo Java Doc |
|||||||||||||||