public abstract class ClassValue<T> extends Object
ClassValueto cache information needed to perform the message send quickly, for each class encountered.
|Modifier||Constructor and Description|
|Modifier and Type||Method and Description|
Computes the given class's derived value for this
Returns the value for the given class.
Removes the associated value for the given class.
This method will be invoked within the first thread that accesses
the value with the
Normally, this method is invoked at most once per class,
but it may be invoked again if there has been a call to
If this method throws an exception, the corresponding call to
will terminate abnormally with that exception, and no class value will be recorded.
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.
type parameter is typically a class, but it may be any type,
such as an interface, a primitive type (like
In the absence of
remove calls, a class value has a simple
state diagram: uninitialized and initialized.
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)
computeValuemethod. This may result in an additional invocation of the
computeValuemethod for the given class.
In order to explain the interaction between
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
nothing happens, since the class value is already uninitialized.
Otherwise, the state is advanced atomically to
When a thread
T queries a class value in state
the thread first attempts to initialize the class value to state
computeValue and installing the resulting value.
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
Otherwise, whether the new state is even or odd,
T will discard the newly computed value
and retry the
Discarding and retrying is an important proviso,
T could potentially install
a disastrously stale value. For example:
CV.get(C)and sees state
Tquickly computes a time-dependent value
V0and gets ready to install it
Tis hit by an unlucky paging or scheduling event, and goes to sleep for a long time
CV.get(C)and sees state
T2quickly computes a similar time-dependent value
V1and installs it on
T2(or a third thread) then calls
T2are repeated several times
Twakes up and attempts to install
V0; this must fail
CV.computeValueuses locks to properly observe the time-dependent states as it computes
V1, etc. This does not remove the threat of a stale value, since there is a window of time between the return of
Tand the installation of the the new value. No user synchronization is possible during this time.
type- the type whose class value must be removed
NullPointerException- if the argument is null
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2023, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.