Brief introduction to ThreadLocal class

ThreadLocal Construction method of

    public ThreadLocal() {
    
    }

set

    public void set(T value) {
    
        Thread t = Thread.currentThread();// Current thread 
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);//this==》 At present threadLocal object ;
        else
            createMap(t, value);
    }

Why? ThreadLocal It can save the private variables of each thread ？
        because ThreadLocal Just equivalent to a tool key, In fact, the value is stored in the current thread ; Above set In the method , First, get the current thread t , And then use it getMap(t) , From the current thread t in , Get ThreadLocalMap object threadLocals; And then ThreadLocal Objects and value Value to key-val The form is preserved in ThreadLocalMap Of Entry in ;

get

    public T get() {
    
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
    
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
    
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

get The process ：

• 1. Get the current thread
• 2. Through the current thread , Get ThreadLocalMap The object of ：threadLocals
• 3. from threadLocals Get in object ThreadLocal object , Find value ：value;

ThreadLocalMap

set When it's worth it , In fact, what really saves value is ThreadLocalMap object ;
We can look at it ThreadLocalMap Source code ：

        static class Entry extends WeakReference<ThreadLocal<?>> {
    
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
    
                super(k);
                value = v;
            }
        }

               
        /**  Initialize capacity size */
        private static final int INITIAL_CAPACITY = 16;
      	/**  Store entry Of table, And before HashMap Medium entry Different */
        private Entry[] table;
        /**  Already stored entry Number */
        private int size = 0;
       /** table Threshold of capacity enlargement */
        private int threshold; 
     
     
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

ThreadLocalMap In the structure of 2 A key structure ：

• Entry object , preservation ThreadLocal Object and variable values ：value
• table Array , What's stored is Entry object ;

ThreadLocalMap Although it's called map, But with common HashMap Dissimilarity , Its structure is not ： Array + Linked list / Array + Linked list + Red and black trees ;
It's just a table Array ; The objects stored in the array are Entry,Entry It's a key-value Structure ;

test

We know ThreadLocal Stored value ThreadLocalMap Is an array , Therefore, one thread can add multiple ThreadLocal object ;

        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        ThreadLocal<String> threadLocal2 = new ThreadLocal<>();
        Thread t1 = new Thread(()->{
    
        threadLocal.set("1");
        threadLocal2.set("threadLocal2 var2. ,,,,,,")
            System.out.println("t1:"+threadLocal.get()+";threadLocal2 :"+threadLocal2 .get());});
            
        Thread t2 = new Thread(()->{
    threadLocal.set("2");
            System.out.println("t2:"+threadLocal.get());});
            
        Thread t3 = new Thread(()->{
    threadLocal.set("3");
            System.out.println("t3:"+threadLocal.get());});
        t1.start();
        t2.start();
        t3.start();

Each thread can be based on its own situation , add to ThreadLocal Variable ; If there is 2 Variables need to be stored separately by threads , You can add 2 individual ThreadLocal object ; Can also be 2 Variables are packaged into a class , You only need one ThreadLocal It's OK to store ;

For example, when the browser requests the server , Each request corresponds to a request Object and a response object ; There is 2 There are ways to store

	 Mode one ：
    ThreadLocal<Request > request  = new ThreadLocal<>();
    ThreadLocal<Response > response = new ThreadLocal<>();

     Mode two ： Pack it up session class 
    public class Session{
    
    	Request  request  ;
    	Response response ;
    }
    ThreadLocal<Session> session= new ThreadLocal<>();