ThreadLocal详解

最新推荐文章于 2020-12-18 12:03:10 发布

原创最新推荐文章于 2020-12-18 12:03:10 发布 · 165 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#ThreadLocal

新并发编程专栏收录该内容

17 篇文章

订阅专栏

本文深入解析了ThreadLocal的工作原理，包括其内部数据结构ThreadLocalMap的使用，以及set和get方法的具体实现流程。通过实例演示了如何在多线程环境中使用ThreadLocal实现线程间的数据隔离。

前言:

ThreadLocal 是线程内部的数据存储类，多线程操作 ThreadLocal 时，不同的线程对数据进行储存后，只有在当前线程中才可以获取到存储的数据，不同的线程之间数据隔离。
ThreadLocal 数据的存储通过 get 和 set 方法来进行操作
具体实现是因为不同的线程中维护了一个数据 ThreadLocalMap( 其中table 数组存储数据) ，通过 ThreadLocal 确定了数组下标，而这个下标就是value存储的对应位置。

简单使用：

Demo：

public class Test {

    public static void main(String[] args) {

        ThreadLocal<String> threadLocal = new ThreadLocal<String>();

        new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set(Thread.currentThread().getName() + "_a");
                threadLocal.set(Thread.currentThread().getName() + "_b");
                System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set(Thread.currentThread().getName() + "_a");
                threadLocal.set(Thread.currentThread().getName() + "_b");
                System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
            }
        }).start();
    }
}

打印结果：
在 main 方法中我们定义了 threadLocal ，并且启动了两个线程 Thread-0，Thread-1，并且分别执行了set、get 方法，根据结果可以看出两个线程的数据储存是满足我们上面的表述的。

ThreadLocal 源码：

ThreadLocal 的源码相对比较简单，我们着重看一下 set(T value）和 get() 方法,具体解释在代码中:


	// Step 1
    public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // Step 2: 从当前线程(Thread)中获取 ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null)
        	// Step 3
            map.set(this, value);
        else
        	// Step 4
            createMap(t, value);
    }

	// Step 2: 获取当前线程的 ThreadLocalMap
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
	


	public T get() {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // Step 2: 获取当前线程的 ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // Step 5 ： 获取当 ThreadLocalMap.Entry，得到 value 的值并返回
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

在 get、set 方法中均是通过当前线程，获得在 Thread 中定义的 ThreadLocal.ThreadLocalMap 变量，后面通过操作 ThreadLocalMap 进行相应的 Step 3、Step 4、Step 5 操作，ThreadLocal 的内部类 ThreadLocalMap 是存取数据的关键
注意：Step 2 获取到的 ThreadLocalMap 是每个线程自己的变量非共享的，其实在这里已经解决了多线程数据隔离问题。

ThreadLocal内部类 ThreadLocalMap：

上面的 ThreadLocal 中 get 和 set 方法中关键点是 ThreadLocalMap ，ThreadLocalMap 是 ThreadLocal 的一个内部类，其中维护一个 Entry 类型的数组用来存取数据：
先看一下 Entry 的实现：

static class ThreadLocalMap {
		
		/**
         * 1、Entry是一个包含Key 和 Values 的一个对象
         * 2、Entry的key为ThreadLocal，values是values
         * 3、这里 ThreadLocal 通过 WeakReference 变成一个弱引用的对象，
         *    这样做的好处就是在线程销毁的时候，对应的实体就会被回收，不会出现内存泄漏
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;

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

		private static final int INITIAL_CAPACITY = 16;

        // 保存数据的table
        private Entry[] table;

        /**
         * The number of entries in the table.
         */
        private int size = 0;

        // table 调整的阈值
        private int threshold; // Default to 0

}

Entry是一个key为ThreadLocal 存储 Values 的对象

看一下 Step 3 执行的 map.set(this, value)方法：


static class ThreadLocalMap {
	
		// Step3: 设置值
        private void set(ThreadLocal<?> key, Object value) {

            // 获取到 table 并根据 key 计算出ThreadLocal，所在的下标
            Entry[] tab = table;
            int len = tab.length;
            // 计算下标：这种方式可以尽量避免重复，而且值又在范围之内
            int i = key.threadLocalHashCode & (len-1);

            //  table 可能会存放其他数据，这里找到合适的下标
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                // 如果当前指向Entry 是存储过的 ThreadLocal，就直接将以前的数据覆盖掉，并结束
                if (k == key) {
                    e.value = value;
                    return;
                }

                // 当前的 Entry key为空，将当前的数据保存进去
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
	
		// 省略代码....
}

Step 5 ： map.getEntry(this) 方法， this 为当前的 ThreadLocal ：


static class ThreadLocalMap {
 
 	// Step 5 ： 获取当 ThreadLocalMap.Entry，得到 value 的值并返回
 	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);
      }

	// 省略代码....
}

END !