Detaillierte Erläuterung von InheritableThreadLocal im Java-Multithreading

In diesem Artikel wird hauptsächlich InheritableThreadLocal in der Java-Multithread-Programmierung ausführlich vorgestellt, das einen gewissen Referenzwert hat. Interessierte Freunde können sich auf

Die Rolle von InheritableThreadLocal: Wenn wir Sub-Threads verwenden müssen Wert im übergeordneten Thread angeben, können wir InheritableThreadLocal wie ThreadLocal verwenden.

Werfen wir zunächst einen Blick auf den JDK-Quellcode von 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);
  }
}

Dieser Code ist der vollständige Quellcode von InheritableThreadLocal (ein langer Kommentar wurde gelöscht).

Zuerst können wir sehen, dass es die ThreadLocal-Klasse erbt und dann Folgendes bereitstellt:

protected T childValue(T parentValue){} Methode, dies ist der Schlüssel zu InheritableThreadLocal Daher wird diese Methode bereitgestellt, um den Wert im übergeordneten Thread zurückzugeben. Wenn Sie auch einen Wert im übergeordneten Thread hinzufügen müssen, können Sie die Methode childValue überschreiben.

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();
    }
  }
}

Ausgabe ausführen:

Haupt-Thread-Medianwert: 1508210392057
Haupt-Thread-Medianwert: 1508210392057
Haupt-Thread-Medianwert 1508210392057 Haupt-Thread-Wert: 1508210392057
Haupt-Thread-Medianwert: 1508210392057
Haupt-Thread-Medianwert: 1508210392057
In Thread A: 1508210392057 Änderung des geerbten Werts
In Thread A: 1508210392057 Änderung des geerbten Werts
In Thread In A: 1508210 392057 Ändert den geerbten Wert
In Thread A: 1508210392057 Ändert den geerbten Wert
In Thread A: 1508210392057 Ändert den geerbten Wert
In Thread A: 1508210392057 Ändert den geerbten Wert Änderung
In Thread A: 1508210392057 Änderung von. inherit Ed-Wert
In Thread A: 1508210392057 Änderung des geerbten Werts
In Thread A: 1508210392057 Änderung des geerbten Werts
In Thread A: 1508210392057 Änderung des geerbten Werts


Haben Sie eine Frage, warum kann das Untergeordneter Thread erhält die Daten des übergeordneten Threads?


Wir können sehen, dass InheritableThreadLocal die getMap-Methode und die createMap-Methode neu schreibt. Als wir im vorherigen Abschnitt über ThreadLocal gesprochen haben, wussten wir, dass der Wert von ThreadLocal in einer Variablen namens ThreadLocals gespeichert ist, aber jetzt ist es so gibt einen InheritableThreadLocals zurück. Diese Variable ist genau die gleiche wie ThreadLocals, aber der Name wurde geändert. Warum kann ich den Wert also immer noch über die Methode threadlocal.get() in einem neuen Thread abrufen?

Wenn wir uns die Methode childValue ansehen, können wir vermuten, dass beim Erstellen des Threads möglicherweise einige Tricks durchgeführt wurden und einige Werte übergeben wurden.

Wenn wir den Quellcode der Thread-Klasse öffnen, finden wir:

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; 🎜>

Wenn wir also einen untergeordneten Thread erstellen, hat dieser eine InheritableThreadLocal-Variable, die mit ThreadLocals identisch ist:

Der entscheidende Punkt ist der folgende Codeausschnitt:

Weiterlesen:

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

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

Mit diesem Code erhalten wir zunächst den Wert des übergeordneten Threads (d. h. des aktuell ausgeführten Threads) und verwenden dann eine for-Schleife, um die Werte im übergeordneten Thread einzufügen unsere neu geschaffenen Werte nacheinander.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von InheritableThreadLocal im Java-Multithreading. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!