Comment utiliser la classe ThreadLocal en Java ?

A quoi sert Threadlocal :

Pour faire simple, un ThreadLocal est partagé dans un fil de discussion et peut être utilisé dans différents threads. Les threads sont isolés les uns des autres (chaque thread ne peut voir que la valeur de son propre thread). Comme indiqué ci-dessous :

Exemple d'utilisation de ThreadLocal

Introduction à l'API

Avant d'utiliser Threadlocal, nous Jetez d'abord un œil à son API ci-dessous :

L'API de la classe ThreadLocal est très simple. Les plus importantes ici sont get(), set(. ), Remove(), set est utilisé pour les opérations d'affectation, get est utilisé pour obtenir la valeur d'une variable et Remove consiste à supprimer la valeur de la variable actuelle. Il convient de noter que la méthode initialValue sera déclenchée lorsqu'elle l'est. appelé pour la première fois et est utilisé pour initialiser la valeur actuelle de la variable. Par défaut, initialValue renvoie null.

Utilisation de ThreadLocal

Maintenant que nous avons fini de parler de l'API de la classe ThreadLocal, pratiquons-la pour comprendre la phrase précédente : Un ThreadLocal est dans un fil C'est partagé et isolé entre différents threads (chaque thread ne peut voir que la valeur de son propre thread)

public class ThreadLocalTest {

    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
	// 重写这个方法，可以修改“线程变量”的初始值，默认是null
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    public static void main(String[] args) throws InterruptedException {

        //一号线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("一号线程set前：" + threadLocal.get());
                threadLocal.set(1);
                System.out.println("一号线程set后：" + threadLocal.get());
            }
        }).start();

        //二号线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("二号线程set前：" + threadLocal.get());
                threadLocal.set(2);
                System.out.println("二号线程set后：" + threadLocal.get());

            }
        }).start();

        //主线程睡1s
        Thread.sleep(1000);

        //主线程
        System.out.println("主线程的threadlocal值：" + threadLocal.get());

    }

}

Expliquez un peu le code ci-dessus :

#🎜🎜 #Chaque instance ThreadLocal est similaire à un Nom de la variable. Différentes instances de ThreadLocal sont des noms de variables différents. Il y aura une valeur à l'intérieur (compris de cette façon pour le moment), qui est appelée « variable ThreadLocal ou variable de thread » dans la description suivante. Représente une instance de la classe ThreadLocal. .

Créez une "variable ThreadLocal" statique dans la classe, créez deux threads dans le thread principal et définissez les variables ThreadLocal sur 1 et 2 dans ces deux threads respectivement. Attendez ensuite la fin de l'exécution des threads n°1 et 2 et vérifiez la valeur de la variable ThreadLocal dans le thread principal.

Résultats et analyse du programme⌛

L'objectif des résultats du programme est que la sortie du thread principal est 0. S'il s'agit de variables ordinaires, définissez les variables ordinaires sur 1 et 2 dans le thread n° 1 et le thread n° 2, puis imprimez cette variable une fois l'exécution des threads n° 1 et n° 2 terminée, la valeur de sortie doit être 1 ou 2 ( lequel est généré est déterminé par le système d'exploitation lié à la logique de planification des threads). Cependant, après avoir utilisé la variable ThreadLocal pour attribuer des valeurs via deux threads, la valeur initiale 0 est affichée dans le thread du thread principal. C'est pourquoi "un ThreadLocal est partagé dans un thread et isolé entre différents threads". Chaque thread ne peut voir que la valeur de son propre thread. C'est le rôle principal de ThreadLocal : implémenter des variables locales scoped pour les threads.

Analyse du code source de Threadlocal

Principe

Chaque objet Thread a un ThreadLocalMap Lorsqu'un ThreadLocal est créé, le ThreadLocal sera ajouté. à la carte, où la clé est ThreadLocal et la valeur peut être de n'importe quel type. Vous ne comprendrez peut-être pas très bien cette phrase lorsque vous la lirez pour la première fois, mais nous la comprendrons après avoir lu ensemble le code source.

Notre compréhension précédente était que toutes les valeurs constantes ou références de types référence sont stockées dans des instances ThreadLocal, mais en fait elles ne le sont pas. Cette instruction nous permet simplement de mieux comprendre ce concept de variables ThreadLocal. Le stockage d'une valeur dans ThreadLocal stocke en fait une valeur dans ThreadLocalMap dans l'objet thread actuel. ThreadLocalMap peut être simplement compris comme une carte, et la clé pour stocker une valeur dans cette carte est l'instance ThreadLocal elle-même.

Code source

???? En d'autres termes, les données dans ThreadLocal que vous souhaitez enregistrer ne sont pas réellement là Au lieu de l'enregistrer dans un objet ThreadLocal, il utilise cette instance de ThreadLocal comme clé pour l'enregistrer dans une Map dans le thread actuel. La même chose est vraie lors de l'obtention de la valeur de ThreadLocal. C'est pourquoi ThreadLocal peut réaliser une isolation entre les threads.

Classe interne ThreadLocalMap

ThreadLocalMap est une classe interne de ThreadLocal, qui implémente un ensemble de sa propre structure Map✨

Attributs ThreadLocalMap : #🎜 🎜#

static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        //初始容量16
        private static final int INITIAL_CAPACITY = 16;
        //散列表
        private Entry[] table;
        //entry 有效数量 
        private int size = 0;
        //负载因子
        private int threshold;

ThreadLocalMap définit la variable ThreadLocal

private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            
            //与运算  & (len-1) 这就是为什么 要求数组len 要求2的n次幂 
            //因为len减一后最后一个bit是1 与运算计算出来的数值下标 能保证全覆盖 
            //否者数组有效位会减半 
            //如果是hashmap 计算完下标后 会增加链表 或红黑树的查找计算量 
            int i = key.threadLocalHashCode & (len-1);
            
            // 从下标位置开始向后循环搜索  不会死循环  有扩容因子 必定有空余槽点
            for (Entry e = tab[i];   e != null;  e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                //一种情况 是当前引用 返回值
                if (k == key) {
                    e.value = value;
                    return;
                }
                //槽点被GC掉 重设状态 
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
			//槽点为空 设置value
            tab[i] = new Entry(key, value);
            //设置ThreadLocal数量
            int sz = ++size;
			
			//没有可清理的槽点 并且数量大于负载因子 rehash
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

ThreadLocalMap introduction de l'attribut ???? :

est stocké dans un tableau similaire à un Hashmap Within normal, mais contrairement à la méthode zipper utilisée par hashmap pour résoudre les conflits de hachage, ThreadLocalMap utilise la méthode d'adresse ouverte
La capacité initiale du tableau est de 16, et le facteur de charge est de 2/3#🎜🎜 #

• La clé du nœud node encapsule WeakReference pour le recyclage

• Emplacement de stockage ThreadLocalMap

Stockés dans Thread, il y a deux variables ThreadLocalMap

threadLocals sont créés dans l'ensemble de méthodes d'objet ThreadLocal et sont également gérés par ThreadLocal

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

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

# 🎜🎜#inheritableThreadLocals Semblable à ThreadLocal, InheritableThreadLocal remplace la méthode createMap

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

inheritableThreadLocals 作用是将ThreadLocalMap传递给子线程

init方法中 条件满足后直接为子线程创建ThreadLocalMap

注意：

• 仅在初始化子线程的时候会传递 中途改变副线程的inheritableThreadLocals 变量 不会将影响结果传递到子线程 。

• 使用线程池要注意 线程不回收 尽量避免使用父线程的inheritableThreadLocals 导致错误

Key的弱引用问题

为什么要用弱引用,官方是这样回答的

To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.

为了处理非常大和生命周期非常长的线程，哈希表使用弱引用作为 key。

生命周期长的线程可以理解为：线程池的核心线程

ThreadLocal在没有外部对象强引用时如Thread，发生GC时弱引用Key会被回收，而Value是强引用不会回收，如果创建ThreadLocal的线程一直持续运行如线程池中的线程，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。

• key 使用强引用????： 引用的ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。

• key 使用弱引用????： 引用的ThreadLocal的对象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set,get，remove的时候会被清除。

Java8中已经做了一些优化如，在ThreadLocal的get()、set()、remove()方法调用的时候会清除掉线程ThreadLocalMap中所有Entry中Key为null的Value，并将整个Entry设置为null，利于下次内存回收。

java中的四种引用

• 强引用????： 如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象

• 软引用????： 在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。（软引用可用来实现内存敏感的高速缓存,比如网页缓存、图片缓存等。使用软引用能防止内存泄露，增强程序的健壮性）

• 弱引用????： 具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象

• 虚引用????： 虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。（注意哦，其它引用是被JVM回收后才被传入ReferenceQueue中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。可以使用在对象销毁前的一些操作，比如说资源释放等。）

通常ThreadLocalMap的生命周期跟Thread（注意线程池中的Thread）一样长，如果没有手动删除对应key（线程使用结束归还给线程池了，其中的KV不再被使用但又不会GC回收，可认为是内存泄漏），一定会导致内存泄漏，但是使用弱引用可以多一层保障：弱引用ThreadLocal会被GC回收，不会内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除，Java8已经做了上面的代码优化。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!