ThreadLocal

 1 public
 2 class Thread implements Runnable {
 3     /*...其他属性...*/
 4  
 5     /* ThreadLocal values pertaining to this thread. This map is maintained
 6      * by the ThreadLocal class. */
 7     ThreadLocal.ThreadLocalMap threadLocals = null;
 8  
 9     /*
10      * InheritableThreadLocal values pertaining to this thread. This map is
11      * maintained by the InheritableThreadLocal class.
12      */
13     ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

 1 public class ThreadLocal<T> {
 2     /**..其他属性和方法稍后介绍...*/
 3     /**
 4      * ThreadLocalMap is a customized hash map suitable only for
 5      * maintaining thread local values. No operations are exported
 6      * outside of the ThreadLocal class. The class is package private to
 7      * allow declaration of fields in class Thread.  To help deal with
 8      * very large and long-lived usages, the hash table entries use
 9      * WeakReferences for keys. However, since reference queues are not
10      * used, stale entries are guaranteed to be removed only when
11      * the table starts running out of space.
12      */
13     static class ThreadLocalMap {

 1     /**
 2      * Create the map associated with a ThreadLocal. Overridden in
 3      * InheritableThreadLocal.
 4      *
 5      * @param t the current thread
 6      * @param firstValue value for the initial entry of the map
 7      */
 8     void createMap(Thread t, T firstValue) {
 9         t.threadLocals = new ThreadLocalMap(this, firstValue);
10     }

  1    /**
  2      * Returns the current thread‘s "initial value" for this
  3      * thread-local variable.  This method will be invoked the first
  4      * time a thread accesses the variable with the {@link #get}
  5      * method, unless the thread previously invoked the {@link #set}
  6      * method, in which case the {@code initialValue} method will not
  7      * be invoked for the thread.  Normally, this method is invoked at
  8      * most once per thread, but it may be invoked again in case of
  9      * subsequent invocations of {@link #remove} followed by {@link #get}.
 10      *
 11      * <p>This implementation simply returns {@code null}; if the
 12      * programmer desires thread-local variables to have an initial
 13      * value other than {@code null}, {@code ThreadLocal} must be
 14      * subclassed, and this method overridden.  Typically, an
 15      * anonymous inner class will be used.
 16      *
 17      * @return the initial value for this thread-local
 18      */
 19     protected T initialValue() {
 20         return null;
 21     }
 22  
 23     /**
 24      * Creates a thread local variable. The initial value of the variable is
 25      * determined by invoking the {@code get} method on the {@code Supplier}.
 26      *
 27      * @param <S> the type of the thread local‘s value
 28      * @param supplier the supplier to be used to determine the initial value
 29      * @return a new thread local variable
 30      * @throws NullPointerException if the specified supplier is null
 31      * @since 1.8
 32      */
 33     public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
 34         return new SuppliedThreadLocal<>(supplier);
 35     }
 36  
 37     /**
 38      * Creates a thread local variable.
 39      * @see #withInitial(java.util.function.Supplier)
 40      */
 41     public ThreadLocal() {
 42     }
 43  
 44     /**
 45      * Returns the value in the current thread‘s copy of this
 46      * thread-local variable.  If the variable has no value for the
 47      * current thread, it is first initialized to the value returned
 48      * by an invocation of the {@link #initialValue} method.
 49      *
 50      * @return the current thread‘s value of this thread-local
 51      */
 52     public T get() {
 53         Thread t = Thread.currentThread();
 54         ThreadLocalMap map = getMap(t);
 55         if (map != null) {
 56             ThreadLocalMap.Entry e = map.getEntry(this);
 57             if (e != null) {
 58                 @SuppressWarnings("unchecked")
 59                 T result = (T)e.value;
 60                 return result;
 61             }
 62         }
 63         return setInitialValue();
 64     }
 65  
 66     /**
 67      * Variant of set() to establish initialValue. Used instead
 68      * of set() in case user has overridden the set() method.
 69      *
 70      * @return the initial value
 71      */
 72     private T setInitialValue() {
 73         T value = initialValue();
 74         Thread t = Thread.currentThread();
 75         ThreadLocalMap map = getMap(t);
 76         if (map != null)
 77             map.set(this, value);
 78         else
 79             createMap(t, value);
 80         return value;
 81     }
 82  
 83     /**
 84      * Sets the current thread‘s copy of this thread-local variable
 85      * to the specified value.  Most subclasses will have no need to
 86      * override this method, relying solely on the {@link #initialValue}
 87      * method to set the values of thread-locals.
 88      *
 89      * @param value the value to be stored in the current thread‘s copy of
 90      *        this thread-local.
 91      */
 92     public void set(T value) {
 93         Thread t = Thread.currentThread();
 94         ThreadLocalMap map = getMap(t);
 95         if (map != null)
 96             map.set(this, value);
 97         else
 98             createMap(t, value);
 99     }
100  
101     /**
102      * Removes the current thread‘s value for this thread-local
103      * variable.  If this thread-local variable is subsequently
104      * {@linkplain #get read} by the current thread, its value will be
105      * reinitialized by invoking its {@link #initialValue} method,
106      * unless its value is {@linkplain #set set} by the current thread
107      * in the interim.  This may result in multiple invocations of the
108      * {@code initialValue} method in the current thread.
109      *
110      * @since 1.5
111      */
112      public void remove() {
113          ThreadLocalMap m = getMap(Thread.currentThread());
114          if (m != null)
115              m.remove(this);
116      }

 1 import java.util.Random;
 2 
 3 public class testThreadLocal extends Thread{ 6     
 7     private static boolean flag;
 8     
 9     public void run()
10     {
11         Random random=new Random();
12         int a=random.nextInt(20);
13                 flag=flag(a);
14         System.out.println("其他线程"+a+"启动，flag="+flag);
15         }
16         
17     public static void main(String[] args) {    
18         flag=flag(3);
19         System.out.println("主线程启动，flag="+flag);
20     
21         for (int i = 0; i < 10; i++) {
22             new testThreadLocal().start();
23         }    
24     }
25     
26     public static boolean flag(int a){
27         if(a>4){
28             flag=true;
29             return flag;
30         }else {
31             return flag;
32         }
33     }
34 }
35         

 1 import java.util.Random;
 2 
 3 public class testThreadLocal extends Thread{
 4         public void run()
 5     {
 6         Random random=new Random();
 7         int a=random.nextInt(20);
 8         boolean flag=flag(a,false);
 9         System.out.println("其他线程"+a+"启动，flag="+flag);
10     }
11         public static void main(String[] args) {
12         
13         boolean flag=flag(3,false);
14         System.out.println("主线程启动，flag="+flag);
15     
16         for (int i = 0; i < 10; i++) {
17             new testThreadLocal().start();
18         }
19         
20     }
21     
22     public static boolean flag(int a，boolean flag){
23         if(a>4){
24             flag=true;
25             return flag;
26         }else {
27             return flag;
28         }
29     }
30 }

 1 import java.util.Random;
 2 
 3 public class testThreadLocal extends Thread{
 4     
 5     private static ThreadLocal<Boolean> tlflag=new ThreadLocal<>();
 6 
 7     public void run()
 8     {
 9         Random random=new Random();
10         int a=random.nextInt(20);
11         flag(a);
12         System.out.println("ThreadLocal形式，其他线程"+a+"启动，flag="+tlflag.get());
13     }
14     
15     public static void main(String[] args) {
16         
17         flag(3);
18         System.out.println("ThreadLocal形式，主线程启动，flag="+tlflag.get());
19         
20         for (int i = 0; i < 10; i++) {
21             new testThreadLocal().start();
22         }
23     }
24 
25         public static void flag(int a){
26         
27         if(a>4){
28             tlflag.set(true);
29         }else {
30             tlflag.set(false);
31         }
32     }
33 }