Java ThreadLocal原理解析以及应用场景分析案例详解

目录

• ThreadLocal的定义
• ThreadLocal的应用场景
• ThreadLocal的demo
• TheadLocal的源码解析
• ThreadLocal的set方法
• ThreadLocal的get方法
• ThreadLocalMap的结构
• ThreadLocalMap的set方法
• ThreadLocalMap的getEntry方法
• ThreadLocal的内存泄露
• 如何避免内存泄露呢
• 应用实例
• 实际应用二
• 总结

ThreadLocal的定义

JDK对ThreadLocal的定义如下：
TheadLocal提供了线程内部的局部变量：每个线程都有自己的独立的副本；ThreadLocal实例通常是类中的private static字段，该类一般与线程状态相关（或线程上下文）中使用。只要线程处于活动状态且ThreadLocal实例时可访问的状态下，每个线程都持有对其线程局部变量的副本的隐式引用，在线程消亡后，ThreadLocal实例的所有副本都将进行垃圾回收。

ThreadLocal的应用场景

ThreadLocal 不是用来解决多线程访问共享变量的问题，所以不能替换掉同步方法。一般而言，ThreadLocal的最佳应用场景是：按照线程多实例（每个线程对应一个实例）的对象的访问。
例如：在事务中，connection绑定到当前线程来保证这个线程中的数据库操作用的是同一个connection。

ThreadLocal的demo

public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal threadLocal = new ThreadLocal<>();
        threadLocal.set("张三");

        new Thread(()->{
            threadLocal.set("李四");
            System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
        },"线程1").start();
        new Thread(()->{
            threadLocal.set("王二");
            System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
        },"线程2").start();
        new Thread(()->{
            System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
        },"线程3").start();
        System.out.println("线程=" + Thread.currentThread().getName() + "获取到的数据=" + threadLocal.get());
    }
}

运行结果：

从运行结果，我们可以看出线程1和线程2在ThreadLocal中设置的值相互独立，每个线程只能取到自己设置的那个值。

TheadLocal的源码解析

ThreadLocal存储数据的逻辑是：每个线程持有一个自己的ThreadLocalMap,key为ThreadLocal对象的实例，value 是我们需要设值的值。

ThreadLocal的set方法

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

getMap的方法如下：

public class Thread implements Runnable {
	
	//每个线程自己的ThreadLocalMap对象通过ThreadLocal保存下来
  ThreadLocal.ThreadLocalMap threadLocals = null;

  ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
}

首先获取当前线程的ThreadLocalMap对象，该对象是通过实例变量threadLocals保存的。

2. 如果获取得到ThreadLocalMap，则直接设值，key为当前ThreadLocal类的this实例，如果获取不到调用createMap方法创建ThreadLoalMap实例，并将值设置到这个ThreadLocalMap中，后面我们会重点介绍ThreadLocal的createMap方法。
接下来我们就来看看ThreadLocal的get方法。

ThreadLocal的get方法

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

1.首先获取当前线程的ThreadLocalMap对象，没有的话，设置初始值（null）并返回

2. 如果可以获取到ThreadLocalMap 则获取其Entry对象，如果不为空则直接返回value
说完了ThreadLocal的set方法和get方法。我就来具体看看前面提到的ThreadLocalMap。

ThreadLocalMap的结构

public class ThreadLocal {
		
	private static AtomicInteger nextHashCode =new AtomicInteger();
	
	//初始的Hash值是0x61c88647
	 private static final int HASH_INCREMENT = 0x61c88647;
		
	//每次调用就原子性的将hash值增加HASH_INCREMENT
	private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
	
	static class ThreadLocalMap {
		 //Entry继承WeakReference
		  static class Entry extends WeakReference> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

				private static final int INITIAL_CAPACITY = 16;


				 private void setThreshold(int len) {
					threshold = len * 2 / 3;
				}


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

			 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);
				}
			}
	}	

如上，ThreadLocalMap作为ThreadLocal的静态内部类，由ThreadLocal所持有，每个线程内部通过ThreadLocal来获取自己的ThreadLocalMap实例。结构如下图所示：

从上述代码我们可以看出ThreadLocalMap实际上没有继承Map接口，其只是一个可扩展的散列表结构。初始大小是16。大于等于数据的1/2 的时候会扩容为2倍的原数组的rehash。初始的hashCode值为0x61c88647。每创建一个Entry对象，hash值就会增加一个固定大小0x61c88647。同时，我们注意到，ThreadLocalMap的Entry是继承WeakReference,和HashMap很大的区别是，Entry中没有next字段，所以不存在链表的情况。那么没有链表结构，发生hash冲突了怎么办呢？要解答这个问题就需要看看ThreadLocalMap的set方法了。

ThreadLocalMap的set方法

  private void set(ThreadLocal key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
			//1.根据ThreadLocal对象的hash值，定位到table中的位置i
            int i = key.threadLocalHashCode & (len-1);
			
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal k = e.get();
				//判断Entry.key等于当前的ThreadLoacl对象key，则覆盖旧值，退出。
                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();
        }

前面我们提到了每个ThreadLocal对象都有一个hash值threadLocalHashCode，每创建一个Entry对象，hash值就增加一个固定的大小0x61c88647。

1.根据ThreadLocal对象的hash值，定位到table中的位置i

2.如果table[i]的Entry不为null

2.1. 判断Entry.key等于当前的ThreadLoacl对象key，则覆盖旧值，退出。

2.2. 如果Entry.key为null,将执行删除两个null 槽之间的所有过期的stale的entry，
并把当前的位置i上初始化一个Entry对象，退出

2.3 继续查找下一个位置i++

3.如果找到了一个位置k,table[k]为null,初始化一个Entry对象。

ThreadLocalMap的getEntry方法

	 private Entry getEntry(ThreadLocal key) {
            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 Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

1. 根据当前ThreadLocal的hashCode mod table.length，计算直接索引的位置i，如果e不为null并且key相同则返回e。
2. 如果e为null，返回null
3. 如果e不为空且key不相同，则查找下一个位置，继续查找比较，直到e为null退出
4. 在查找的过程中如果发现e不为空，且e的k为空的话，删除当前槽和下一个null槽之间的所有过期entry对象。
   总结ThreadLocalMap：
5. ThreadLocalMap的散列表采用开放地址，线性探测的方法处理hash冲突，在hash冲突较大的时候效率低下，因为ThreadLoaclMap是一个Thread的一个属性，所以即使在自己的代码中控制设置的元素个数，但还是不能控制其他代码的行为。
6. ThreadLocalMap的set、get、remove操作中都带有删除过期元素的操作，类似缓存的lazy淘汰。

ThreadLocal的内存泄露

ThreadLocal可能导致内存泄露，为什么？先看看Entry的实现：

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

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

通过之前的分析我们已经知道，当使用ThreadLocal保存一个value时，会在ThreadLoalMap中的数组插入一个Entry对象，按理来说key-value都可以以强引用保存在Entry对象中，但在ThreadLocalMap的实现中，key被保存到了WeakReference对象（弱引用）中，即ThreadLocalMap弱引用ThreadLocal。
Key的引用链是
ThreadLocalRef---->ThreadLocal，
这就导致了一个问题，当一个ThreadLocal没有强引用时，threadLocal会被GC清理，会形成一个key为null的Map的引用。
但是value是强引用的，只有当当前线程结束了value的强引用才会结束，但线程迟迟未结束时，就会出现
ThreadRef---->Thread---->ThreadLocalMap—>Entry—>value这条强引用链条。
废弃threadLocal占用的内存会在三种情况下清理：

1. thread结束，那么与之相关的threadlocal value会被清理
2. GC后，thread.threadLocal(map) 的threadhold超过最大值时，会清理
3. GC后，thread.threadlocals(maps)添加新的Entry时，hash算法没有命中既有Entry时，会清理

那么何时会“内存泄漏”？当Thread长时间不结束，存在大量废弃的ThreadLocal，而又不再添加新的ThreadLocal时。

如何避免内存泄露呢

在调用ThreadLocal的get()、set()可能会清除ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就可以被回收，当然如果调用remove方法，肯定会删除对应的Entry对象。

  ThreadLocal threadLocal = new ThreadLocal<>();
        try {
            threadLocal.set("张三");
        } catch (Exception e) {
            threadLocal.remove();
        }

应用实例

public class DateUtil {
    private final static Map> sdfMap = new HashMap<>();
	    public final static String Y2M2D2HMS_ = "yyyy/MM/dd HH:mm:ss";
	    private static SimpleDateFormat getsdf(final String pattern) {
        ThreadLocal sdfThread = sdfMap.get(pattern);
        if (sdfThread == null) {
            //双重检验,防止sdfMap被多次put进去值,和双重锁单例原因是一样的
            synchronized (DateUtil.class) {
                // 只有Map中还没有这个pattern的sdf才会生成新的sdf并放入map
                // 这里是关键,使用ThreadLocal替代原来直接new SimpleDateFormat
                sdfThread = sdfMap.get(pattern);
                if (sdfThread == null) {
                    sdfThread = ThreadLocal.withInitial(() -> new SimpleDateFormat(pattern));
                    sdfMap.put(pattern, sdfThread);
                }

            }
        }
        return sdfThread.get();
    }
	    /**
     * @param date    需要格式化的date
     * @param pattern 给定转换格式
     * @return java.lang.String 时间串
     * @description 按照指定pattern的方式格式化时间
     */
    public static String formatDate(Date date, String pattern) {
        return DateUtil.getsdf(pattern).format(date);
    }
}

SimpleDateFormat是线程不安全的类，同时创建一个SimpleDateFormat类又比较耗时，所以，我们可以将SimpleDateFormat类放在ThreadLocal包装起来。然后，根据日期格式化的类型作为key放入一个静态的map中。

实际应用二

 private static ThreadLocal DECIMAL_FORMAT_THREAD_LOCAL = ThreadLocal.withInitial(() -> new DecimalFormat(DECIMAL_FORMAT));

    /**
     * 获取金额格式化的类
     * @return
     */
    public static DecimalFormat getDecimalFormat() {
        return DECIMAL_FORMAT_THREAD_LOCAL.get();
    }

我们可以将金额格式化的类DecimalFormat保存到ThreadLocal中。

总结

本文简单的介绍了ThreadLocal的应用场景，其主要用在需要每个线程独占的元素上，例如SimpleDateFormat。然后，就是介绍了ThreadLocal的实现原理，详细介绍了set()和get()方法，介绍了ThreadeLocalMap的数据结构，最后就是说到了ThreadLocal的内存泄露以及避免的方式。

到此这篇关于Java ThreadLocal原理解析以及应用场景分析案例详解的文章就介绍到这了,更多相关Java ThreadLocal原理解析以及应用场景内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！