并发编程（四）之ThreadLocal详解

最新推荐文章于 2024-05-20 15:12:11 发布

汪了个王

最新推荐文章于 2024-05-20 15:12:11 发布

阅读量690

点赞数 2

分类专栏：并发编程文章标签：多线程

本文链接：https://blog.csdn.net/weixin_43477531/article/details/106954577

版权

并发编程专栏收录该内容

22 篇文章 8 订阅

订阅专栏

概述

多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，那一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。

ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建了ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题。

ThreadLocal简单使用

常用方法

void set(Object value)	设置当前线程的线程局部变量的值
public Object get()	该方法返回当前线程所对应的线程局部变量。
public void remove()	将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是 JDK5.0 新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动
protected Object initialValue()	返回该线程局部变量的初始值，该方法是一个 protected 的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第 1 次调用 get()或 set(Object)时才执行，并且仅执行 1 次。ThreadLocal 中的缺省实现直接返回一个 null

简单使用

在不使用ThreadLocal的情况下：

public class NoThreadLocal {

    static Integer count=new Integer(1);

    public static class TestNoThreadLocal implements Runnable{

        private int id;

        public TestNoThreadLocal(int id) {
            this.id = id;
        }
        @Override
        public void run() {
            count=count+id;
            System.out.println(Thread.currentThread().getName()+"count:"+count);
        }
    }

    /**
     * 运行三个线程
     */
    public void startThread(){
        Thread[] runs=new Thread[3];
        for (int i = 0; i < runs.length; i++) {
            runs[i]=new Thread(new TestNoThreadLocal(i));
        }
        for (int i = 0; i < runs.length; i++) {
            runs[i].start();
        }
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        new NoThreadLocal().startThread();
    }
}

打印如下：

Thread-0-count:1
Thread-1-count:2
Thread-2-count:4

使用ThreadLocal的情况下：

public class NoThreadLocal {

    //static Integer count=new Integer(1);
    static ThreadLocal<Integer> count=new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            return 1;
        }
    };

    public static class TestNoThreadLocal implements Runnable{

        private int id;

        public TestNoThreadLocal(int id) {
            this.id = id;
        }
        @Override
        public void run() {
            Integer i = count.get();
            i=i+id;
            count.set(i);
            System.out.println(Thread.currentThread().getName()+"-count:"+count.get());
        }
    }

    /**
     * 运行三个线程
     */
    public void startThread(){
        Thread[] runs=new Thread[3];
        for (int i = 0; i < runs.length; i++) {
            runs[i]=new Thread(new TestNoThreadLocal(i));
        }
        for (int i = 0; i < runs.length; i++) {
            runs[i].start();
        }
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        new NoThreadLocal().startThread();
    }
}

打印如下：

Thread-0-count:1
Thread-1-count:2
Thread-2-count:3

ThreadLocal的实现原理

Thread类中有两个变量threadLocals和inheritableThreadLocals，二者都是ThreadLocal内部类ThreadLocalMap类型的变量，我们通过查看内部内ThreadLocalMap可以发现实际上它类似于一个HashMap。在默认情况下，每个线程中的这两个变量都为null

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

只有当线程第一次调用ThreadLocal的set或者get方法的时候才会创建他们。除此之外，每个线程的本地变量不是存放在ThreadLocal实例中，而是放在调用线程的ThreadLocals变量里面（前面也说过，该变量是Thread类的变量）。也就是说，ThreadLocal类型的本地变量是存放在具体的线程空间上，其本身相当于一个装载本地变量的工具壳，通过set方法将value添加到调用线程的threadLocals中，当调用线程调用get方法时候能够从它的threadLocals中取出变量。如果调用线程一直不终止，那么这个本地变量将会一直存放在他的threadLocals中，所以不使用本地变量的时候需要调用remove方法将threadLocals中删除不用的本地变量。

set方法源码

public void set(T value) {
	//1.获取当前线程
	Thread t = Thread.currentThread();
	//2.以当前线程作为key，去查找对应的线程变量，找到对应的map
    ThreadLocalMap map = getMap(t);
    //3.如果map不为null直接添加本地变量，key为当前线程，值为添加的本地变量值
    if (map != null)
            map.set(this, value);
    //4.如果map为null，说明首次添加，需要首先创建出对应的map
    else
        createMap(t, value);
}

在上面的代码中，2处调用getMap方法获得当前线程对应的threadLocals，该方法代码如下：

ThreadLocalMap getMap(Thread t) {
	//获取线程自己的变量threadLocals，并绑定到当前调用线程的成员变量threadLocals上
	return t.threadLocals;
}

如果调用getMap方法返回值不为null，就直接将value值设置到threadLocals中（key为当前线程引用，值为本地变量）；如果getMap方法返回null说明是第一次调用set方法（前面说到过，threadLocals默认值为null，只有调用set方法的时候才会创建map），这个时候就需要调用createMap方法创建threadLocals，该方法如下所示:

void createMap(Thread t, T firstValue) {
	t.threadLocals = new ThreadLocalMap(this, firstValue);
}

createMap方法不仅创建了threadLocals，同时也将要添加的本地变量值添加到了threadLocals中。

get方法源码

public T get() {
    //1.获取当前线程
    Thread t = Thread.currentThread();
    //2.获取当前线程的threadLocals变量
    ThreadLocalMap map = getMap(t);
    //3.如果threadLocals变量不为null，就可以在map中查找到本地变量的值
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //4.执行到此处，threadLocals为null，调用该更改初始化当前线程的threadLocals变量
    return setInitialValue();
}

private T setInitialValue() {
    //protected T initialValue() {return null;}
    T value = initialValue();
    //1.获取当前线程
    Thread t = Thread.currentThread();
    //2.以当前线程作为key值，去查找对应的线程变量，找到对应的map
    ThreadLocalMap map = getMap(t);
    //3.如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值
    if (map != null)
        map.set(this, value);
    //4.如果map为null，说明首次添加，需要首先创建出对应的map
    else
        createMap(t, value);
    return value;
}

remove方法的实现

remove方法判断该当前线程对应的threadLocals变量是否为null，不为null就直接删除当前线程中指定的threadLocals变量

public void remove() {
    //获取当前线程绑定的threadLocals
     ThreadLocalMap m = getMap(Thread.currentThread());
     //如果map不为null，就移除当前线程中指定ThreadLocal实例的本地变量
     if (m != null)
         m.remove(this);
 }

ThreadLocal不支持继承性

同一个ThreadLocal变量在父线程中被设置值后，在子线程中是获取不到的。（threadLocals中为当前调用线程对应的本地变量，所以二者自然是不能共享的）

public class NoExtends {

    //1.创建ThreadLocal变量
    public static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        //2.在main线程中添加main线程的本地变量
        threadLocal.set("mainVal");
        //3.新创建一个子线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程中的本地变量值:"+threadLocal.get());
            }
        });
        thread.start();
        //4.输出main线程中的本地变量值
        System.out.println("mainx线程中的本地变量值:"+threadLocal.get());
    }
}

ThreadLocal引发内存泄漏分析

首先我们先看看ThreadLocalMap的类图，在前面的介绍中，我们知道ThreadLocal只是一个工具类，他为用户提供get、set、remove接口操作实际存放本地变量的threadLocals（调用线程的成员变量），也知道threadLocals是一个ThreadLocalMap类型的变量，下面我们来看看ThreadLocalMap这个类。

引用

Object o=new Object();

这个 o,我们可以称之为对象引用，而 new Object()我们可以称之为在内存中产生了一个对象实例。

当写下 o=null 时，只是表示 o 不再指向堆中 object 的对象实例，不代表这个对象实例不存在了。

强引用

就是指在程序代码之中普遍存在的，类似“Object obj=new Object（）” 这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象实例。

软引用

是用来描述一些还有用但并非必需的对象。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象实例列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。在 JDK 1.2 之后，提供了 SoftReference 类来实现软引用。

弱引用

也是用来描述非必需对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象实例只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象实例。在 JDK 1.2 之后，提供了 WeakReference 类来实现弱引用。

虚引用

也称为幽灵引用或者幻影引用，它是最弱的一种引用关系。一个对象实例是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象实例被收集器回收时收到一个系统通知。在 JDK 1.2 之后，提供了PhantomReference 类来实现虚引用。

内存泄漏现象

代码如下：

public class ThreadLocalOOM {
    private static final int TASK_LOOP_SIZE = 500;

    final static ThreadPoolExecutor poolExecutor
            = new ThreadPoolExecutor(5, 5,
            1,
            TimeUnit.MINUTES,
            new LinkedBlockingQueue<>());

    static class LocalVariable {
    	/*5M大小的数组*/
        private byte[] a = new byte[1024*1024*5];
    }

    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        /*5*5=25*/
        for (int i = 0; i < TASK_LOOP_SIZE; ++i) {
            poolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                	//5M大小的数组  
                    new LocalVariable();
                    System.out.println("use local varaible");
                }
            });
            Thread.sleep(100);
        }
        System.out.println("pool execute over");
    }
}

为了演示，把堆的大小设置为如下

从上图可以看出内存占用大小在25M左右，因为每个任务中会不断 new 出一个 5M 的数组，5*5=25M，这是很合理的。

使用ThreadLocal，代码如下：

public class ThreadLocalOOM {
    private static final int TASK_LOOP_SIZE = 500;

    final static ThreadPoolExecutor poolExecutor
            = new ThreadPoolExecutor(5, 5,
            1,
            TimeUnit.MINUTES,
            new LinkedBlockingQueue<>());

    static class LocalVariable {
        private byte[] a = new byte[1024*1024*5];/*5M大小的数组*/
    }

    final static ThreadLocal<LocalVariable> localVariable
            = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        /*5*5=25*/
        for (int i = 0; i < TASK_LOOP_SIZE; ++i) {
            poolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    localVariable.set(new LocalVariable());
                    System.out.println("use local varaible");
                }
            });

            Thread.sleep(100);
        }
        System.out.println("pool execute over");
    }
}

从上图可以看出使用之后内存占用最高升至 150M，一般情况下稳定在 90M 左右，那么加入一个

ThreadLocal 后，内存的占用真的会这么多？这里我们调用remove方法再次尝试。

可以看见最高峰的内存占用也在 25M 左右，完全和我们不加 ThreadLocal 表现一样。

这就充分说明，确实发生了内存泄漏。

分析ThreadLocalMap内部实现

我们知道ThreadLocalMap内部实际上是一个Entry数组private Entry[] table，我们先看看Entry的这个内部类

/**
 * 是继承自WeakReference的一个类，该类中实际存放的key是
 * 指向ThreadLocal的弱引用和与之对应的value值(该value值
 * 就是通过ThreadLocal的set方法传递过来的值)
 * 由于是弱引用，当get方法返回null的时候意味着不在被引用
 */
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** value就是和ThreadLocal绑定的 */
    Object value;

    //k：ThreadLocal的引用，被传递给WeakReference的构造方法
    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}
//WeakReference构造方法(public class WeakReference<T> extends Reference<T> )
public WeakReference(T referent) {
    super(referent); //referent：ThreadLocal的引用
}

//Reference构造方法
Reference(T referent) {
    this(referent, null);//referent：ThreadLocal的引用
}

Reference(T referent, ReferenceQueue<? super T> queue) {
    this.referent = referent;
    this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}

根据上面对 ThreadLocal 的分析，我们可以知道每个 Thread 维护一个ThreadLocalMap，这个映射表的key 是 ThreadLocal 实例本身，value 是真正需要存储的 Object，也就是说 ThreadLocal 本身并不存储值，它只是作为一个 key 来让线程从 ThreadLocalMap 获取 value。仔细观察 ThreadLocalMap，这个 map 是使用 ThreadLocal 的弱引用作为 Key 的，弱引用的对象在 GC 时会被回收。

因此使用了 ThreadLocal 后，引用链如下图所示

图中的虚线表示弱引用

这样，当把threadlocal 变量置为 null 以后，没有任何强引用指向 threadlocal实例，所以 threadlocal将会被 gc 回收。这样一来，ThreadLocalMap 中就会出现key 为 null 的 Entry，就没有办法访问这些 key 为 null 的 Entry 的 value，如果当前线程再迟迟不结束的话，这些 key 为 null 的 Entry 的 value 就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value，而这块 value 永远不会被访问到了，所以存在着内存泄露。只有当前 thread 结束以后，current thread 就不会存在栈中，强引用断开， Current Thread、Map value 将全部被 GC 回收。最好的做法是在不需要使用ThreadLocal 变量后，都调用它的 remove()方法，清除数据。

其实考察 ThreadLocal 的实现，我们可以看见，无论是 get()、set()在某些时候，调用了expungeStaleEntry 方法用来清除 Entry 中 Key 为 null 的 Value，但是这是不及时的，也不是每次都会执行的，所以一些情况下还是会发生内存泄露。只有 remove()方法中显式调用了 expungeStaleEntry 方法。从表面上看内存泄漏的根源在于使用了弱引用，但是另一个问题也同样值得思考：

为什么使用弱引用而不是强引用？

下面我们分两种情况讨论：

key 使用强引用

引用 ThreadLocal 的对象被回收了，但是 ThreadLocalMap还持有 ThreadLocal 的强引用，如果没有手动删除，ThreadLocal 的对象实例不会被回收，导致 Entry 内存泄漏。
key 使用弱引用

引用的 ThreadLocal 的对象被回收了，由于 ThreadLocalMap持有 ThreadLocal 的弱引用，即使没有手动删除，ThreadLocal的对象实例也会被回收。value 在下一次 ThreadLocalMap 调用 set，get，remove 都有机会被回收。

比较两种情况，我们可以发现：由于 ThreadLocalMap 的生命周期跟 Thread一样长，如果都没有手动删除对应 key，都会导致内存泄漏，但是使用弱引用可以多一层保障。

因此，ThreadLocal 内存泄漏的根源是：由于 ThreadLocalMap 的生命周期跟Thread 一样长，如果没有手动删除对应 key 就会导致内存泄漏，而不是因为弱引用。

注意

当 ThreadLocal 存储很多 Key 为 null 的 Entry 的时候，而不再去调用 remove、get、set 方法，那么将导致内存泄漏。

使用线程池+ThreadLocal时要小心，因为这种情况下，线程是一直在不断的重复运行的，从而也就造成了 value 可能造成累积的情况。

小结

JVM 利用设置 ThreadLocalMap 的 Key 为弱引用，来避免内存泄露
JVM 利用调用 remove、get、set 方法的时候，回收弱引用

错误使用ThreadLocal导致线程不安全

代码如下：

public class ThreadLocalUnsafe implements Runnable {

    public static Number number = new Number(0);

    public static ThreadLocal<Number> value = new ThreadLocal<Number>() {
    };

    @Override
    public void run() {
        //每个线程计数加一
        number.setNum(number.getNum()+1);
      //将其存储到ThreadLocal中
        value.set(number);
        SleepTools.ms(2);
        //输出num值
        System.out.println(Thread.currentThread().getName()+"="+value.get().getNum());
    }



    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(new ThreadLocalUnsafe()).start();
        }
    }

    private static class Number {
        public Number(int num) {
            this.num = num;
        }

        private int num;

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public String toString() {
            return "Number [num=" + num + "]";
        }
    }

}

打印如下：

Thread-4=5
Thread-2=5
Thread-1=5
Thread-3=5
Thread-0=5

为什么每个线程都输出 5？难道他们没有独自保存自己的 Number 副本吗？为什么其他线程还是能够修改这个值？仔细考察 ThreadLocal 和 Thead 的代码，我们发现 ThreadLocalMap 中保存的其实是对象的一个引用，这样的话，当有其他线程对这个引用指向的对象实例做修改时，其实也同时影响了所有的线程持有的对象引用所指向的同一个对象实例。这也就是为什么上面的程序为什么会输出一样的结果：5 个线程中保存的是同一 Number 对象的引用，在线程睡眠的时候，其他线程将 num 变量进行了修改，而修改的对象 Number 的实例是同一份，因此它们最终输出的结果是相同的。而上面的程序要正常的工作，应该的用法是让每个线程中的 ThreadLocal 都应该持有一个新的 Number 对象。

ThreadLocal正确的使用方法

每次使用完ThreadLocal都调用它的remove()方法清除数据
将ThreadLocal变量定义成private static，这样就一直存在ThreadLocal的强引用，也就能保证任何时候都能通过ThreadLocal的弱引用访问到Entry的value的值，进而清除掉。

汪了个王

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
并发编程（四）之ThreadLocal详解

概述多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，那一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。 ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建了ThreadLocal变量，那么访问
复制链接

扫一扫