ClassValue

public abstract class ClassValue
extends Object

java.lang.Object
↳	java.lang.ClassValue<T>

Lazily associate a computed value with (potentially) every type. For example, if a dynamic language needs to construct a message dispatch table for each class encountered at a message send call site, it can use a ClassValue to cache information needed to perform the message send quickly, for each class encountered.

Summary

Protected constructors
`ClassValue()` Sole constructor.

Public methods
`T`	`get(Class<?> type)` Returns the value for the given class.
`void`	`remove(Class<?> type)` Removes the associated value for the given class.

Protected methods
`abstract T`	`computeValue(Class<?> type)` Computes the given class's derived value for this `ClassValue`.

Inherited methods

From class


        
          java.lang.Object

`Object`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>`	`getClass()` Returns the runtime class of this `Object`.
`int`	`hashCode()` Returns a hash code value for the object.
`final void`	`notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void`	`notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String`	`toString()` Returns a string representation of the object.
`final void`	`wait(long timeoutMillis, int nanos)` Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`	`wait(long timeoutMillis)` Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`	`wait()` Causes the current thread to wait until it is awakened, typically by being notified or interrupted.

Protected constructors

ClassValue

Added in API level 34

protected ClassValue ()

Sole constructor. (For invocation by subclass constructors, typically implicit.)

Public methods

get

Added in API level 34

public T get (Class<?> type)

Returns the value for the given class. If no value has yet been computed, it is obtained by an invocation of the computeValue method.

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.

Parameters
`type`	`Class`: the type whose class value must be computed or retrieved

Returns
`T`	the current value associated with this `ClassValue`, for the given class or interface

Throws
`NullPointerException`	if the argument is null

See also:

remove

Added in API level 34

public void remove (Class<?> type)

Removes the associated value for the given class. If this value is subsequently read for the same class, its value will be reinitialized by invoking its computeValue method. This may result in an additional invocation of the computeValue method for the given class.

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:

T calls CV.get(C) and sees state 2N
T quickly computes a time-dependent value V0 and gets ready to install it
T is hit by an unlucky paging or scheduling event, and goes to sleep for a long time
...meanwhile, T2 also calls CV.get(C) and sees state 2N
T2 quickly computes a similar time-dependent value V1 and installs it on CV.get(C)
T2 (or a third thread) then calls CV.remove(C), undoing T2's work
the previous actions of T2 are repeated several times
also, the relevant computed values change over time: V1, V2, ...
...meanwhile, T wakes up and attempts to install V0; this must fail

We can assume in the above scenario that CV.computeValue uses 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 computeValue in T and the installation of the new value. No user synchronization is possible during this time.

Parameters
`type`	`Class`: the type whose class value must be removed

Throws
`NullPointerException`	if the argument is null

Protected methods

computeValue

Added in API level 34

protected abstract T computeValue (Class<?> type)

Computes the given class's derived value for this ClassValue.

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.

Parameters
`type`	`Class`: the type whose class value must be computed

Returns
`T`	the newly computed value associated with this `ClassValue`, for the given class or interface

See also:

get(Class)
remove(Class)