Interviewer: what are the usage scenarios of ThreadLocal? How to avoid memory leakage?

ThreadLocal What are the use scenarios ？

Thread There are two variables in the class threadLocals and inheritableThreadLocals, Both ThreadLocal Inner class ThreadLocalMap Variable of type , We look inside ThreadLocalMap It can be found that it is actually similar to a HashMap. By default , These two variables in each thread are null:

ThreadLocal.ThreadLocalMap threadLocals = null;ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

Only when the thread first calls ThreadLocal Of set perhaps get Methods before they are created .

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();}    ThreadLocalMap getMap(Thread t) {        return t.threadLocals;}

besides , The local variables of each thread are not stored in ThreadLocal In the example , Instead, it is placed on the of the calling thread ThreadLocals In variables . in other words ,ThreadLocal Local variables of type are stored in specific thread space , It itself is equivalent to a carrier for loading local variables , adopt set Methods will value Added to the calling thread threadLocals in , When the calling thread calls get Methods can be learned from its threadLocals Take variables out of . If the calling thread never terminates , Then this local variable will always be stored in his threadLocals in , So when you don't use local variables, you need to call remove Methods will threadLocals Delete unused local variables , Prevent memory leaks .

public void set(T value) {        Thread t = Thread.currentThread();        ThreadLocalMap map = getMap(t);        if (map != null)            map.set(this, value);        else            createMap(t, value);}public void remove() {         ThreadLocalMap m = getMap(Thread.currentThread());         if (m != null)             m.remove(this);}

ThreadLocal How to avoid memory leakage ？

Every Thread There is one.
ThreadLocal.ThreadLocalMap Of map, The map Of key by ThreadLocal example , It's a weak reference , We know that weak citation is good for GC Recycling . When ThreadLocal Of key == null when ,GC It's going to reclaim that space , however value But it doesn't have to be recycled , Because he's still with Current Thread There is a strong reference relationship , as follows

Because of this strong reference relationship , It can lead to value It can't be recycled . If the thread object is not destroyed, the strong reference relationship will always exist , There will be a memory leak . So as long as this thread object can be used in time GC Recycling , There will be no memory leaks . If you run into a thread pool , That's even worse . So how to avoid this problem ？ I mentioned earlier , stay ThreadLocalMap Medium setEntry()、getEntry(), If you encounter key == null The situation of , Would be right value Set to null. Of course, we can also display the call ThreadLocal Of remove() Methods to deal with . Let's do it again ThreadLocal Make a brief summary ：

• ThreadLocal Not to solve the problem of shared variables , It doesn't exist to coordinate thread synchronization , It is a mechanism introduced to facilitate each thread to handle its own state . This is crucial .
• Every Thread There's one inside ThreadLocal.ThreadLocalMap A member variable of type , This member variable is used to store the actual ThreadLocal Copies of variables .
• ThreadLocal Instead of saving a copy of the object for the thread , It only serves as an index . It mainly isolates an instance of a class for each thread , The scope of this instance is only within the thread .