1. 代码100分首页

threadlocal详解_threadlocal详解

小小码 • • 未分类 • 阅读 114
一键激活最新全家桶

threadlocal详解_threadlocal详解1、每个线程都有一个 ThreadLocalMap 对象，每个 ThreadLocalMap 里面都包含了一个 Entry[] 数组，而 Entry 是由 key（threadLocal）和 value（数据）组成。 2、Entry extends WeakReference，…

一、学习目标

1、每个线程都有一个 ThreadLocalMap 对象，每个 ThreadLocalMap 里面都包含了一个 Entry[] 数组，而 Entry 是由 key（threadLocal）和 value（数据）组成。

2、Entry extends WeakReference，是弱引用，注意的是，Entry 的 key（threadLocal）是弱引用会。而弱引用会在正常垃圾回收时被回收。

3、ThreadLocal 最常用的这四个方法：

  • get()
  • set()
  • remove()
  • initialValue()

除了 ThreadLocal#initialValue()，其他的方法都会调用 ThreadLocal.ThreadLocalMap#expungeStaleEntry()，将 key == null 的 entry，将其 value 设置为null，即数据清理工作，以便于gc垃圾回收。

为什么要做这样的清除？

  • 我们知道 Entry 对象里面包含了 ThreadLocal 和 value，ThreadLocal 是 WeakReference（弱引用）的 referent。每次垃圾回收期触发GC的时候，都会回收 WeakReference 的 referent，会将 referent 设置为null。那么 table 数组中就会存在很多 threadLocal = null 但是 value 不为空的 Entry，这种 Entry 的存在是没有任何实际价值的。

4、Entry 为什么要继承 WeakReference？

  • 避免内存泄漏：如果使用强引用，ThreadLocal 在用户进程不再被引用，但是只要线程不结束，在 ThreadLocalMap 中就还存在引用，无法被GC回收，会导致内存泄漏。
  • 另外在使用线程池技术的时候，由于线程不会被销毁，回收之后，下一次又会被重复利用，会导致 ThreadLocal 无法被释放，最终也会导致内存泄露问题。

5、ThreadLocal有哪些坑：

  • 内存泄露问题：

ThreadLocal即使使用了WeakReference（弱引用）也可能会存在内存泄露问题，因为 entry对象中只把key(即threadLocal对象)设置成了弱引用，但是value值没有。 还是会存在下面的强依赖：

Thread -> ThreaLocalMap -> Entry -> value

如何解决：

使用完ThreadLocal之后，手动调用一下调用ThreadLocal#remove()，该方法会把entry中的key(即threadLocal对象)和value一起清空。如果调用 ThreadLocal#get()、ThreadLocal#set(T value) ，但他们是基于垃圾回收器把key回收之后的基础之上触发的数据清理。如果出现垃圾回收器回收不及时的情况，也一样有问题。

  • 线程安全问题：

可能有些朋友认为使用了 ThreadLocal 就不会出现线程安全问题了，其实是不对的。假如我们定义了一个static的变量count，多线程的情况下，threadLocal中的value需要修改并设置count的值，它一样有问题。因为static的变量是多个线程共享的，不会再单独保存副本。

6、ThreadLocal相比synchronized、volatile的优势在哪里？

  • synchronized：在并发量小的情况下还好，如果并发量较大时，会有大量的线程等待同一个对象锁，会造成系统吞吐量直线下降。
  • volatile：修饰的变量不保留拷贝，直接访问主内存，主要用于一写多读的场景
  • ThreadLocal：给每一个线程都创建变量的副本，保证每个线程访问都是自己的副本，相互隔离，就不会出现线程安全问题

二、ThreadLocal的使用

1、线程不安全：

public class ThreadA extends Thread {

	private int i;
	private UnsafeThread unsafeThread;

	ThreadA(int i, UnsafeThread unsafeThread) {
		this.i = i;
		this.unsafeThread = unsafeThread;
	}

	@Override
	public void run() {
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		unsafeThread.calc();

		System.out.println("i:" + i + ",count:" + unsafeThread.getCount());
	}
}

public class UnsafeThread {

	private int count = 0;

	public void calc() {
		count++;
	}

	public int getCount() {
		return count;
	}

	public static void main(String[] args) throws InterruptedException {
		UnsafeThread testThread = new UnsafeThread();
		for (int i = 0; i < 20; i++) {
			new ThreadA(i, testThread).start();
		}

		Thread.sleep(200);
		System.out.println("realCount:" + testThread.getCount());
	}
}

运行结果：

i:6,count:8
i:0,count:8
i:17,count:13
i:7,count:8
i:2,count:8
i:11,count:8
i:8,count:11
i:5,count:11
i:13,count:11
i:15,count:11
i:14,count:11
i:10,count:8
i:3,count:11
i:12,count:11
i:9,count:8
i:19,count:15
i:4,count:15
i:16,count:15
i:1,count:15
i:18,count:15
realCount:15

我们可以看到：出现了线程安全问题

  • realCount最终出现错误，预计的结果应该是20，实际情况却是15
  • count出现重复

2、加入ThreadLocal，线程安全：

class ThreadB extends Thread {

	private int i;
	private SafeThread testThreadLocal;

	ThreadB(int i, SafeThread testThreadLocal) {
		this.i = i;
		this.testThreadLocal = testThreadLocal;
	}

	@Override
	public void run() {
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		testThreadLocal.calc();

		System.out.println("i:" + i + ",count:" + testThreadLocal.getCount());
	}
}

public class SafeThread {

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

	private int count = 0;

	public void calc() {
		threadLocal.set(count + 1);
	}

	public int getCount() {
		Integer integer = threadLocal.get();
		return integer != null ? integer : 0;
	}

	public static void main(String[] args) throws InterruptedException {
		SafeThread testThreadLocal = new SafeThread();
		for (int i = 0; i < 20; i++) {
			new ThreadB(i, testThreadLocal).start();
		}
		Thread.sleep(200);

		System.out.println("realCount:" + testThreadLocal.getCount());
	}

}

运行结果：

i:1,count:1
i:10,count:1
i:4,count:1
i:11,count:1
i:6,count:1
i:7,count:1
i:9,count:1
i:3,count:1
i:12,count:1
i:0,count:1
i:5,count:1
i:8,count:1
i:2,count:1
i:13,count:1
i:17,count:1
i:18,count:1
i:15,count:1
i:19,count:1
i:16,count:1
i:14,count:1
realCount:0

三、ThreadLocal的工作原理

1、线程不安全：

image

我们可以看到多个线程可以同时访问公共资源count，当某个线程在执行count++的时候，可能其他的线程正好同时也执行count++。但由于多个线程变量count的不可见性，会导致另外的线程拿到旧的count值+1，这样就出现了realCount预计是20，但是实际上是15的数据问题。

2、线程安全：

image

如图所示：

  • 往大的方向上说，ThreadLocal会给每一个线程都创建变量的副本，保证每个线程访问都是自己的副本，相互隔离。
  • 往小的方向上说，每个线程内部都有一个threadLocalMap，每个threadLocalMap里面都包含了一个entry数组，而entry是由threadLocal和数据（这里指的是count）组成的。

这样一来，每个线程都拥有自己专属的变量count。

示例2中，线程1调用calc方法时，会先调用的getCount方法，由于第一次调用threadLocal.get()返回是空的，所以getCount返回值是0。这样threadLocal.set(getCount() + 1)，就变成了threadLocal.set(0 + 1)，它会给线程1中threadLocal的数据值设置成1。

线程2再调用calc方法，同样会先调用getCount方法，由于第一次调用threadLocal.get()返回是空的，所以getCount返回值也是0。这样threadLocal.set(getCount() + 1)，会给线程2中threadLocal的数据值也设置成1。

……

最后每个线程的threadLocal中的数据值都是1。

还有，示例2中打印出来的realCount为什么是0呢？

  • 因为testThreadLocal.getCount()是在主线程中调用的，其他的线程改变只会影响自己的副本，不会影响原始变量，count初始值是0，所以最后还是0。

四、ThreadLocal的源码解析

1、Thread 类定义了一个叫 threadLocals 的成员变量，它的类型是ThreadLocal.ThreadLocalMap。很明显ThreadLocalMap是ThreadLocal的内部类，验证了我在图中画的内容，每个线程都有一个ThreadLocalMap对象。

Thread.class：

ThreadLocal.ThreadLocalMap threadLocals = null;

2、ThreadLocalMap 构造方法

ThreadLocal.ThreadLocalMap：

static class ThreadLocalMap {
    
    // Entry是WeakReference（弱引用）的子类，弱引用对象会在gc回收时被回收
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;
        
        // Entry 包含了 ThreadLocal 变量 和 Object的value
        Entry(ThreadLocal<?> k, Object v) {
            // ThreadLocal变量做为WeakReference的referen
            super(k);
            value = v;
        }
    }

    private static final int INITIAL_CAPACITY = 16;
    
    // 数组，它的类型是Entry
    private Entry[] table;

    private int size = 0;

    private int threshold; // Default to 0

    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }
    
    ...
}

3、ThreadLocal#get()：

public T get() {
    //获取当前线程
    Thread t = Thread.currentThread();
    
    //获取当前线程中的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    
    //如果可以查询到数据
    if (map != null) {
    
        //从ThreadLocalMap中获取entry对象，Entry 的 key 为 ThreadLocal
        ThreadLocalMap.Entry e = map.getEntry(this);
        
        //如果entry存在
        if (e != null) {
            @SuppressWarnings("unchecked")
            //获取entry中的值
            T result = (T)e.value;
            //返回获取到的值
            return result;
        }
    }
    
    //调用初始化方法，返回null
    return setInitialValue();
}

ThreadLocal#getMap(t)：

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

实际上是调用 Thread 类的变量：

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal#getEntry(ThreadLocal<?> key)：

private Entry getEntry(ThreadLocal<?> key) {
    //threadLocalHashCode是key的hash值
    //key.threadLocalHashCode & (table.length - 1)，
    //相当于threadLocalHashCode对table.length - 1的取余操作，
    //这样可以保证数组的下表在0到table.length - 1之间。
    int i = key.threadLocalHashCode & (table.length - 1);
    //获取下标对应的entry
    Entry e = table[i];
    //如果entry不为空，并且从弱引用中获取到的值(threadLocal) 和 key相同 
    if (e != null && e.get() == key)
        //返回获取到的entry
        return e;
    else
       //如果没有获取到entry或者e.get()获取不到数据，则清理空数据
        return getEntryAfterMiss(key, i, e);
}

entry是WeakReference的子类，那么e.get()方法会调用：Refernt#get()

public T get() {
  return this.referent;
}

返回的是一个引用，这个引用就是构造器传入的threadLocal对象。

image

ThreadLocal#getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e)

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;

    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

该方法里面会调用expungeStaleEntry方法，后面我们会重点介绍的

ThreadLocal#setInitialValue()：

private T setInitialValue() {
    //调用用户自定义的initialValue方法，默认值是null
    T value = initialValue();
    //获取当前线程
    Thread t = Thread.currentThread();
    //获取当前线程中的ThreadLocalMap，跟之前一样
    ThreadLocalMap map = getMap(t);
    //如果ThreadLocalMap不为空，
    if (map != null)
        //则覆盖key为当前threadLocal的值
        map.set(this, value);
    else
       //否则创建新的ThreadLocalMap
        createMap(t, value);
    //返回用户自定义的值 
    return value;
}

4、ThreadLocal#set()：

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

ThreadLocal.ThreadLocalMap#set(ThreadLocal<?> key, Object value)：

private void set(ThreadLocal<?> key, Object value) {
    //将table数组赋值给新数组tab
    Entry[] tab = table;
    //获取数组长度
    int len = tab.length;
    //跟之前一样计算数组中的下表
    int i = key.threadLocalHashCode & (len-1);

    //循环变量tab获取entry
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        //获取entry中的threadLocal对象 
        ThreadLocal<?> k = e.get();
        //如果threadLocal对象不为空，并且等于key
        if (k == key) {
            //覆盖已有数据
            e.value = value;
            //返回
            return;
        }
        //如果threadLocal对象为空
        if (k == null) {
            //创建一个新的entry赋值给已有key
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    //如果key不在已有数据中，则创建一个新的entry
    tab[i] = new Entry(key, value);
    //长度+1
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

replaceStaleEntry方法也会调用expungeStaleEntry方法。

5、ThreadLocal#remove()：

public void remove() {
 //还是那个套路，不过简化了一下
 //先获取当前线程，再获取线程中的ThreadLocalMap对象
 ThreadLocalMap m = getMap(Thread.currentThread());
 //如果ThreadLocalMap不为空
 if (m != null)
     //删除数据
     m.remove(this);
}

ThreadLocal.ThreadLocalMap#remove(ThreadLocal<?> key)：

private void remove(ThreadLocal<?> key) {
    //将table数组赋值给新数组tab
    Entry[] tab = table;
    //获取数组长度
    int len = tab.length;
    //跟之前一样计算数组中的下表
    int i = key.threadLocalHashCode & (len-1);
    //循环变量从下表i之后不为空的entry
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        //如果可以获取到threadLocal并且值等于key 
        if (e.get() == key) {
            //清空引用
            e.clear();
            //处理threadLocal为空但是value不为空的entry
            expungeStaleEntry(i);
            return;
        }
    }
}

其中的clear方法，也很简单，只是把引用设置为null，即清空引用

public void clear() {
    this.referent = null;
}

ThreadLocal#expungeStaleEntry(int staleSlot)


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

    //将位置staleSlot对应的entry中的value设置为null，有助于垃圾回收
    tab[staleSlot].value = null;
    //将位置staleSlot对应的entry设置为null，有助于垃圾回收
    tab[staleSlot] = null;
    //数组大小-1
    size--;

    Entry e;
    int i;
    //变量staleSlot之后entry不为空的数据
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        //获取当前位置的entry中对应的threadLocal 
        ThreadLocal<?> k = e.get();
        //threadLocal为空，说明是脏数据
        if (k == null) {
            //value设置为null，有助于垃圾回收
            e.value = null;
            //当前位置的entry设置为null
            tab[i] = null;
            //数组大小-1
            size--;
        } else {
            //重新计算位置
            int h = k.threadLocalHashCode & (len - 1);
            //如果h和i不相等，说明存在hash冲突
            //现在它前面的脏Entry被清理
            //该Entry需要向前移动，防止下次get()或set()的时候
            //再次因散列冲突而查找到null值
            if (h != i) {
                tab[i] = null;
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

该方法首先清除当前位置的脏Entry，然后向后遍历直到table[i]==null。在遍历的过程中如果再次遇到脏Entry就会清理。

如果没有遇到就会重新变量当前遇到的Entry，如果重新散列得到的下标h与当前下标i不一致，说明该Entry被放入Entry数组的时候发生了散列冲突（其位置通过再散列被向后偏移了），现在其前面的脏Entry已经被清除，所以当前Entry应该向前移动，补上空位置。否则下次调用set()或get()方法查找该Entry的时候会查找到位于其之前的null值。

为什么要做这样的清除？

  • 我们知道 Entry 对象里面包含了 threadLocal 和 value，threadLocal 是WeakReference（弱引用）的referent。每次垃圾回收期触发GC的时候，都会回收WeakReference的referent，会将referent设置为null。那么table数组中就会存在很多 threadLocal = null 但是 value 不为空的 Entry，这种 Entry的存在是没有任何实际价值的。
  • 这种数据通过getEntry是获取不到值，因为它里面有if (e != null && e.get() == key)这句判断。

为什么要使用WeakReference（弱引用）？

  • 避免内存泄漏：如果使用强引用，ThreadLocal在用户进程不再被引用，但是只要线程不结束，在ThreadLocalMap中就还存在引用，无法被GC回收，会导致内存泄漏。
  • 另外在使用线程池技术的时候，由于线程不会被销毁，回收之后，下一次又会被重复利用，会导致ThreadLocal无法被释放，最终也会导致内存泄露问题。

四、ThreadLocal有哪些坑

1、内存泄露问题：

ThreadLocal即使使用了WeakReference（弱引用）也可能会存在内存泄露问题，因为 entry对象中只把key(即threadLocal对象)设置成了弱引用，但是value值没有。 还是会存在下面的强依赖：

Thread -> ThreaLocalMap -> Entry -> value

如何解决：

使用完ThreadLocal之后，手动调用一下调用ThreadLocal#remove()，该方法会把entry中的key(即threadLocal对象)和value一起清空。如果调用 ThreadLocal#get()、ThreadLocal#set(T value) ，但他们是基于垃圾回收器把key回收之后的基础之上触发的数据清理。如果出现垃圾回收器回收不及时的情况，也一样有问题。

2、线程安全问题：

可能有些朋友认为使用了 ThreadLocal 就不会出现线程安全问题了，其实是不对的。假如我们定义了一个static的变量count，多线程的情况下，threadLocal中的value需要修改并设置count的值，它一样有问题。因为static的变量是多个线程共享的，不会再单独保存副本。

五、总结：

1、每个线程都有一个 ThreadLocalMap 对象，每个 ThreadLocalMap 里面都包含了一个 Entry[] 数组，而 Entry 是由 key（threadLocal）和 value（数据）组成。

2、Entry extends WeakReference，是弱引用，注意的是，Entry 的 key（threadLocal）是弱引用会。而弱引用会在正常垃圾回收时被回收。

3、ThreadLocal 最常用的这四个方法：

  • get()
  • set()
  • remove()
  • initialValue()

除了 ThreadLocal#initialValue()，其他的方法都会调用 ThreadLocal.ThreadLocalMap#expungeStaleEntry()，将 key == null 的 entry，将其 value 设置为null，即数据清理工作，以便于gc垃圾回收。

为什么要做这样的清除？

  • 我们知道 Entry 对象里面包含了 ThreadLocal 和 value，ThreadLocal 是 WeakReference（弱引用）的 referent。每次垃圾回收期触发GC的时候，都会回收 WeakReference 的 referent，会将 referent 设置为null。那么 table 数组中就会存在很多 threadLocal = null 但是 value 不为空的 Entry，这种 Entry 的存在是没有任何实际价值的。

4、Entry 为什么要继承 WeakReference？

  • 避免内存泄漏：如果使用强引用，ThreadLocal 在用户进程不再被引用，但是只要线程不结束，在 ThreadLocalMap 中就还存在引用，无法被GC回收，会导致内存泄漏。
  • 另外在使用线程池技术的时候，由于线程不会被销毁，回收之后，下一次又会被重复利用，会导致 ThreadLocal 无法被释放，最终也会导致内存泄露问题。

5、ThreadLocal有哪些坑：

  • 内存泄露问题：

ThreadLocal即使使用了WeakReference（弱引用）也可能会存在内存泄露问题，因为 entry对象中只把key(即threadLocal对象)设置成了弱引用，但是value值没有。 还是会存在下面的强依赖：

Thread -> ThreaLocalMap -> Entry -> value

如何解决：

使用完ThreadLocal之后，手动调用一下调用ThreadLocal#remove()，该方法会把entry中的key(即threadLocal对象)和value一起清空。如果调用 ThreadLocal#get()、ThreadLocal#set(T value) ，但他们是基于垃圾回收器把key回收之后的基础之上触发的数据清理。如果出现垃圾回收器回收不及时的情况，也一样有问题。

  • 线程安全问题：

可能有些朋友认为使用了 ThreadLocal 就不会出现线程安全问题了，其实是不对的。假如我们定义了一个static的变量count，多线程的情况下，threadLocal中的value需要修改并设置count的值，它一样有问题。因为static的变量是多个线程共享的，不会再单独保存副本。

6、ThreadLocal相比synchronized、volatile的优势在哪里？

  • synchronized：在并发量小的情况下还好，如果并发量较大时，会有大量的线程等待同一个对象锁，会造成系统吞吐量直线下降。
  • volatile：修饰的变量不保留拷贝，直接访问主内存，主要用于一写多读的场景
  • ThreadLocal：给每一个线程都创建变量的副本，保证每个线程访问都是自己的副本，相互隔离，就不会出现线程安全问题

六、参考：

mp.weixin.qq.com/s/uh8Q48FGK…

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
转载请注明出处: https://daima100.com/13561.html

赞 (0)
小小码小小码
0 0

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注