Shulou(Shulou.com)06/02 Report--

In this issue, the editor will bring you about how to analyze InheritableThreadLocal. The article is rich in content and analyzes and narrates it from a professional point of view. I hope you can get something after reading this article.

InheritableThreadLocal inherits from ThreadLocal and overrides the childValue, getMap, createMap methods. The main function is that the child thread can read the variables of the parent thread. Look at this class.

Public class InheritableThreadLocal extends ThreadLocal {protected T childValue (T parentValue) {return parentValue;} / / returns the inheritableThreadLocals of the Thread class, while ThreadLocal uses the threadLocals variable ThreadLocalMap getMap (Thread t) {return t firstValue;} void createMap (Thread t, T ThreadLocals) {t.inheritableThreadLocals = new ThreadLocalMap (this, firstValue);}}

Example:

Public class InheritableThreadLocalTest {private static final InheritableThreadLocal threadLocal = new InheritableThreadLocal (); public static void main (String [] args) throws InterruptedException {threadLocal.set ("hello world"); Thread thread = new Thread (new Runnable () {@ Override public void run () {/ / threadLocal.set ("son thread"); System.out.println ("thread:" + threadLocal.get ()) }); thread.start (); thread.join (); System.out.println ("main:" + threadLocal.get ());}}

Output:

Thread:hello worldmain:hello world

What happens here if I set a new value in the child thread? Found that the value of the parent thread did not change

Analysis of thread:son threadmain:hello world Source Code

First of all, start with the newly created child thread. Here, the main thing is to copy the value of the parent thread to the child thread.

/ / Constructor public Thread (Runnable target) {init (null, target, "Thread-" + nextThreadNum (), 0);} / / skip directly to the final init method private void init (ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc, boolean inheritThreadLocals) {if (name = = null) {throw new NullPointerException ("name cannot be null");} this.name = name Thread parent = currentThread (); SecurityManager security = System.getSecurityManager (); / / Omit the middle part and look at the main / / get the inheritableThreadLocals variable of the parent thread. If it is not empty, the variable in the copy parent thread is changed to the child thread if (inheritThreadLocals & & parent.inheritableThreadLocals! = null) this.inheritableThreadLocals = ThreadLocal.createInheritedMap (parent.inheritableThreadLocals); / * Stash the specified stack size in case the VM cares * / this.stackSize = stackSize; / * Set thread ID * / tid = nextThreadID () } / / ThreadLocal.createInheritedMap method static ThreadLocalMap createInheritedMap (ThreadLocalMap parentMap) {return new ThreadLocalMap (parentMap);} / / ThreadLocalMap (parentMap) method private ThreadLocalMap (ThreadLocalMap parentMap) {Entry [] parentTable = parentMap.table; int len = parentTable.length; setThreshold (len) / / create a new Entry array. Entry inherits WeakReference,key to ThreadLocal type / / this is to facilitate GC to collect invalid data table = new Entry [len]; for (int j = 0; j < len; jacks +) {Entry e = parentTable [j] when there is a large amount of data If (e! = null) {@ SuppressWarnings ("unchecked") ThreadLocal key = (ThreadLocal) e.get (); if (key! = null) {/ / InheritableThreadLocal rewrites childValue and returns the value Object value = key.childValue (e.value); Entry c = new Entry (key, value) / / calculate the array index position, using "linear detection" int h = key.threadLocalHashCode & (len-1); / / if the current position has a value, the pointer needs to be moved to the next position until it finds the position that is not null while (table [h]! = null) h = nextIndex (h, len) Table [h] = c; size++;}

The child thread gets the parent thread value analysis, see the get method of ThreadLocal

Public T get () {Thread t = Thread.currentThread (); / / actually call the getMap method of the InheritableThreadLocal class. GetMap returns the inheritableThreadLocals variable of the current thread / / each thread has it, and is the local variable of the Thread class ThreadLocalMap map = getMap (t). / / if null initializes a ThreadLocalMap if whose value is null (map! = null) {/ / this is the InheritableThreadLocal class, take a look at the getEntry method ThreadLocalMap.Entry e = map.getEntry (this); if (e! = null) {@ SuppressWarnings ("unchecked") T result = (T) e.value; return result;}} return setInitialValue () } / / this is to get the corresponding value of the index from the table array. This table has already copy the data of the parent thread private Entry getEntry (ThreadLocal key) {int I = key.threadLocalHashCode & (table.length-1); Entry e = table [I]; if (e! = null & & e.get () = key) return e Else / / if the condition is not true, it loops the entire table and processes the data with key failure / / if it is not found after traversal, it returns null return getEntryAfterMiss (key, I, e);} Summary

The child thread can read the parent thread data. The actual reason is that when the child thread is created, the data will be copy from the parent thread.

InheritableThreadLocal inherits ThreadLocal and rewrites childValue, getMap, createMap. The operation on this class is actually on thread ThreadLocalMap.

The above is the editor for you to share how to analyze InheritableThreadLocal, if you happen to have similar doubts, you might as well refer to the above analysis to understand. If you want to know more about it, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.