ThreadLocal详解

最新推荐文章于 2023-07-04 11:48:17 发布

红月修罗

最新推荐文章于 2023-07-04 11:48:17 发布

阅读量1.1k

点赞数 1

分类专栏：多线程高并发专题文章标签： ThreadLocal 多线程线程安全

多线程高并发专题专栏收录该内容

1 篇文章 0 订阅

订阅专栏

ThreadLocal 详解

1、讲讲你对ThreadLocal的一些理解。
2、ThreadLocal用在什么地方？
- 2.1、保存线程上下文信息，在任意需要的地方可以获取！
- 2.2、线程安全的，避免某些情况需要考虑线程安全必须同步带来的性能损失！
3、ThreadLocal一些细节！
4、ThreadLocal的最佳实践！
5、思考

1、讲讲你对ThreadLocal的一些理解。

那么我们该怎么回答呢？？？？你也可以思考下，下面看看零度的思考；

ThreadLocal用在什么地方？
ThreadLocal一些细节！
ThreadLocal的最佳实践！
思考

2、ThreadLocal用在什么地方？

讨论ThreadLocal用在什么地方前，我们先明确下，如果仅仅就一个线程，那么都不用谈ThreadLocal的，ThreadLocal是用在多线程的场景的！！！

ThreadLocal归纳下来就2类用途：

1）保存线程上下文信息，在任意需要的地方可以获取！

2）线程安全的，避免某些情况需要考虑线程安全必须同步带来的性能损失！

2.1、保存线程上下文信息，在任意需要的地方可以获取！

由于ThreadLocal的特性，同一线程在某地方进行设置，在随后的任意地方都可以获取到。从而可以用来保存线程上下文信息。

常用的比如每个请求怎么把一串后续关联起来，就可以用ThreadLocal进行set，在后续的任意需要记录日志的方法里面进行get获取到请求id，从而把整个请求串起来。

还有比如Spring的事务管理，用ThreadLocal存储Connection，从而各个DAO可以获取同一Connection，可以进行事务回滚，提交等操作。

2.2、线程安全的，避免某些情况需要考虑线程安全必须同步带来的性能损失！

ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。但是ThreadLocal也有局限性，我们来看看阿里规范：

15.【参考】 ThreadLocal 无法解决共享对象的更新问题， ThreadLocal 对象建议使用 static
修饰。这个变量是针对一个线程内所有操作共享的，所以设置为静态变量，所有此类实例共享
此静态变量，也就是说在类第一次被使用时装载，只分配一块存储空间，所有此类的对象 ( 只
要是这个线程内定义的 ) 都可以操控这个变量。

每个线程往ThreadLocal中读写数据是线程隔离，互相之间不会影响的，所以ThreadLocal无法解决共享对象的更新问题！

由于不需要共享信息，自然就不存在竞争问题了，从而保证了某些情况下线程的安全，以及避免了某些情况需要考虑线程安全必须同步带来的性能损失！！！

这类场景阿里规范里面也提到了：

/*
5.【强制】 SimpleDateFormat 是线程不安全的类，一般不要定义为 static 变量，如果定义为
static ，必须加锁，或者使用 DateUtils 工具类。
正例：注意线程安全，使用 DateUtils 。亦推荐如下处理：
*/
private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() {
	@ Override
	protected DateFormat initialValue() {
		return new SimpleDateFormat("yyyy-MM-dd");
	}
};

3、ThreadLocal一些细节！

ThreaLocal使用示例代码：

public class ThreadLocalTest {
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {

        new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    threadLocal.set(i);
                    System.out.println(Thread.currentThread().getName() + "====" + threadLocal.get());
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                threadLocal.remove();
            }
        }, "threadLocal1").start();


        new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "====" + threadLocal.get());
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                threadLocal.remove();
            }
        }, "threadLocal2").start();
    }
}

代码运行结果：

threadLocal1====53
threadLocal2====null
threadLocal1====54
threadLocal2====null
threadLocal1====55
threadLocal2====null
threadLocal1====56
threadLocal2====null
threadLocal1====57
threadLocal2====null
threadLocal1====58
threadLocal2====null
threadLocal1====59

从运行的结果我们可以看到threadLocal1进行set值对threadLocal2并没有任何影响！

Thread、ThreadLocalMap、ThreadLocal总览图：
在这里插入图片描述
Thread 源码有如下代码：

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;  // 这个就是ThreadLocalMap

    /*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

hread类有属性变量threadLocals （类型是ThreadLocal.ThreadLocalMap），也就是说每个线程有一个自己的ThreadLocalMap ，所以每个线程往这个ThreadLocal中读写隔离的，并且是互相不会影响的。

一个ThreadLocal只能存储一个Object对象，如果需要存储多个Object对象那么就需要多个ThreadLocal！！！

如图：
在这里插入图片描述
看到上面的几个图，大概思路应该都清晰了，我们Entry的key指向ThreadLocal用虚线表示弱引用，下面我们来看看ThreadLocalMap:

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

java对象的引用包括：强引用，软引用，弱引用，虚引用。

因为这里涉及到弱引用，简单说明下：

弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，该对象仅仅被弱引用关联，那么就会被回收。

当仅仅只有ThreadLocalMap中的Entry的key指向ThreadLocal的时候，ThreadLocal会进行回收的！！！

ThreadLocal被垃圾回收后，在ThreadLocalMap里对应的Entry的键值会变成null，但是Entry是强引用，那么Entry里面存储的Object，并没有办法进行回收，所以ThreadLocalMap 做了一些额外的回收工作。

private int expungeStaleEntry(int staleSlot) {
          Entry[] tab = table;
          int len = tab.length;

          // expunge entry at staleSlot
          tab[staleSlot].value = null;
          tab[staleSlot] = null;
          size--;

          // Rehash until we encounter null
          Entry e;
          int i;
          for (i = nextIndex(staleSlot, len);
               (e = tab[i]) != null;
               i = nextIndex(i, len)) {
              ThreadLocal<?> k = e.get();
              if (k == null) {
                  e.value = null;
                  tab[i] = null;
                  size--;
              } else {
                  int h = k.threadLocalHashCode & (len - 1);
                  if (h != i) {
                      tab[i] = null;

                      // Unlike Knuth 6.4 Algorithm R, we must scan until
                      // null because multiple entries could have been stale.
                      while (tab[h] != null)
                          h = nextIndex(h, len);
                      tab[h] = e;
                  }
              }
          }
          return i;
      }

虽然做了但是也会存在内存泄漏风险（我没有遇到过，网上很多类似场景，所以会提到后面的ThreadLocal最佳实践！！！）

4、ThreadLocal的最佳实践！

备注：很多时候，我们都是用在线程池的场景，程序不停止，线程基本不会销毁！！！

由于线程的生命周期很长，如果我们往ThreadLocal里面set了很大很大的Object对象，虽然set、get等等方法在特定的条件会调用进行额外的清理，但是ThreadLocal被垃圾回收后，在ThreadLocalMap里对应的Entry的键值会变成null，但是后续在也没有操作set、get等方法了。

所以最佳实践，应该在我们不使用的时候，主动调用remove方法进行清理。

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

这里把ThreadLocal定义为static还有一个好处就是，由于ThreadLocal有强引用在，那么在ThreadLocalMap里对应的Entry的键会永远存在，那么执行remove的时候就可以正确进行定位到并且删除！！！

最佳实践做法应该为：在finally里面调用 remove();

new Thread(() -> {
    try {
        for (int i = 0; i < 100; i++) {
            threadLocal.set(i);
            System.out.println(Thread.currentThread().getName() + "====" + threadLocal.get());
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    } finally {
        threadLocal.remove();
    }
}, "threadLocal1").start();


new Thread(() -> {
    try {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "====" + threadLocal.get());
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    } finally {
        threadLocal.remove();
    }
}, "threadLocal2").start();

5、思考

对于ThreadLocal，在参考Netty源码的时候，还有个FastThreadLocal，详解参考：https://blog.csdn.net/lirenzuo/article/details/94495469。

参考：https://mp.weixin.qq.com/s/8Ql-5kaUtxiCWyHR6uPPBw

红月修罗

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal详解

ThreadLocal 详解1、讲讲你对ThreadLocal的一些理解。2、ThreadLocal用在什么地方？2.1、保存线程上下文信息，在任意需要的地方可以获取！2.2、线程安全的，避免某些情况需要考虑线程安全必须同步带来的性能损失！3、ThreadLocal一些细节！4、ThreadLocal的最佳实践！五、思考1、讲讲你对ThreadLocal的一些理解。那么我们该怎么回答呢？？？？...
复制链接

扫一扫