Detailed explanation of ThreadLocal

One 、ThreadLocal

1、 explain

ThreadLocal Is a thread local variable . In fact, its function is very simple , That is to provide a copy of the variable value for each thread that uses the variable , yes Java A special thread binding mechanism in , Each thread can change its own copy independently , It doesn't conflict with copies of other threads .

2、 Usage method

ThreadLocal<String> nameThreadLocal = new ThreadLocal<>();
nameThreadLocal.set(name);
nameThreadLocal.get();

3、Request Use cases

stay springMvc In a single case controller Define member variables in request , Use @autowired When the injection ,request Is the use of ThreadLocal Thread safe .

1. stay controller In the injection request yes jdk Dynamic proxy object ,ObjectFactoryDelegatingInvocationHandler Example . When we call the member domain request The method of is actually called objectFactory Of getObject() object . there objectFactory yes RequestObjectFactory.
2. RequestObjectFactory Of getObject In fact, from RequestContextHolder Of threadlocal Removed from .
3. Request just entered springmvc Of dispatcherServlet I will put request Related objects are set to RequestContextHolder Of threadlocal In the middle .

Reference resources ： stay SpringMVC Controller In the injection Request Member domain - abcwt112 - Blog Garden

4、 Reference resources

ThreadLocal Detailed explanation

https://www.jianshu.com/p/3bb70ae81828

Two 、InheritableThreadLocal

1、 explain

ThreadLocal It is designed to bind the current thread , If you want the current thread ThreadLocal Can be used by child threads , The implementation will be quite difficult （ The user needs to pass... In the code himself ）. In this context ,InheritableThreadLocal emerge as the times require .

2、 principle

When creating a new thread , The following constructor will be called .

    public Thread(Runnable target) {
    
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

We follow the init Method , You can find such a piece of code . It was created here inheritableThreadLocals .

        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

Keep looking at createInheritedMap Method , There is a new one ThreadLocalMap object , Its construction method is as follows .

Analyzing the code, we know , When creating a child thread , Will be the parent thread of inheritableThreadLocals Copy to sub thread inheritableThreadLocals object .

        private ThreadLocalMap(ThreadLocalMap parentMap) {
    
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
    
                Entry e = parentTable[j];
                if (e != null) {
    
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
    
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

3、 Reference resources

InheritableThreadLocal Detailed explanation
https://www.jianshu.com/p/94ba4a918ff5

3、 ... and 、ThreadLocal Memory leak

https://blog.csdn.net/qq_25775675/article/details/105731434