ThreadLocal，在多线程下保证数据安全

1. ThreadLocal简介

多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。

常用的方式：1.synchronize 加锁方法    
		   2.ThreadLocal方法

ThreadLocal的作用是提供线程内的局部变量，这种变量在多线程环境下访问时能够保证各个线程里变量的独立性。

2.ThreadLocal实现原理

Java中的ThreadLocal是用哈希表实现的，每个线程Thread维护一个ThreadLocalMap属性，里面就以Map的形式存储了多个ThreadLocal对象。当在线程中调用ThreadLocal操作方法时，都会通过当前Thread线程对象拿到线程里的ThreadLocalMap，再通过ThreadLocal对象从ThreadLocalMap中锁定数据实体（ThreadLocalMap.Entry）。

ThreadLocal暴露了多个基本的操作和构造方法，主要的功能有：构造方法、设值方法、取值方法和资源回收；

2.1构造方法

ThreadLocal是一个泛型类，只提供了一个构造方法，通过泛型可以指定要存储的值的类型。

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<>(supplier);
}
    
public ThreadLocal() {
}

protected T initialValue() {
       return null;
}

在实例化对象时配合initialValue()方法，提供一个初始值，因为这是一个protected方法，需要在实例化ThreadLocal对象覆盖方法。

private static ThreadLocal<Object> objectThreadLocal = new ThreadLocal<Object>(){

     @Override
    protected Object initialValue() {
         return "hello";
    }
};

还可以通过静态的设置初始值的方法withInitial()，因为Supplier接口是个函数式接口，因此，我们可以使用lambad表达式：

 private static ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> "hello");

2.2 set方法

要保存的数据通过set方法设置，多次调用set方法并不会保存多个数据，而是发生覆盖，一个ThreadLocal正常只能保存一个数据：

    public void set(T value) {
		//获取当前线程t
        Thread t = Thread.currentThread();
        //获取当前线程维护的ThreadLocalMap 
        ThreadLocalMap map = getMap(t);
        //线程中存在map，设值
        if (map != null)
            map.set(this, value); //this表示当前threadLocal对象
        else
            createMap(t, value); //线程中不存在ThreadLocalMap，创建后再设值
    }


private void set(ThreadLocal<?> key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            //计算当前threadLocal对象的索引位置
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                //获取当前entry的key值
                ThreadLocal<?> k = e.get();
				//判断是否和插入的key是同一个对象
                if (k == key) {
                	//替换值
                    e.value = value;
                    return;
                }
				//说明当前索引位置的key不存在
                if (k == null) {
                	//替换旧的entry
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
			//找到空位置，新建entry并插入
            tab[i] = new Entry(key, value);
            int sz = ++size;
            //大于阈值，再hash
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

2.3 get方法

public T get() {
		//获取当前线程t
        Thread t = Thread.currentThread();
        //获取当前线程维护的ThreadLocalMap 
        ThreadLocalMap map = getMap(t);
        //
        if (map != null) {
       		//获取当前threadlocal的entry对象
            ThreadLocalMap.Entry e = map.getEntry(this);
          
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //如果当前线程没有维护map，初始化创建map，
        //如果当前线程维护map，但没有当前threadlocal的entry对象，会去添加一个entry对象，其值为默认初始值
		
		//在没有使用set方法设值之前，调用get方法获取的将是initialValue方法设置的值
        return setInitialValue();
    }

//初始化创建map
 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;
    }

	//为当前线程穿件一个ThreadLocalMap，并将值存储进去
   void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

2.4 remove方法

当我们不再需要保存的数据时，应该通过remove方法将当前线程中保存的值移除掉使对象得到GC（调用remove方法将把ThreadLocal对象从当前线程的ThreadLocalMap移除）：

     public void remove() {
     	// 拿到当前线程中的ThreadLocalMap
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
         	// 从ThreadLocalMap移除key为当前ThreadLocal对象的记录
             m.remove(this);
     }

3. 内存泄漏

每个Thread含有的ThreadLocalMap中的Key为ThreadLocal变量的弱引用，如果一个ThreadLocal变量没有外部强引用来引用它，那么它在JVM下一次GC的时候会被垃圾回收掉，这时候，Map中就存在了key为NULL的value，这个value无法被访问。如果当前线程再迟迟不结束的话（例如当前线程在一个线程池中），那么value所指向的对象可能永远无法释放，也即不能被回收，造成内存泄露。

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

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

在每一次对ThreadLocalMap的set，get，remove等操作中，都会清除Map中key为null的Entry。因此，ThreadLocal一般是不会存在内存泄露风的。