当先锋百科网

首页 1 2 3 4 5 6 7

1.ThreadLocal的相关面试题

1)Java中的引用类型有哪几种?
2)每种引用类型的特点?
3)每种引用类型的场景是什么?
4)ThreadLocal你了解吗?
5)ThreadLocal应用在什么地方?
6)Thread会产生内存泄漏吗?

在学习ThreadLocal之前,先了解一下java中的四种引用,大厂面试的时候,面试官一般都是先问四种引用,然后过渡到ThreadLocal。

2.Java中的引用类型

从Java SE2开始,就提供了四种类型的引用:强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的:第一是可以让程序员通过代码的方式决定某些对象的生命周期;第二是有利于JVM进行垃圾回收。
1)强引用:使用最普遍的引用,比如下面的这段代码中的o和str都是强引用

Object o = new Object();
String str = "hello world";

如果一个对象具有强引用,那么它永远不会被 GC,当内存空间不足时,JVM 宁愿抛出OutOfMemoryError(OOM),使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。如果想中断强引用和某个对象之间的关联,可以显示地将引用赋值为null,这样一来的话,JVM在合适的时间就会回收该对象。

2)软引用(SoftReference):软引用是用来描述一些有用但并不是必需的对象,在Java中用java.lang.ref.SoftReference类来表示。如果一个对象只具有软引用(Soft Reference),当内存空间充足时,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。因此,这一点可以很好地用来解决OOM的问题,并且这个特性很适合用来实现缓存:比如网页缓存、图片缓存等。

mport java.lang.ref.SoftReference;
 
public class Main {
    public static void main(String[] args) {
         
        SoftReference<String> sr = new SoftReference<String>(new String("hello"));
        System.out.println(sr.get());
    }
}

3)弱引用(WeakReference):弱引用也是用来描述非必需对象的,如果一个对象只具有弱引用(Weak Reference),其生命周期相比于软引用更加短暂。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会对它进行回收。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。在java中,用java.lang.ref.WeakReference类来表示。ThreadLocal中就是用的弱引用,具体怎么用的,下面会讲。

import java.lang.ref.WeakReference;
 
public class Main {
    public static void main(String[] args) {
     
        WeakReference<String> sr = new WeakReference<String>(new String("hello"));
         
        System.out.println(sr.get());//hello
        System.gc();                //通知JVM的gc进行垃圾回收
        System.out.println(sr.get()); //null
    }
}

4)虚引用(PhantomReference):虚引用和前面的软引用、弱引用不同,它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收,永远拿不到虚引用指向的对象。

要注意的是,虚引用必须和引用队列关联使用,当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会把这个虚引用加入到与之关联的引用队列中,相当于发出一个通知。程序(垃圾回收器)可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。虚引用被用来管理JVM中的堆外内存,JVM中有个DirectByteBuffer,管理操作操作系统的一小块内存(堆外内存),DirectByteBuffer没有的时候,会放到队列中,垃圾回收器发现这个虚引用被加载到队列中,就会清理堆外内存,如果不用虚引用,那么堆外内存就无法被清理,因为不是被JVM管理的。

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
 
 
public class Main {
    public static void main(String[] args) {
        ReferenceQueue<String> queue = new ReferenceQueue<String>();
        PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
        System.out.println(pr.get());
    }
}

3.ThreadLocal

3.1 ThreadLocal是什么

ThreadLocal是在Thread类之外实现的一个功能(java.lang.ThreadLocal), 它会为每个线程分别存储一份唯一的数据。正如它的名字所说的,它为线程提供了本地存储,也就是说你所创建出来变量对每个线程实例来说都是唯一的。当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本。通过下面这段代码,可以更好的理解。

public class ThreadLocal1 {
    volatile static Person p = new Person();
    
    public static void main(String[] args) {
                
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            System.out.println(p.name);
        }).start();
        
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            p.name = "lisi";
        }).start();
    }
}

class Person {
    String name = "zhangsan";
}

结果为lisi。
现在这两个线程是互相影响的;第二个线程改了名字之后,第一个线程就能读的到了;
有的时候就想线程2的改变,不想让线程1知道,这时候怎么做?

/**
 * ThreadLocal线程局部变量
 *
 * ThreadLocal是使用空间换时间,synchronized是使用时间换空间
 * 比如在hibernate中session就存在与ThreadLocal中,避免synchronized的使用
 *
 * 运行下面的程序,理解ThreadLocal
 */
package yxxy.c_022;

import java.util.concurrent.TimeUnit;

public class ThreadLocal2 {
    static ThreadLocal<Person> tl = new ThreadLocal<>();
    
    public static void main(String[] args) {
                
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            System.out.println(tl.get());
        }).start();
        
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tl.set(new Person());
        }).start(); 
    }
    
    static class Person {
        String name = "zhangsan";
    }
}

结果为null。
ThreadLocal的意思就是,ThreadLocal里面的变量,自己的线程自己用;你别的线程里要想用的话,不好意思你自己往里扔;不能用我线程里面放的东西;相当于每个线程都有自己的变量,互相之间不会产生冲突;可以理解为person对象每个线程里面拷贝了一份,改的都是自己那份,都是自己线程本地的变量,所以空间换时间;ThreadLocal在效率上会更高一些;有一些需要加锁的对象,如果它们在使用的时候自己进行的改变,自己维护这个状态,不用通知其他线程,那么这个时候可以使用ThreadLocal;

3.2 从数据结构入手

下图为ThreadLocal的内部结构图
在这里插入图片描述
从上面的结构图,我们已经窥见ThreadLocal的核心机制:

  • 每个Thread线程内部都有一个Map。
  • Map里面存储线程本地对象(key)和线程的变量副本(value)
  • 但是,Thread内部的Map是由ThreadLocal维护的,由ThreadLocal负责向map获取和设置线程的变量值。

3.3 ThreadLocal底层原理

当一个线程往ThreadLocal里存放数据时,

  1. 会先获取当前线程
  2. 得到当前线程的ThreadLocalMap,如果当前线程的ThreadLocalMap为空,就新建一个
  3. 把ThreadLocal对象当做key,把数据当做value存放到map中

源码如下:
set(T value)方法

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value); //在map中以ThreadLocal对象最为key,值作为value
        else
            createMap(t, value);
    }

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

下面来看getMpa(Thread t)

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

返回的是t.threadLocals,一个ThreadLocalMap对象,就是一个map。
下面来看一下这个ThreadLocals

这是Thread类中的代码,也就是说,每创建一个线程,线程就有一个ThreadLocalMap(threadLocals)。当一个线程往ThreadLocal里存放数据时,实际上是存到了自己的ThreadLocalMap里,并且在这个map中,以ThreadLocal对象作为key,以要存的值作为value,这就解释了,为什么一个线程往ThreaLocal里存放数据时,其他的线程无法得到数据。
在这里插入图片描述

get()方法

  1. 获取当前线程的ThreadLocalMap对象(threadLocals)
  2. 从map中获取线程存储的K-V Entry节点。
  3. 从Entry节点获取存储的Value副本值返回。
  4. map为空的话返回初始值null,即线程变量副本为null,在使用时需要注意判断NullPointerException。
 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();
    }

protected T initialValue() {
        return null;
    }

private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

remove()方法

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

3.4 ThreadLocalMap

ThreadLocalMap是ThreadLocal的内部类,没有实现Map接口,用独立的方式实现了Map的功能,其内部的Entry也独立实现。
在这里插入图片描述
在ThreadLocalMap中,也是用Entry来保存K-V结构数据的。但是Entry中key只能是ThreadLocal对象,这点被Entry的构造方法已经限定死了。从源码中可以看出,Entry类继承了弱引用类,构造函数中,调用了弱引用类的构造函数,也就是说,Entry对象和ThreadLocal对象之间是弱引用,但只有Key是弱引用类型的,Value并非弱引用。

 static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

ThreadLocalMap的成员变量:

private static final int INITIAL_CAPACITY = 16;

        /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

        /**
         * The number of entries in the table.
         */
        private int size = 0;

        /**
         * The next size value at which to resize.
         */
        private int threshold; // Default to 0

Hash冲突怎么解决

和HashMap的最大的不同在于,ThreadLocalMap结构非常简单,没有next引用,也就是说ThreadLocalMap中解决Hash冲突的方式并非链表的方式,而是采用线性探测的方式,所谓线性探测,就是根据初始key的hashcode值确定元素在table数组中的位置,如果发现这个位置上已经有其他key值的元素被占用,则利用固定的算法寻找一定步长的下个位置,依次判断,直至找到能够存放的位置。

ThreadLocalMap解决Hash冲突的方式就是简单的步长加1或减1,寻找下一个相邻的位置

private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

        /**
         * Decrement i modulo len.
         */
private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }

显然ThreadLocalMap采用线性探测的方式解决Hash冲突的效率很低,如果有大量不同的ThreadLocal对象放入map中时发送冲突,或者发生二次冲突,则效率很低。

所以这里引出的良好建议是:每个线程只存一个变量,这样的话所有的线程存放到map中的Key都是相同的ThreadLocal,如果一个线程要保存多个变量,就需要创建多个ThreadLocal,多个ThreadLocal放入Map中时会极大的增加Hash冲突的可能。

3.5 ThreadLocal 内存泄漏问题

内存泄漏:对于应用程序来说,当对象已经不再被使用,但是Java的垃圾回收器不能回收它们的时候,就产生了内存泄露。
在这里插入图片描述
现在,根据图片重新理一下思路,一个线程使用ThreadLocal存放数据时(调用set方法),会先获取当前线程,并且获取线程的ThreadLocalMap,tl与ThreadLocal之间是强引用,ThreadLocalMap中,存储的是Entry对象,Entry对象中key与ThreadLocal之间是弱引用。

ThreadLocal中为什么要用弱引用
若是强引用的话,即使tl = null,但key的引用依然指向ThreadLocal对象,所以会有内存泄漏(一直占着内存不放),而使用弱引用则不会,当tl=null时,ThreadLocal会在下一次GC时被回收。

使用了弱引用,还是会有内存泄漏,ThreadLocal被回收,key的值变为null,则导致整个value再也无法被访问到,因此依然存在内存泄漏。所以在使用完ThreadLocal后,要调用remove()方法,删除对应的Entry对象(这里是另entry = null)。

3.6 ThreadLocal的使用场景

  • 线程间数据隔离
  • Spring中的声明式事务
  • 数据库连接,Session会话管理,会将Connection对象放到ThreadLocal中,这样一个线程中所有方法使用的都是同一个Connection对象,不同线程使用的是不同的Connection对象。

总结
Java中的四种引用:强软弱虚。强引用:最普通的一个引用,只有等于null的时候,才会被回收。软引用:当JVM内存满的时候,会将软引用的对象进行回收,软引用主要用于图片缓存、网页缓存。虚引用:当一个对象只被虚引用时,下一次GC时,会被回收,虚引用主要用于HashMap、ThreadLocalMap中防止内存泄漏。虚引用:虚引用的对象,无法获得,必须和队列一起使用,当被回收时,会被放进队列,相当于给出一个通知,虚引用主要用于管理堆外内存。
ThreadLocal:ThreadLocal是给线程提供了一个本地存储,当一个线程使用ThreadLocal存储数据时,其他线程是看不到的,原理是,当调用ThreadLocal的set()方法时,会先获取当前线程,然后获取到线程的ThreadLocalMap,将ThreadLocal作为key、数据作为value存储起来,当然ThreadLocal将key、value封装成了一个Entry对象,Entry类继承了弱引用类,key和ThreadLocal之间是弱引用,这样避免了ThreadLocal对象内存泄漏,为了避免value内存泄漏,每次使用完之后,调用remove方法,对Entry对象进行回收。

参考:马士兵老师公开课
ThreadLocal-面试必问深度解析

文中如有不足之处,欢迎指正,谢谢!