get() and set() methods)
* only affects the state of the object as seen by the currently
* executing Thread.
*
* The first time a ThreadLocal object is accessed on a particular
* Thread, the state for that Thread's copy of the local variable is set by
* executing the method initialValue().
*
*
An example how you can use this: *
* class Connection
* {
* private static ThreadLocal owner = new ThreadLocal()
* {
* public Object initialValue()
* {
* return("nobody");
* }
* };
* ...
* }
*
*
* Now all instances of connection can see who the owner of the currently
* executing Thread is by calling owner.get(). By default any
* Thread would be associated with 'nobody'. But the Connection object could
* offer a method that changes the owner associated with the Thread on
* which the method was called by calling owner.put("somebody").
* (Such an owner changing method should then be guarded by security checks.)
*
* When a Thread is garbage collected all references to values of
* the ThreadLocal objects associated with that Thread are removed.
*
* @author Mark Wielaard set(Thread, Object) and get(Thread) methods
* access it. Package visible for use by InheritableThreadLocal.
*/
final Map valueMap = Collections.synchronizedMap(new WeakHashMap());
/**
* Creates a ThreadLocal object without associating any value to it yet.
*/
public ThreadLocal()
{
}
/**
* Called once per thread on the first invocation of get(), if set() was
* not already called. The default implementation returns null.
* Often, this method is overridden to create the appropriate initial object
* for the current thread's view of the ThreadLocal.
*
* @return the initial value of the variable in this thread
*/
protected Object initialValue()
{
return null;
}
/**
* Gets the value associated with the ThreadLocal object for the currently
* executing Thread. If this is the first time the current thread has called
* get(), and it has not already called set(), the value is obtained by
* initialValue().
*
* @return the value of the variable in this thread
*/
public Object get()
{
Thread currentThread = Thread.currentThread();
// Note that we don't have to synchronize, as only this thread will
// ever modify the returned value and valueMap is a synchronizedMap.
Object value = valueMap.get(currentThread);
if (value == null)
{
value = initialValue();
valueMap.put(currentThread, value == null ? NULL : value);
}
return value == NULL ? null : value;
}
/**
* Sets the value associated with the ThreadLocal object for the currently
* executing Thread. This overrides any existing value associated with the
* current Thread and prevents initialValue() from being
* called if this is the first access to this ThreadLocal in this Thread.
*
* @param value the value to set this thread's view of the variable to
*/
public void set(Object value)
{
// Note that we don't have to synchronize, as only this thread will
// ever modify the returned value and valueMap is a synchronizedMap.
valueMap.put(Thread.currentThread(), value == null ? NULL : value);
}
}