Package Summary Overview Summary

### class:ThreadLocal [NONE]
Type Parameters: `T` - the type of the thread local's value Direct Known Subclasses: `InheritableThreadLocal` public class ThreadLocal<T>extends Object This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its `get` or `set` method) has its own, independently initialized copy of the variable. `ThreadLocal` instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID). For example, the class below generates unique identifiers local to each thread. A thread's id is assigned the first time it invokes `ThreadId.get()` and remains unchanged on subsequent calls.
     import java.util.concurrent.atomic.AtomicInteger;

     public class ThreadId {
         // Atomic integer containing the next thread ID to be assigned
         private static final AtomicInteger nextId = new AtomicInteger(0);

         // Thread local variable containing each thread's ID
         private static final ThreadLocal<Integer> threadId =
             new ThreadLocal<Integer>() {
                 @Override protected Integer initialValue() {
                     return nextId.getAndIncrement();
             }
         };

         // Returns the current thread's unique ID, assigning it if necessary
         public static int get() {
             return threadId.get();
         }
     }
Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the `ThreadLocal` instance is accessible; after a thread goes away, all of its copies of thread-local instances are subject to garbage collection (unless other references to these copies exist). Since: 1.2

### constructor:ThreadLocal() [NONE]
### ThreadLocal public ThreadLocal() Creates a thread local variable. See Also: `withInitial(java.util.function.Supplier)`

### method:initialValue() [NONE]
### initialValue protected T initialValue() Returns the current thread's "initial value" for this thread-local variable. This method will be invoked the first time a thread accesses the variable with the `get()` method, unless the thread previously invoked the `set(T)` method, in which case the `initialValue` method will not be invoked for the thread. Normally, this method is invoked at most once per thread, but it may be invoked again in case of subsequent invocations of `remove()` followed by `get()`. This implementation simply returns `null`; if the programmer desires thread-local variables to have an initial value other than `null`, `ThreadLocal` must be subclassed, and this method overridden. Typically, an anonymous inner class will be used. Returns: the initial value for this thread-local

### method:withInitial(java.util.function.Supplier) [NONE]
### withInitial public static <S> ThreadLocal<S> withInitial (Supplier<? extends S> supplier) Creates a thread local variable. The initial value of the variable is determined by invoking the `get` method on the `Supplier`. Type Parameters: `S` - the type of the thread local's value Parameters: `supplier` - the supplier to be used to determine the initial value Returns: a new thread local variable Throws: `NullPointerException` - if the specified supplier is null Since: 1.8

### method:get() [NONE]
### get public T get() Returns the value in the current thread's copy of this thread-local variable. If the variable has no value for the current thread, it is first initialized to the value returned by an invocation of the `initialValue()` method. If the current thread does not support thread locals then this method returns its `initialValue()` (or `null` if the `initialValue` method is not overridden). Returns: the current thread's value of this thread-local See Also: `Thread.Builder.allowSetThreadLocals(boolean)`PREVIEW ### set public void set (T value) Sets the current thread's copy of this thread-local variable to the specified value. Most subclasses will have no need to override this method, relying solely on the `initialValue()` method to set the values of thread-locals. Parameters: `value` - the value to be stored in the current thread's copy of this thread-local. Throws: `UnsupportedOperationException` - if the current thread is not allowed to set its copy of thread-local variables See Also: `Thread.Builder.allowSetThreadLocals(boolean)`PREVIEW

### method:remove() [NONE]
### remove public void remove() Removes the current thread's value for this thread-local variable. If this thread-local variable is subsequently read by the current thread, its value will be reinitialized by invoking its `initialValue()` method, unless its value is set by the current thread in the interim. This may result in multiple invocations of the `initialValue` method in the current thread. Since: 1.5