L'utilisation de ThreadLocal dans le multithreading Java

Le contenu de cet article concerne l'utilisation de ThreadLocal dans le multi-threading Java. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Dans un environnement multithread, la synchronisation des threads doit être effectuée lors de l'accès à des variables non thread-safe, par exemple en utilisant la méthode synchronized pour accéder aux instances HashMap. Cependant, l'accès synchrone réduira la concurrence et affectera les performances du système. À ce stade, vous pouvez échanger de l'espace contre du temps. Si nous allouons une variable indépendante à chaque thread, vous pouvez utiliser des variables non thread-safe de manière asynchrone. Nous appelons ces variables des variables locales de thread.

Comme leur nom l'indique, les variables locales de thread signifient que chaque thread a sa propre copie indépendante de la variable et n'est pas accessible par d'autres threads comme les variables locales ordinaires. Java ne fournit pas de variables locales de thread au niveau du langage, mais fournit la fonction de variables locales de thread dans la bibliothèque de classes, qui est la classe protagoniste ThreadLocal cette fois.

Utilisation de ThreadLocal

La version Java8 de ThreadLocal en a 4, comme indiqué dans le image ci-dessus Il existe deux méthodes publiques et une méthode protégée. La première méthode est utilisée pour renvoyer la valeur initiale, qui est nulle par défaut. La deuxième méthode statique withInitial(Supplier extends S> supplier) est nouvellement ajoutée dans la version Java8, et les trois méthodes d'instance suivantes sont très simples.

Avant Java8, lorsque vous utilisez ThreadLocal et que vous souhaitez définir la valeur initiale, vous devez hériter de la classe ThreadLocal et remplacer la méthode protégée T initialValue(), par exemple :

ThreadLocal<integer> threadLocal = new ThreadLocal<integer>() {
    @Override
    protected Integer initialValue() {
        return 0;
    }
};</integer></integer>

Dans la version Java8, vous pouvez utiliser la méthode statique nouvellement ajoutée withInitial(Supplier extends S> supplier) pour définir la valeur initiale de manière très pratique, par exemple :

ThreadLocal<integer> threadLocal = ThreadLocal.withInitial(() -> 0);

System.out.println(threadLocal.get());
threadLocal.set(16);
System.out.println(threadLocal.get());
threadLocal.remove();
System.out.println(threadLocal.get());

// 同一个线程的输出
0
16
0
Process finished with exit code 0</integer>

Le principe de ThreadLocal

Alors, comment ThreadLocal implémente-t-il la fonction des variables locales du thread ? En fait, le principe de base de ThreadLocal n’est pas très compliqué. ThreadLocal définit en interne une classe statique ThreadLocalMap. La clé de ThreadLocalMap est l'objet ThreadLocal. La valeur de ThreadLocalMap est la valeur stockée par ThreadLocal. Jetons un coup d'œil à une partie du code source de ThreadLocal :

    // ThreadLocal的set方法
    public void set(T value) {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取Map
        ThreadLocalMap map = getMap(t);
        if (map != null)
            // 设置值
            map.set(this, value);
        else
            // 初始化Map
            createMap(t, value);
    }
    
    // ThreadLocal的createMap方法
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
    
    // Thread类定义的实例域
    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

On peut voir que l'implémentation principale de ThreadLocal est l'implémentation de ThreadLocalMap qui déclare en interne une classe Entry pour stocker les données :

static class Entry extends WeakReference<threadlocal>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal> k, Object v) {
        super(k);
        value = v;
    }
}</threadlocal>

L'implémentation de ThreadLocalMap est similaire à l'implémentation de HashMap. Par exemple, les tableaux sont également utilisés pour stocker des données et se développer automatiquement. La différence est que l'algorithme de hachage et le traitement après collision de hachage sont différents.

        // ThreadLocalMap的set方法
        private void set(ThreadLocal> key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            // 计算在Entry[]中的索引，每个ThreadLocal对象都有一个hash值threadLocalHashCode，每初始化一个ThreadLocal对象，hash值就增加一个固定的大小0x61c88647
            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;
                }
                // 代替无效的键
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
        
        private static int nextIndex(int i, int len) {
            return ((i + 1 Vous pouvez voir que ThreadLocalMap traite le tableau Entry[] comme un anneau. À partir de la position calculée de l'index, si l'index contient déjà des données, il sera jugé si la clé est la même, et si elle est la même, la valeur sera mise à jour. Sinon, attendez simplement de trouver une position vide et mettez-y la valeur. La même chose est vraie lors de l'obtention des valeurs. À partir de la position d'index calculée, une par une est vérifiée pour voir si les clés sont les mêmes. S'il y a de nombreuses collisions de hachage, les performances peuvent ne pas être très bonnes. <p></p><p>Application ThreadLocal<strong><code></code></strong><code><br></code></p><code><span style="font-family : Microsoft YaHei, Microsoft YaHei; "> ThreadLocal a un large éventail d'applications.Par exemple, le framework Spring, que les ingénieurs Java connaissent très bien, utilise ThreadLocal pour encapsuler des objets avec état non thread-safe, afin que nous puissions déclarer la plupart des beans comme portée singleton. Lors de l'écriture de code multithread, nous pouvons également nous demander s'il est préférable d'accéder aux objets avec état non thread-safe de manière synchrone, ou s'il est préférable d'utiliser ThreadLocal pour encapsuler des objets avec état non thread-safe. <p><code><span style="font-family: 微软雅黑, Microsoft YaHei;">ThreadLocal的应用是非常广的，比如Java工程师非常熟悉的Spring框架中就使用了ThreadLocal来把非线程安全的状态性对象封装起来，所以我们可以把绝大部分的Bean声明为singleton作用域。我们在编写多线程代码时也可以想想是用同步的方式访问非线程安全的状态性对象比较好，还是使用ThreadLocal把非线程安全的状态性对象封装起来更好。</span><br></code></p></span></code><p class="comments-box-content"><br></p>

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!