ThreadLocal用法-阿里云开发者社区

使用场景1

每个线程需要一个独享对象（通常是工具类，典型需要使用的类有SimpleDateFormat和Random）

每个Thread内有自己的实例副本，不共享

比喻：教材只有一本，一起做笔记有线程安全问题。复印后没有问题，使用ThradLocal相当于复印了教材。

将可能会发生线程冲突的类作为ThreadLocal的泛型：

//内部类，下面可以直接使用
class ThreadSafeFormat{
    public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        }
    };
}

date方法中使用上面的ThreadSafeFormat类中的dateFormatThreadLocal属性：

public class ThreadLocalNormalUsage00 {
    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
    public static void main(String[] args) {
        for(int i=0; i<300; i++){
            int finalI = i;
            threadPool.submit(new Runnable(){
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage00().date(finalI);
                    System.out.println(date);
                }
            });
        }
    }
    public String date(int seconds){
        Date date = new Date(1000 * seconds);
        //这样每个线程都有一个自己的simpleDateFormat，保证线程安全
        SimpleDateFormat simpleDateFormat = ThreadSafeFormat.dateFormatThreadLocal.get();
        return simpleDateFormat.format(date);
    }
}

使用场景2

每个线程内需要保存全局变量（例如在拦截器中获取用户信息），可以让不同方法直接使用，避免参数传递的麻烦

public class ThreadLocalNormalUsage02 {
    public static void main(String[] args) {
        new Service1().process();
    }
}
class Service1 {
    public void process() {
        User user = new User("朱上林");
        //将User对象存储到 ctx 中
        UserContextctx.ctx.set(user);
        new Service2().process();
    }
}
class Service2 {
    public void process() {
      //从ctx中取User对象
        User user = UserContextctx.ctx.get();
        System.out.println("Service2拿到用户名: " + user.name);
        new Service3().process();
    }
}
class Service3 {
    public void process() {
      //从ctx中取User对象
        User user = UserContextctx.ctx.get();
        System.out.println("Service3拿到用户名: " + user.name);
    }
}
class UserContextctx {
    public static ThreadLocal<User> ctx = new ThreadLocal<>();
}
class User {
    String name;
    public User(String name) {
        this.name = name;
    }
}

总结

让某个需要用到的对象实现线程之间的隔离（每个线程都有自己独立的对象）

可以在任何方法中轻松的获取到该对象

根据共享对象生成的时机选择使用initialValue方法还是set方法

对象初始化的时机由我们控制的时候使用initialValue 方式

如果对象生成的时机不由我们控制的时候使用 set 方式

原理

Thread

ThreadLocal

ThreadLocalMap

在Thread类内部有有ThreadLocal.ThreadLocalMap threadLocals = null;这个变量，它用于存储ThreadLocal，因为在同一个线程当中可以有多个ThreadLocal，并且多次调用get()所以需要在内部维护一个ThreadLocalMap用来存储多个ThreadLocal

ThreadLocal相关方法

T initialValue()

该方法用于设置初始值，并且在调用get()方法时才会被触发，所以是懒加载。

但是如果在get()之前进行了set()操作，这样就不会调用initialValue()。

通常每个线程只能调用一次本方法，但是调用了remove()后就能再次调用

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    //获取到了值直接返回resule
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //没有获取到才会进行初始化
    return setInitialValue();
}
private T setInitialValue() {
    //获取initialValue生成的值，并在后续操作中进行set，最后将值返回
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

void set(T t)

为这个线程设置一个新值

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

T get()

获取线程对应的value

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

void remove()

删除对应这个线程的值

ThreadLocal注意点

1.内存泄露；某个对象不会再被使用，但是该对象的内存却无法被收回

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;
        Entry(ThreadLocal<?> k, Object v) {
            //调用父类，父类是一个弱引用
            super(k);
            //强引用
            value = v;
        }
    }

强引用：当内存不足时触发GC，宁愿抛出OOM也不会回收强引用的内存

弱引用：触发GC后便会回收弱引用的内存

正常情况

当Thread运行结束后，ThreadLocal中的value会被回收，因为没有任何强引用了

非正常情况

当Thread一直在运行始终不结束，强引用就不会被回收，存在以下调用链 Thread–>ThreadLocalMap–>Entry(key为null)–>value因为调用链中的 value 和 Thread 存在强引用，所以value无法被回收，就有可能出现OOM。

JDK的设计已经考虑到了这个问题，所以在set()、remove()、resize()方法中会扫描到key为null的Entry，并且把对应的value设置为null，这样value对象就可以被回收。

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            //当ThreadLocal为空时，将ThreadLocal对应的value也设置为null
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }
    setThreshold(newLen);
    size = count;
    table = newTab;
}

但是只有在调用set()、remove()、resize()这些方法时才会进行这些操作，如果没有调用这些方法并且线程不停止，那么调用链就会一直存在，所以可能会发生内存泄漏。

2.如何避免内存泄漏（阿里规约）

调用remove()方法，就会删除对应的Entry对象，可以避免内存泄漏，所以使用完ThreadLocal后，要调用remove()方法。

class Service1 {
    public void process() {
        User user = new User("鲁毅");
        //将User对象存储到 holder 中
        UserContextHolder.holder.set(user);
        new Service2().process();
    }
}
class Service2 {
    public void process() {
        User user = UserContextHolder.holder.get();
        System.out.println("Service2拿到用户名: " + user.name);
        new Service3().process();
    }
}
class Service3 {
    public void process() {
        User user = UserContextHolder.holder.get();
        System.out.println("Service3拿到用户名: " + user.name);
        //手动释放内存，从而避免内存泄漏
        UserContextHolder.holder.remove();
    }
}

3.ThreadLocal的空指针异常问题

/**
 * ThreadLocal的空指针异常问题
 */
public class ThreadLocalNPE {
    ThreadLocal<Long> longThreadLocal = new ThreadLocal<>();
    public void set() {
        longThreadLocal.set(Thread.currentThread().getId());
    }
    public Long get() {
        return longThreadLocal.get();
    }
    public static void main(String[] args) {
        ThreadLocalNPE threadLocalNPE = new ThreadLocalNPE();
        //如果get方法返回值为基本类型，则会报空指针异常，如果是包装类型就不会出错
        System.out.println(threadLocalNPE.get());
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocalNPE.set();
                System.out.println(threadLocalNPE.get());
            }
        });
        thread1.start();
    }
}

空指针异常问题的解决：

如果get方法返回值为基本类型，则会报空指针异常，如果是包装类型就不会出错。这是因为基本类型和包装类型存在装箱和拆箱的关系，造成空指针问题的原因在于使用者。

4.共享对象问题

如果在每个线程中ThreadLocal.set()进去的东西本来就是多个线程共享的同一对象，比如static对象，那么多个线程调用ThreadLocal.get()获取的内容还是同一个对象，还是会发生线程安全问题。

5.优先使用框架的支持，而不是自己创造

例如在Spring框架中，如果可以使用RequestContextHolder，那么就不需要自己维护ThreadLocal，因为自己可能会忘记调用remove()方法等，造成内存泄漏。

ThreadLocal用法

使用场景1

使用场景2

总结

原理

ThreadLocal相关方法

ThreadLocal注意点

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

ThreadLocal用法

使用场景1

使用场景2

总结

原理

ThreadLocal相关方法

ThreadLocal注意点

热门文章

最新文章

相关电子书