Java并发工具之ThreadLocal

一、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();
    }
}

打印结果:

两个方案都可以解决线程安全问题,但是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;
    }
}

打印结果:

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

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

3. ThreadLocal 的两个使用方式

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

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

4. ThreadLocal的好处

  • 线程安全

  • 不需要加锁,执行效率高

  • 更高效的利用内存,节省开销

    相比于每个任务都新建一个SimpleDateFormat,显然用ThreadLocal可以节省内存和开销

  • 避免传参的繁琐操作

    无论是场景一的工具类,还是场景二的用户名,都可以在任务地方直接通过ThreadLocal拿到,再也不需要在方法的形参中再定义传入相同的参数。ThreadLocal使代码耦合度更低,更优雅。

三、ThreadLocal 原理

1. ThreadLocal 与 Thread 的关系

  • 每一个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();
    }
}

打印结果:

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

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

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

点我扫码关注微信公众号

文章来源:Java并发工具之ThreadLocal


个人微信:CaiBaoDeCai

微信公众号名称:Java知者

微信公众号 ID: JavaZhiZhe

谢谢关注!

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值