Threadlocal线程变量简介

Threadlocal线程变量简介

ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

ThreadLoal 变量，线程局部变量，同一个 ThreadLocal 所包含的对象，在不同的 Thread 中有不同的副本。

注意：

每个 Thread 内有自己的实例副本，且该副本只能由当前 Thread 使用，故其它 Thread 不可访问，那就不存在多线程间共享的问题。

ThreadLocal 提供了线程本地的实例。它与普通变量的区别在于，每个使用该变量的线程都会初始化一个完全独立的实例副本。ThreadLocal 变量通常被private static修饰。当一个线程结束时，它所使用的所有 ThreadLocal 相对的实例副本都可被回收。

总的来说，ThreadLocal 适用于每个线程需要自己独立的实例且该实例需要在多个方法中被使用，也即变量在线程间隔离而在方法或类间共享的场景

应用实例：

public class ThreadLocalDemo {
    
    

    private static ThreadLocal<Integer> localVar = new ThreadLocal<>();


    public static void main(String[] args) {
    
    
        Thread thread = new Thread(
                new Runnable() {
    
    
                    @Override
                    public void run() {
    
    
                        ThreadLocaDemo.localVar.set(1007);
                        System.out.println(Thread.currentThread().getName()+": "+ ThreadLocaDemo.localVar.get());
                    }
                }, "Thread A"
        );
        thread.start();

        ThreadLocaDemo.localVar.set(1991);
        System.out.println(Thread.currentThread().getName()+": "+localVar.get());
        ThreadLocaDemo.localVar.remove();
        System.out.println(Thread.currentThread().getName()+" after remove: "+localVar.get());
    }
}

运行结果：

Threadlocal原理

介绍

threadlocal 是作为 当前线程中的属性 ThreadLocalMap 集合 中的某一个 Entry的 key 值，即 Entry( threadlocal, value)。

虽然不同的线程之间 threadlocal这个key值 是一样的，但是不同的线程所拥有的 ThreadLocalMap 是独一无二的，

因此不同的线程间同一个key（即ThreadLocal）对应存储的值（即value）不一样，从而到达了线程间变量隔离的目的，但是在同一个线程中这个value变量地址是一样的。

源码

ThreadLocal的set()方法

/**
* Sets the current thread's copy of this thread-local variable to the specified value. Most subclasses will
* have no need to override this method, relying solely on the 'initialValue' method to set the values of 
* thread-locals.
* Params: value – the value to be stored in the current thread's copy of this thread-local.
**/
public void set(T value) {
    
    
        // 1、获取当前线程
        Thread t = Thread.currentThread();
        // 2、获取线程中的属性 threadLocalMap 
     	// 如果threadLocalMap 不为空，则直接更新要保存的变量值
        // 否则创建threadLocalMap，并赋值
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            // 初始化thradLocalMap 并赋值
            createMap(t, value);
    }
/**
* Get the map associated with a ThreadLocal. Overridden in InheritableThreadLocal.
* Params:t – the current thread
* Returns:the map
**/
ThreadLocalMap getMap(Thread t) {
    
    
        return t.threadLocals;
    }

那么ThreadLocalMap又是什么呢，还有createMap又是怎么做的，继续往下看。

  static class ThreadLocalMap {
    
    
 
        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
    
    
            /** The value associated with this ThreadLocal. */
            Object value;
 
            Entry(ThreadLocal<?> k, Object v) {
    
    
                super(k);
                value = v;
            }
        }
 
        
    }

可看出ThreadLocalMap是ThreadLocal的内部静态类，而它的构成主要是用Entry来保存数据 ，而且还是继承的弱引用。在Entry内部使用ThreadLocal作为key，使用我们设置的value作为value。

//这个是threadlocal 的内部方法
void createMap(Thread t, T firstValue) {
    
    
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
 
 
    //ThreadLocalMap 构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    
    
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

ThreadLocal的get方法

    public T get() {
    
    
        //1、获取当前线程
        Thread t = Thread.currentThread();
        //2、获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        //3、如果map数据不为空，
        if (map != null) {
    
    
            //3.1、获取threalLocalMap中存储的值
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
    
    
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //如果是数据为null，则初始化，初始化的结果，TheralLocalMap中存放key值为threadLocal，值为null
        return setInitialValue();
    }
 
 
private T setInitialValue() {
    
    
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

ThreadLocal的remove方法

 public void remove() {
    
    
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

remove方法，直接将ThrealLocal 对应的值从当前相差Thread中的ThreadLocalMap中删除。为什么要删除，这涉及到内存泄露的问题。

实际上 ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用，弱引用的特点是，如果这个对象只存在弱引用，那么在下一次垃圾回收的时候必然会被清理掉。

所以如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候会被清理掉的，这样一来 ThreadLocalMap中使用这个 ThreadLocal 的 key 也会被清理掉。但是，value 是强引用，不会被清理，这样一来就会出现 key 为 null 的 value。

ThreadLocal其实是与线程绑定的一个变量，如此就会出现一个问题：如果没有将ThreadLocal内的变量删除（remove）或替换，它的生命周期将会与线程共存。通常线程池中对线程管理都是采用线程复用的方法，在线程池中线程很难结束甚至于永远不会结束，这将意味着线程持续的时间将不可预测，甚至与JVM的生命周期一致。举个例字，如果ThreadLocal中直接或间接包装了集合类或复杂对象，每次在同一个ThreadLocal中取出对象后，再对内容做操作，那么内部的集合类和复杂对象所占用的空间可能会开始持续膨胀。

ThreadLocal与Synchronized的区别

ThreadLocal其实是与线程绑定的一个变量。ThreadLocal和Synchonized都用于解决多线程并发访问。

但是ThreadLocal与synchronized有本质的区别：

1. Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

2. Synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问，这样就可以在多个线程间通信时获得数据共享。

   ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。

参考文章

https://blog.csdn.net/u010445301/article/details/111322569

一些选择题

D

ThreadLocal为每一个线程都提供了变量的副本**，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。

参考文章

https://blog.csdn.net/u010445301/article/details/111322569

一些选择题

[外链图片转存中…(img-5I7mAWOL-1709222980782)]

D