ThreadLocal说明

强引用 正常的引用都是强引用

// 创建M对象，重写finalize方法
public class M {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("GC回收之前调用finalize");
    }
}

/**
 * 对象的finlize会在对象被回收的时间调用，不能将耗时特别长的东西，
 * 放入finalize里面比如关闭文件IO，关闭数据库连接等，可能导致对象的回收时间增长，最终出现OOM；
 * @author hxp 
 * @create 2020-08-05 20:23
 */
public class NormalRef {
    public static void main(String[] args) throws IOException {
        M m = new M(); 
        m = null;
        System.gc();
        System.in.read(); // 阻塞main线程,给垃圾回收线程执行时间
    }
}

软引用 使用场景 缓存

/** -Xmx20m
 * @author hxp 软引用 使用场景 缓存
 * 内存够用的情况下软引用不会被回收
 * heap将装不下，这个时候系统会垃圾回收，先回收一次，如果不够会把软引用回收掉的情况下
 * @create 2020-08-05 20:39
 */
public class SoftRef {
    public static void main(String[] args) {
        // 变量softReference 到 对象SoftReference为强引用
        // 对象SoftReference 指向 new byte[1024 * 1024 * 10]为软引用
        SoftReference<byte[]> softReference = new SoftReference<>(new byte[1024 * 1024 * 10]);
        System.out.println("第一次 正常获取："+softReference.get()); // 可以获取到
        System.gc();
        try {
            Thread.sleep(500);// 为了等待gc完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 内存够用的情况下软引用不会被回收
        System.out.println("第二次 内存够用的情况下手动GC再次获取："+softReference.get());

        // 再分配一个数组，heap将装不下，这个时候系统会垃圾回收，先回收一次，如果不够会把软引用回收掉jdk7的情况下
        byte[] bytes = new byte[1024 * 1024 * 5];  // 1024 * 1024 * 10
        System.out.println("第三次 内存不够的情况下再次获取："+softReference.get());
    }
}

执行结果

第一次 正常获取：[B@424c0bc4
第二次 内存够用的情况下手动GC再次获取：[B@424c0bc4
第三次 内存不够的情况下再次获取：[B@424c0bc4

Process finished with exit code 0

将 byte[] bytes = new byte[1024 * 1024 * 10];
执行结果如下：

第一次 正常获取：[B@424c0bc4
第二次 内存够用的情况下手动GC再次获取：[B@424c0bc4
第三次 内存不够的情况下再次获取：nulls

Process finished with exit code 0

第三次获取数据为 null，说明在head为20m的时候，当我们分类第二bytes的时候内存不够，导致第一个softReference 指向的软引用被回收

弱引用 使用场景ThreadLocal中防止内存泄漏

/**
 * @author hxp 弱引用 使用场景ThreadLocal中防止内存泄漏
 * @create 2020-08-05 20:53
 */
public class WeakRef {
    public static void main(String[] args) {
        //对象WeakReference 指向 new M()为弱引用
        WeakReference<M> wr = new WeakReference<>(new M());
        System.out.println("gc之前"+wr.get());
        System.gc(); // 弱引用在经历一次GC之后就会被回收
        System.out.println("gc之后"+wr.get());
    }
}

执行结果

gc之前com.hxp.threadlocal.M@42e26948
GC回收之前调用finalize
gc之后null

虚引用 使用场景 JVM内部用来管理直接内存

/**
 * @author hxp 虚引用 使用场景 JVM内部用来管理直接内存
 * @create 2020-08-05 20:59
 */
public class PhantomRef {
    private static final ReferenceQueue<M>  queue = new ReferenceQueue<>();
    public static void main(String[] args) {
        PhantomReference<M> phantomReference = new PhantomReference<>(new M(), queue);
        // 虚引用用于管理操作系统直接内存，不在JVM中
        System.out.println(phantomReference.get()); // 执行结果为 null
    }

}

ThreadLocal示例

下面代码首先创建一个 threadLocal对象，开启两个线程，一个线程向threadLocal里面设置值，一个线程向threadLocal里面获取值， 获取不到值说明threadLocal对于多线程具有天然的隔离性。

/**
 * @author hxp  Threadlocal使用场景：
 *  spring  trsaction事务的处理
 *  mybatis关于分页的处理
 * @create 2020-08-05 21:15
 */
public class ThreadLocalTest {
    // 创建一个空的Threadlocal对象,用tl指向ThreadLocal对象
    static ThreadLocal<Persion> tl= new ThreadLocal<>();

    public static void main(String[] args) {

        // 一个线程每隔2秒从共享变量里面获取Persion
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 没有拿到persion,说明tl对于多线程具有天然的隔离性
            System.out.println(tl.get()); // 执行结果null 
        }).start();

        // 一个线程每隔1秒从共享变量里面放入Persion
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 向 tl里面设置对象
            tl.set(new Persion());
        }).start();

    }

    static class Persion {
        String name = "zhangsan";
    }
}

threadLocal源码解读

// threadLocal的set方法
public void set(T value) {
   Thread t = Thread.currentThread(); // 1.获取当前线性
   ThreadLocalMap map = getMap(t); // 拿到当前线程的一个threadLocals属性map
   //ThreadLocalMap getMap(Thread t) {
   //	return t.threadLocals;  其实是返回当前线程的一个属性map
   //}
   
   if (map != null)
   // 将tl作为key,需要设置的值作为value 放入当前线程的一个map属性中
   // 此处的this指的是调用者tl
       map.set(this, value); // 
   else
       createMap(t, value);
}

继续看 map.set(this, value)里面

private void set(ThreadLocal<?> key, Object value) {

    // We don't use a fast path as with get() because it is at
    // least as common to use set() to create new entries as
    // it is to replace existing ones, in which case, a fast
    // path would fail more often than not.

    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

        if (k == key) {
            e.value = value;
            return;
        }

        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
   // 关键步凑：将key，value 组合成map中的一个Entry对象
    tab[i] = new Entry(key, value);

    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

static class Entry extends WeakReference<ThreadLocal<?>> {
     /** The value associated with this ThreadLocal. */
     Object value;
		
     Entry(ThreadLocal<?> k, Object v) {
     // Entry构造方法会先调用父类的构造方法，并把k传给父类(这里的就是前面的this,我们自己写的tl)
     // WeakReference指向ThreadLocal形成一个弱引用
     // 当没有其它变量对ThreadLocal引用的时候，弱引用在经历一次GC之后就会被回收,防止内存泄漏
         super(k);
         value = v;
     }
 }

引用关系图解

为什么要使用弱引用？ 若是使用强引用，即是tl=null，但是key的引用依然指向ThreadLocal对象，所以会有内存泄漏，而使用弱引用则不会，因为当没有其他对象引用的时候，弱引用在经历一次GC之后就会被回收,从而防止内存泄漏。 但是还是有内存泄漏存在，ThreadLocal被回收，key的值变为null,则导致整个value再也无法被访问到，即使ThreadLocal每次在get/set的时候都会清理掉key=null的数据，万一长时间不执行get/set方法，依然存在内存泄漏，在我们不使用threadLocal的时候，切记一定要remove掉。

如果在使用线程池当中，当每个线程使用完成之后，首先remove清理ThreadLocal ,再还回线程池。避免当前线程里面的map累积产生内存泄漏，若下一次被使用的时候，先判断是否在某个key,不存在则添加，会出现使用到上一次遗留Entry情况。