Java并发工具之ThreadLocal

比眉伴天荒 2024-03-16 17:45 54阅读 0赞

### 一、ThreadLocal 简介 ###

#### 1. ThreadLocal 是什么？ ####

ThreadLocal 字面意思是本地线程，其实更准确来说是线程局部变量，线程类 Thread 有个变量叫做 threadLocals，其类型就是ThreadLocal.ThreadLocalMap 类型，他其实不是一个 Map 类型，但可以暂时理解它是一个Map，键为 ThreadLocal 对象，值就是要存入的value。

#### 2. ThreadLocal 作用 ####

`ThreadLocal` 就是用于线程间的数据隔离的。ThreadLocal 提供线程内部的局部变量，在本线程内随时随地可取，隔离其他线程，获取保存的值时非常方便，`ThreadLocal 为变量在每个线程中都创建了一个副本`，每个线程就可以很方便的访问自己内部的副本变量。

#### 3. ThreadLocal的两大使用场景 ####

*  每个线程需要一个独享的对象（通常是指工具类对象），每个线程内有自己的实例副本，不与其他线程共享；
 *  每个线程内需要一个变量作为全局共用（当前线程内全局共用），可以让不同的方法直接使用，避免传递参数的麻烦；

总之，就是解决多个线程的共享变量的线程安全问题；

### 二、使用场景案例 ###

#### 1. 每个线程需要一个独享的对象 ####

下面的案例是关于 SimpleDateFormat 工具类，在多线程共享时的线程安全问题

线程不安全的代码：

public class MyThreadLocal {
    
        private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    
        public static String date(int seconds) {
            Date date = new Date(1000 * seconds);
            return sdf.format(date);
        }
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            for (int i = 0; i < 1000; i++) {
                int finalI = i;
                executorService.execute(new Runnable() {
                    @Override
                    public void run() {
                        String date = date(finalI);
                        System.out.println(date);
                    }
                });
            }
            executorService.shutdown();
        }
    }

这里为了提高性能，所以将 SimpleDateFormat 作为 static 属性，多线程共享，但是这样就会出现安全问题，打印结果如下：

![image-20230608083233479][]

由结果可以看出，打印出了两个相同的时间，说明发生了运行结果错误，问题代码就发生在sdf.format(date)，这行代码不是线程安全的。

解决方案有两个：使用同步锁 synchronized 和使用 ThreadLocal 解决。

##### （1）同步锁 synchronized #####

public class MyThreadLocal {
    
        private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    
        public static String date(int seconds) {
            Date date = new Date(1000 * seconds);
            String s = null;
            synchronized (MyThreadLocal.class) {
                s = sdf.format(date);
            }
    //        Date date = new Date(1000 * seconds);
            return s;
        }
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            for (int i = 0; i < 1000; i++) {
                int finalI = i;
                executorService.execute(new Runnable() {
                    @Override
                    public void run() {
                        String date = date(finalI);
                        System.out.println(date);
                    }
                });
            }
            executorService.shutdown();
        }
    }

##### (2) 用ThreadLocal解决 #####

public class MyThreadLocal1 {
    
    //    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            private static ThreadLocal<SimpleDateFormat> simpleDateFormatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"));
    
        public static String date(int seconds) {
            Date date = new Date(1000 * seconds);
            SimpleDateFormat sdf = simpleDateFormatThreadLocal.get();
            return sdf.format(date);
        }
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            for (int i = 0; i < 1000; i++) {
                int finalI = i;
                executorService.execute(new Runnable() {
                    @Override
                    public void run() {
                        String date = date(finalI);
                        System.out.println(date);
                    }
                });
            }
            executorService.shutdown();
        }
    }

打印结果：

![acf2b4c19862fb72feea570bd98f717b.png][]

两个方案都可以解决线程安全问题，但是synchronized加锁的方法，由于同一时刻只有一个线程执行，所以效率低下；ThreadLocal方法在多线程并行的情况下，由于每个线程内都有自己独享的对象，也不会有线程安全问题。

#### 2. 每个线程内需要一个变量作为全局共用 ####

在应用开发中，有些参数需要被线程内许多方法使用，如权限管理，很多的方法都需要验证当前线程用户的身份信息

案例内容：一个系统中，user对象需要在很多server中进行使用

*  方案1  
    将user作为参数层层传递，从service1->service2->service3以此类推。这样会导致代码冗余且难以维护
 *  方案2  
    定义一个全局的static 的user，想要拿的时候直接获取。但这是一种**错误的方案**！！因为我们现在的场景是多用户的系统，每个线程对应着不同的用户，每个线程的user是不同的
 *  方案3  
    定义一个UserMap，每次访问从Map中获取用户的信息，多线程访问下加锁或者使用ConcurrentHashMap，但是对性能有影响
 *  方案4  
    利用ThreadLocal，不需要锁，不影响性能。ThreadLocal 主打的就是同一个线程内不同方法间的共享。

所以优选选择方案4，代码演示如下：

/**
     * 避免传递参数的麻烦
     * ThreadLocalan案例2
     * @author Chkl
     * @create 2020/3/10
     * @since 1.0.0
     */
    public class ThreadLocalNormalUsage06 {
        public static void main(String[] args) {
            new Service1().process();
        }
    }
    
    class Service1 {
        public void process() {
            User user = new User("周星驰");
            UserContextHolder.holder.set(user);
            new Service2().process();
        }
    }
    
    class Service2 {
        public void process() {
            User user = UserContextHolder.holder.get();
            System.out.println("service2:" + user.name);
            UserContextHolder.holder.remove();
            UserContextHolder.holder.set(new User("古天乐"));
            new Service3().process();
        }
    }
    
    class Service3 {
        public void process() {
            User user = UserContextHolder.holder.get();
            System.out.println("service3:" + user.name);
        }
    }
    
    class UserContextHolder {
        public static ThreadLocal<User> holder
                = new ThreadLocal<>();
    }
    
    class User {
        String name;
        public User(String name) {
            this.name = name;
        }
    }

打印结果：

![4ae7e9ae34ae60c34796b3bc1d3327f5.png][]

通过以上两个案例，我们可以了解到 ThreadLocal 的两个作用：

*  让对象在线程之间隔离；
 *  在任何方法中都可以直接获取到对象；

#### 3. ThreadLocal 的两个使用方式 ####

上面两个使用场景中，ThreadLocal 的初始化方式也是分为两种：

*  场景1：initialValue  
    如果在ThreadLocal第一次get的时候把对象给初始化时使用，对象的初始化时机受控制
 *  场景2：set  
    如果需要保存到ThreadLocal的对象的生成时机不由我们随意控制，我们用set方法放进去，再用get方法取出来；

#### 4. ThreadLocal的好处 ####

*  线程安全
 *  不需要加锁，执行效率高
 *  更高效的利用内存，节省开销
    
    相比于每个任务都新建一个SimpleDateFormat，显然用ThreadLocal可以节省内存和开销
 *  避免传参的繁琐操作
    
    无论是场景一的工具类，还是场景二的用户名，都可以在任务地方直接通过ThreadLocal拿到，再也不需要在方法的形参中再定义传入相同的参数。ThreadLocal使代码耦合度更低，更优雅。

### 三、ThreadLocal 原理 ###

#### 1. ThreadLocal 与 Thread 的关系 ####

![0b6951cd01a57f109270e725e409f781.png][]

*  每一个Thread里面都有一个ThreadLocalMap类型的threadlocals成员变量，它可以存储很多的ThreadLocal对象，因为一个线程可能有多个ThreadLocal对象，其中对象引用名称作为key；
 *  ThreadLocalMap：也就是Thread.threadLocals，是Thread里的一个成员变量，里面最重要的是一个键值对数组Entry\[\] table，可以认为是一个map，键值对；键：这个ThreadLocal；值：实际需要的成员变量；

#### 2. ThreadLocal 源码 ####

##### (1) initialValue() 方法源码 #####

/**
         * Returns the current thread's "initial value" for this
         * thread-local variable.  This method will be invoked the first
         * time a thread accesses the variable with the {@link #get}
         * method, unless the thread previously invoked the {@link #set}
         * method, in which case the {@code initialValue} method will not
         * be invoked for the thread.  Normally, this method is invoked at
         * most once per thread, but it may be invoked again in case of
         * subsequent invocations of {@link #remove} followed by {@link #get}.
         *
         * <p>This implementation simply returns {@code null}; if the
         * programmer desires thread-local variables to have an initial
         * value other than {@code null}, {@code ThreadLocal} must be
         * subclassed, and this method overridden.  Typically, an
         * anonymous inner class will be used.
         *
         * @return the initial value for this thread-local
         */
        protected T initialValue() {
            return null;
        }

*  该方法返回当前线程对应的初始值，使用了延迟加载，当调用get()方法是才会触发
 *  当第一次使用get()方法时会调用此方法，如果调用前用set()方法设置了值就不会调用
 *  当调用remove()方法后再次调用get()方法依然会调用initialize
 *  如果不重写initialValue方法，直接调用get()会返回null

##### (2) get 方法的实现： #####

/**
         * Returns the value in the current thread's copy of this
         * thread-local variable.  If the variable has no value for the
         * current thread, it is first initialized to the value returned
         * by an invocation of the {@link #initialValue} method.
         *
         * @return the current thread's value of this thread-local
         */
        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();
        }

方法里面第一行获取`当前线程`，然后通过 getMap(t) 方法获取 ThreadLocal.ThreadLocalMap，所有的变量数据都存在该 map，map 的具体类型是一个 Entry 数组。

然后接着下面获取到 Entry 键值对，注意这里获取 Entry 时参数传进去的是 this，即 `ThreadLocal 实例`，而不是当前线程 t。如果获取成功，则返回 value 值。

如果 map 为空，则调用 setInitialValue 方法返回一个初始 value，其实这个默认初始 value 为 null。

##### (3) 接着来看一下 getMap 方法做了什么： #####

/* ThreadLocal values pertaining to this thread. This map is maintained by the ThreadLocal class. */
    	ThreadLocal.ThreadLocalMap threadLocals = null;
        /**
         * Get the map associated with a ThreadLocal. Overridden in
         * InheritableThreadLocal.
         *
         * @param  t the current thread
         * @return the map
         */
    	ThreadLocalMap getMap(Thread t) {
            return t.threadLocals;
        }

在 getMap 中，是调用当期线程 t，返回当前线程t中的一个`成员变量 threadLocals`，类型为 ThreadLocal.ThreadLocalMap。就是上面提到的`每一个线程都自带一个 ThreadLocalMap 类型的成员变量。`

##### (4) 继续来看 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;
                }
            }

ThreadLocalMap 是 ThreadLocal 的一个静态内部类，其内部主要是一个 Entry 数组存储数据（并不是一个 map 类型）。

ThreadLocalMap 的 Entry 继承了 WeakReference，用来实现弱引用，被弱引用关联的对象（其实就是 ThreadLocal 对象）只能生存到下一次垃圾收集发生之前，并且使用 ThreadLocal 对象的 HashCode 的散列值计算得出的 Entry 数组的下标 i，这里`不同对象可能存在相同的下标 i`，对此 set() 方法处理逻辑是：下标加一，直到第一个要插入的位置为空。

##### (5) set()方法 #####

/**
         * Sets the current thread's copy of this thread-local variable
         * to the specified value.  Most subclasses will have no need to
         * override this method, relying solely on the {@link #initialValue}
         * method to set the values of thread-locals.
         *
         * @param value the value to be stored in the current thread's copy of
         *        this thread-local.
         */
        public void set(T value) {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);
        }

为这个线程设置一个新值

##### (6) remove()方法 #####

/**
         * Removes the current thread's value for this thread-local
         * variable.  If this thread-local variable is subsequently
         * {@linkplain #get read} by the current thread, its value will be
         * reinitialized by invoking its {@link #initialValue} method,
         * unless its value is {@linkplain #set set} by the current thread
         * in the interim.  This may result in multiple invocations of the
         * {@code initialValue} method in the current thread.
         *
         * @since 1.5
         */
         public void remove() {
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
                 m.remove(this);
         }

删除线程中对应的值，remove()方法也是在ThreadlocalMap中进行操作，传入当前ThreadLocal对象的引用，删除map中的value的值，*不是删除整个ThreadLocalMap对象，而是根据this（也就是当前ThreadLocal对象）来删除对应的threadLocal对象*

### 四、ThreadLocal 注意点 ###

#### 1. 在使用 ThreadLocal时的注意事项 ####

*  最后一次使用之后应该手动的调用remove()方法，防止内存泄露
 *  如果可以不使用ThreadLocal就解决问题，不要强行使用（如：任务数很少时）
 *  优先使用框架的支持，而不是自己创造，例如在Spring中，如果可以使用 RequestContextHolder，那么就不需要自己去维护ThreadLocal，因为自己可能会忘记调用remove方法，造成内存泄漏；

#### 2 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 是基于 ThreadLocalMap 实现的，这个 Map 的 Entry 继承了 WeakReference，而 Entry 对象中的 key 使用了 WeakReference 封装，也就是说 Entry 中的 key 是一个弱引用类型，而弱引用类型只能存活在下次 GC 之前。

如果一个线程调用 ThreadLocal 的 set 设置变量，当前 ThreadLocalMap 则新增一条记录，但发生一次垃圾回收，此时 key 值被回收，而 value 值依然存在内存中，如果线程一直存在（比如在线程池中），那么 value 值将一直被引用，不能被回收。因为存在一条引用链的关系：Thread–>ThreadLocalMap–>Entry–>Value。造成内存泄漏，甚至有可能造成内存溢出OOM

如何避免内存泄漏：当使用完了对应的ThreadLocal，主动调用remove方法删除。

#### 3. 空指针异常问题 ####

代码演示：

public class ThreadLocalNPE {
    
       ThreadLocal<Long> tl =  new ThreadLocal();
    
       public void set(){
           tl.set(Thread.currentThread().getId());
       }
       public long get(){
           return tl.get();
       }
    
        public static void main(String[] args) {
            ThreadLocalNPE item = new ThreadLocalNPE();
            System.out.println(item.get());
    
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    item.set();
                    System.out.println(item.get());
                }
            });
            thread.start();
        }
    }

打印结果：

![87e2bec058a42d77f4bef09e8044bb7d.png][]

这里的，get()方法出现了NPE异常，那为什么呢？

![7fc45272ca50ec45491e0a56a8d87a9c.png][]

ThreadLocal在实例化时是指定存储的包装类型 Long （ThreadLocal tl = new ThreadLocal()）， 而演示代码中的 get() 方法返回的是基本类型 long，那么他在执行 initialValue() 时返回的是 Long，然后自动拆箱，转为 long 基本类型，这里就出现了错误，因为在返回Long 类型时就是null了，对 null进行拆箱返回基本类型，就会出现空指针这异常！

通过修改get()方法的返回值 ，从long —> Long，就可以解决问题。

#### [点我扫码关注微信公众号][Link 1] ####

#### 文章来源：[Java并发工具之ThreadLocal][Java_ThreadLocal] ####

--------------------

### 个人微信：CaiBaoDeCai ###

### 微信公众号名称：Java知者 ###

### 微信公众号 ID： JavaZhiZhe ###

### 谢谢关注！ ###

[image-20230608083233479]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/97e64a3a88954af9a1ae57dcff7afe40.png
[acf2b4c19862fb72feea570bd98f717b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/c5031eda195a4b81b9c3234f0a4f3f09.png
[4ae7e9ae34ae60c34796b3bc1d3327f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/e52a6faa39fc4e82958b54943bbd8d65.png
[0b6951cd01a57f109270e725e409f781.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/7eeae6f104e24dbd9cc7d6389d6bd5c6.png
[87e2bec058a42d77f4bef09e8044bb7d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/275820536a434443b21d3ffd49eea124.png
[7fc45272ca50ec45491e0a56a8d87a9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/f871ce4255a3402497c4ab73b2622201.png
[Link 1]: https://docs.qq.com/doc/DSVhXa2JraFpVVE9V
[Java_ThreadLocal]: https://mp.weixin.qq.com/s?__biz=MzU3NDgyMTIxMw==&mid=2247484796&idx=1&sn=95cd591da6d34641cba096c087c49956&chksm=fd2dc34eca5a4a58c342883f006921625ff46b152b117837004e7875974abf29faced7aa93af#rd