Detailed explanation of InheritableThreadLocal in Java multithreading

This article mainly introduces the InheritableThreadLocal of java multi-thread programming in detail, which has certain reference value. Interested friends can refer to the role of

InheritableThreadLocal: When we need to use it in a child thread When using the value in the parent thread, we can use InheritableThreadLocal like ThreadLocal.

First let's take a look at the jdk source code of InheritableThreadLocal:

package java.lang;
import java.lang.ref.*;

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
  protected T childValue(T parentValue) {
    return parentValue;
  }

  ThreadLocalMap getMap(Thread t) {
    return t.inheritableThreadLocals;
  }

  void createMap(Thread t, T firstValue) {
    t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
  }
}

This code is the complete source code of InheritableThreadLocal (the long comment has been deleted ).

First we can see that it inherits the ThreadLocal class, and then provides:

protected T childValue(T parentValue){} method, this is the key to InheritableThreadLocal Therefore, it provides this method to return the value in the parent thread. If you also need to add a value on the parent thread, you can override the childValue method.

package InheritableThreadLocal;

import java.util.Date;

public class InheritableThreadLocaExt extends InheritableThreadLocal{
  protected Object initialValue() {
    return new Date().getTime();

  }
  protected Object childValue(Object parentValue) {
    return parentValue+"对继承值进行修改";

  }

}

package InheritableThreadLocal;

public class tool {
  public static InheritableThreadLocaExt t=new InheritableThreadLocaExt();

}

package InheritableThreadLocal;

public class MyThread extends Thread{

  public void run() {
      try {
        for(int i=0;i<10;i++) {
          System.out.println("在线程A中："+tool.t.get());
        sleep(100);
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }  
}

package InheritableThreadLocal;

public class test {
  public static void main(String[] args) {
    try {
      for(int i=0;i<10;i++) {
        System.out.println("主线程中值："+tool.t.get());
        Thread.sleep(100);
      }
      Thread.sleep(5000);
      MyThread thread=new MyThread();
      thread.start();

    }catch(InterruptedException e){
      e.printStackTrace();
    }
  }
}

Run output:

Main thread median: 1508210392057
Main thread median: 1508210392057
Main thread median :1508210392057
Main thread median value: 1508210392057
Main thread median value: 1508210392057
Main thread median value: 1508210392057
Main thread median value: 1508210392057
Main thread median value: 1508210392057
Main thread median value: 1508210392057
Main thread median value: 1508210392057
In thread A: 1508210392057 Modify the inherited value
In thread A: 1508210392057 Modify the inherited value
In thread A : 1508210392057 Modifies the inherited value
In thread A: 1508210392057 Modifies the inherited value
In thread A: 1508210392057 Modifies the inherited value
In thread A: 1508210392057 Modifies the inherited value
In thread A: 1508210392057 Modify the inherited value
In thread A: 1508210392057 Modify the inherited value
In thread A: 1508210392057 Modify the inherited value
In thread A: 1508210392057 Modify the inherited value

Do you have a question, why can the child thread obtain the data of the parent thread?

We can see that InheritableThreadLocal rewrites the getMap method and createMap method. When we talked about ThreadLocal in the previous section, we knew that the value of ThreadLocal is stored in a variable called ThreadLocals, but now it returns a InheritableThreadLocals, this variable is exactly the same as ThreadLocals but the name has been changed. So why can I still get the value through the threadlocal.get() method in a new thread?

Looking at the childValue method, we can guess that some tricks may have been done when the thread was created, and some values ​​were passed.

When we open the source code of the Thread class, we can find:

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

So when we create a child thread, it will have an InheritableThreadLocal variable that is the same as ThreadLocals. Look down:

private void init(ThreadGroup g, Runnable target, String name,
           long stackSize, AccessControlContext acc,
           .
           .
           if (inheritThreadLocals && parent.inheritableThreadLocals != null)
      this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

The key point is the following code :

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

Continue watching:

 static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);
  }

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++;
          }
        }
      }
    }

Yes This code first gets the value of the parent thread (that is, the currently executing thread), and then uses a for loop to put the values ​​in the parent thread into our newly created values ​​one by one.

The above is the detailed content of Detailed explanation of InheritableThreadLocal in Java multithreading. For more information, please follow other related articles on the PHP Chinese website!