Java多线程于高并发——ThreadLocal

ThreadLocal

ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问(通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。
我们可以得知ThreadLocal的作用是︰提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。

线程并发:在多线程并发的场景下
传递数据:我们可以通过ThreadLocal在同一线程，不同组件中传递公共变量线程隔离:每个线程的变量都是独立的，不会互相影响

常用方法

方法	说明
ThreadLocal()	创建ThreadLocal对象
protected T initialValue()	返回当前线程局部变量的初始值
public void set( T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

基本使用

原始代码

package example;

public class Demo1 {
    private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        for (int i = 0; i < 6; i++) {
            Thread thread = new Thread(() -> {
                demo1.setContent(Thread.currentThread().getName()+"数据");
                System.out.println(Thread.currentThread().getName() + "----->" + demo1.getContent());
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

这里可以看出，线程和自己的数据没有对应上，开启的线程越多，越容易出现不对应，因为线程没有进行隔离所以线程可能会获取其他线程的数据

使用ThreadLocal来改写

package example;

public class Demo1 {
    private String content;

    private ThreadLocal<String> local = new ThreadLocal<>();

    public String getContent() {
        return local.get();
    }

    public void setContent(String content) {
        local.set(content);
    }

    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                demo1.setContent(Thread.currentThread().getName()+"数据");
                System.out.println(Thread.currentThread().getName() + "----->" + demo1.getContent());
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

即使我增加了线程数也不会出现之前的情况

synchronized和threadLocal的区别

synchronized加了锁导致性能变差，线程需要排队
但是threadLocal不需要！

方式	synchronized	threadLocal
原理	同步机制采用"以时间换空间’的方式，只提供了一份变量,让不同的线程排队访问	ThreadLocal采用"以空间换时间’的方式,为每一个线程都提供了一份变量的副本,从而实现同时访问而相不干扰
侧重	多个线程之间访问资源的同步	多线程中让每个线程之间的数据相互隔离

ThreadLocal内部结构

每个 Thread维护一个ThreadLocalMap，ThreadLocalMap的key是ThreadLocal实例本身，value才是真正存储的值

1. 每个Thread线程内部都有一个Map (ThreadLocalMap)
2. Map里面存储ThreadLocal对象( key )和线程的变呈副本 ( value )
3. Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值
4. 对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

优点

1. 每个Map存储的Entry数量变少
2. 当Thread销毁的时候,ThreadLocalMap也会随之销毁，减少内存的使用

源码分析

public T get()方法

public T get() {
		//获取当前线程
        Thread t = Thread.currentThread();
        //调用getMap方法获取当前线程Thread维护的TreadLocalMap
        ThreadLocalMap map = getMap(t);
        //判断ThreadLocalMap是否为空
        if (map != null) {
        //非空则调用getEntry方法让ThreadLocalMap的Entry获取一个Entry
            ThreadLocalMap.Entry e = map.getEntry(this);
            //再判断当前ThreadLocalMap的Entry是否为空
            if (e != null) {
            //非空去除Entry中的value值
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //不符合以上的情况调用setInitialValue
        return setInitialValue();
    }

    ThreadLocalMap getMap(Thread t) {
    //返回当前线程维护的ThreadLocalMap
        return t.threadLocals;
    }

private Entry getEntry(ThreadLocal<?> key) {
//获取当前ThreadLocal的哈希值
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }
  //设置初始化值       
   private T setInitialValue() {
   //initialValue方法可被子类重写，不重写默认返回null
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
        //对ThreadLocalMap对象进行初始化
        //将当前线程和value作为第一个entry存到ThreadLocalMap中
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value;
    }

private void set方法

    public void set(T value) {
    //获取当前线程对象
        Thread t = Thread.currentThread();
        //调用getMap方法获取当前线程Thread维护的TreadLocalMap
        ThreadLocalMap map = getMap(t);
        //判断当前ThreadLocalMap是否为空
        if (map != null) {
        //不为空则调用方法设置实体entry
            map.set(this, value);
        } else {
        //创建当前线程Thread对应维护的ThreadLocalMap
        //会将其存放到Thread LocalMap的第一个entry中
        
            createMap(t, value);
        }
    }

ThreadLocalMap

ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现。

成员变量

        /**初始的容量，必须是2的整次幂
         * The initial capacity -- MUST be a power of two.
         */
        private static final int INITIAL_CAPACITY = 16;

        /** 叫table的Entry数组，可以根据需要调整大小
         *用于存放数据
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

        /**table中entry的个数
         * The number of entries in the table.
         */
        private int size = 0;

        /**进行扩容的阈值
         * The next size value at which to resize.
         */
        private int threshold; // Default to 0

存储结构Entry

可以看出key一定是ThreadLocal对象，值无所谓
另外，Entry继承WeakReference，也就是key ( ThreadLocal )是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。

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

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

弱引用和内存泄漏

在使用ThreadLocal的过程中会发现有内存泄漏的情况发生，就猜测这个内存泄漏跟Entry中使用了弱引用的key有关系。这个理解其实是不对的。

1. 内存泄漏相关概念
   Memory overflow:内存溢出，没有足够的内存提供申请者使用。
   Memory leak: 内存泄漏是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积终将导致内存溢出。
2. 弱引用相关概念
   Java中的引用有4种类型:强、软、弱、虚。当前这个问题主要涉及到强引用和弱引用:
   强引用(“Strong"” Reference )：就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾回收器就不会回收这种对象。
   弱引用( WeakReference )：垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

ThreadLocalMap中的key使用强引用

1. 假设在业务代码中使用完ThreadLocal , threadLocal Ref被回收了。
2. 但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。
3. 在没有手动删除这个Entry以及CurrentThread依然运行的前提下，
   始终有强引用链 threadRef->currentThread->threadLocalMap->entry .Entry就不会被回收( Entry中包括了ThreadLocal实例和value ) .
   导致Entry内存泄漏。

也就是说，ThreadLocalMap中的key使用了强引用，是无法完全避免内存泄漏的。

ThreadLocalMap中的key使用弱引用

1. 同样假设在业务代码中使用完ThreadLocal , threadLocal Ref被回收了。
2. 由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例。所以threadlocal就可以顺利被gc回收,此时Entry中的key=null。
3. 但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry ->value , value不会被回收，而这块value永远不会被访问到了，导致value内存泄漏。

也就是说，ThreadLocalMap中的key使用了弱引用，也有可能内存泄漏。

内存泄漏原因

比较以上两种情况，我们就会发现，内存泄漏的发生跟ThreadLocalMap中的key是否使用弱引用是没有关系的。

在以上两种内存泄漏的情况中，都有两个前提:

1. 没有手动删除这个Entry
2. CurrentThread依然运行

第一点很好理解，只要在使用完ThreadLocal，调用其remove方法删除对应的Entry ，就能避免内存泄漏。
第二点稍微复杂一点，由于ThreadLocalMap是Thread的一个属性，被当前线程所引用，所以它的生命周期跟Thread一样长。那么在使用完
ThreadLocal的使用，如果当前Thread也随之执行结束，ThreadLocalMap自然也会被gc回收，从根源上避免了内存泄漏。

综上，ThreadLocal内存泄漏的根源是:由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏。

为什么要使用弱引用

事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null (也即是ThreadLocal为null )进行判断，如果为null的话，那么是会对value置为null的。
这就意味着使用完ThreadLocal , CurrentThread依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障，弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用
set,get,remove中的任一方法的时候会被清除，从而避免内存泄漏

ThreadLocalMap中hash冲突的解决

主要是set方法
我们知道
set首先获取当前线程，然后根据当前线程获取一个Map，判断map不为空则将当前ThreadLocal的引用作为key设置到Map中，如果为空则给当前线程创建Map并设置初始值

ThreadLocalMap构造方法

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
			//创建出一个entry
            table = new Entry[INITIAL_CAPACITY];
            //计算索引
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            //根据索引设置值
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            //设置阈值
            setThreshold(INITIAL_CAPACITY);
        }
        

private final int threadLocalHashCode = nextHashCode();

private static AtomicInteger nextHashCode =
        new AtomicInteger();
        
//AtomicInteger是一个提供原子操作的Integer类
//通过线程安全的方式操作加减,适合高并发情况下的使用
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

    public final int getAndAdd(int delta) {
        return U.getAndAddInt(this, VALUE, delta);
    }

private static final int HASH_INCREMENT = 0x61c88647;

关于firstKey.threadLocalHashCode

这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT，HASH_INCREMENT =0x61c88647,这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里,也就是Entry[]table中，这样做可以尽量避免hash冲突。

关于 & (INITIAL_CAPACITY - 1)：

计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现。正是因为这种算法，我们要求size必须是2的整次幂，这也能保证保证在索引不越界的前提下，使得hash发生冲突的次数减小。