# Print output for @column tags ?>
Developers

- Design
- Develop
- Distribute

Developer Console

## Most visited

## Recently visited

## Results for

Summary: Ctors | Methods | Protected Methods | Inherited Methods

# ThreadLocal

`public class ThreadLocal`
`extends Object` ``

java.lang.Object
↳ | java.lang.ThreadLocal<T>

Known direct subclasses InheritableThreadLocal<T>
InheritableThreadLocal<T> | This class extends `ThreadLocal` to provide inheritance of values from parent thread to child thread: when a child thread is created, the child receives initial values for all inheritable thread-local variables for which the parent has values.

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).

## Summary

### Public constructors
`ThreadLocal()` Creates a thread local variable.

### Public methods
`T` | `get()` Returns the value in the current thread's copy of this thread-local variable.
`void` | `remove()` Removes the current thread's value for this thread-local variable.
`void` | `set(T value)` Sets the current thread's copy of this thread-local variable to the specified value.
`static <S> ThreadLocal<S>` | `withInitial(Supplier<? extends S> supplier)` Creates a thread local variable.

### Protected methods
`T` | `initialValue()` Returns the current thread's "initial value" for this thread-local variable.

### 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 timeout, int nanos)` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
`final void` | `wait(long timeout)` Causes the current thread to wait until either another thread invokes the `notify()` method or the `notifyAll()` method for this object, or a specified amount of time has elapsed.
`final void` | `wait()` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object.

## Public constructors

### ThreadLocal

    public ThreadLocal ()

Creates a thread local variable.

See also:

- `withInitial(java.util.function.Supplier)`

## Public methods

### 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.

Returns
`T` | the current thread's value of this thread-local

### 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.

### 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` | `T`: the value to be stored in the current thread's copy of this thread-local.

### withInitial

    public static 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`.

Parameters
`supplier` | `Supplier`: the supplier to be used to determine the initial value

Returns
`ThreadLocal<S>` | a new thread local variable

Throws
`NullPointerException` | if the specified supplier is null

## Protected methods

### 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
`T` | the initial value for this thread-local

Full name *
Email address *
Company / developer name
One of your Play Store app URLs *
Which best describes your business:*
Apps
Games
Apps & Games
*
*