09-JUC进阶-ThreadLocal

JUC java juc
发布时间 :
字数:5.7k 阅读 : 评论:
  1. 一、ThreadLocal简介
    1. 1. 简介
    2. 2. 作用
    3. 3. 常用API介绍
    4. 4. 入门案例
      1. 4.1 案例代码
      2. 4.2 总结
  2. 二、ThreadLocal实际使用
    1. 1. 阿里ThreadLocal规范
    2. 2. 非线程安全的SimpleDateFormat
      1. 2.1 官网文档
      2. 2.2 错误示例代码
      3. 2.3 源码分析结论
    3. 3. 解决方式1
    4. 4. 解决方式2
  3. 三、ThreadLocal源码分析
    1. 1. Thread，ThreadLocal，ThreadLocalMap 关系
      1. 1.1 Thread和ThreadLocal
      2. 1.2 ThreadLocal和ThreadLocalMap
      3. 1.3 三者总概括
    2. 2. 总结
  4. 四、ThreadLocal内存泄露问题
    1. 1. 阿里代码规范
    2. 2. 什么是内存泄漏
    3. 3. ThreadLocal的内存泄露分析
      1. 3.1 实现原理
      2. 3.2 ThreadLocal 内存泄漏的原因
      3. 3.3 那为什么使用弱引用而不是强引用？
        1. 3.3.1 key 使用强引用
        2. 3.3.2 key使用弱引用
    4. 4. 强引用、软引用、弱引用、虚引用
      1. 4.1 整体架构
      2. 4.2 强引用(默认支持模式)
      3. 4.3 软引用
        1. 4.3.1 测试代码
        2. 4.3.2 适用场景
      4. 4.4 弱引用
      5. 4.5 虚引用
        1. 4.5.1 构造方法
        2. 4.5.2 引用队列
    5. 5. GCRoots和四大引用总结
  5. 五、总结

一、ThreadLocal简介

官方文档: https://www.runoob.com/manual/jdk11api/java.base/java/lang/ThreadLocal.html

1. 简介

ThreadLocal提供线程局部变量。这些变量与正常的变量不同，因为每一个线程在访问ThreadLocal实例的时候（通过其get或set方法）都有自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态字段，使用它的目的是希望将状态（例如，用户ID或事务ID）与线程关联起来。

2. 作用

实现每一个线程都有自己专属的本地变量副本(不和其它线程共享)，主要解决了让每个线程绑定自己的值，通过使用get()和set()方法，获取默认值或将其值更改为当前线程所存的副本的值从而避免了线程安全问题。

ThreadLocal

3. 常用API介绍

  • get()

    返回当前线程的此线程局部变量副本中的值。 如果变量没有当前线程的值，则首先将其初始化为调用initialValue()方法返回的值。

  • initialValue()

    返回此线程局部变量的当前线程的“初始值”。 当第一次一个线程访问get()方法,该方法将被调用的.除非线程先调用的set(T)方法，在这种情况下initialValue方法将不被调用的线程。 通常，每个线程最多调用一次此方法，但如果后续调用remove()后跟get() ，则可以再次调用此方法。

    这个实现只返回null ; 如果程序员希望线程局部变量具有除null之外的初始值， ThreadLocal必须对ThreadLocal进行子类化，并且重写此方法。 通常，将使用匿名内部类。

  • remove()

    删除此线程局部变量的当前线程值。 如果当前线程的此线程局部变量随后是read ，则其值将通过调用其initialValue()方法重新初始化。 这可能导致在当前线程中多次调用initialValue方法。

  • set(T value)

    将此线程局部变量的当前线程副本设置为指定值。 大多数子类都不需要重写此方法，仅依靠initialValue()方法来设置线程局部的值。

  • withInitial(Supplier<? extends S> supplier)

    创建一个线程局部变量。 通过调用get上的Supplier方法确定变量的初始值。

常用API

4. 入门案例

4.1 案例代码

公司各个销售人员, 按照出单数各自统计, 使用ThreadLocal实现.

public class ThreadLocalTest {

    public static void main(String[] args) throws InterruptedException {
        MyHouse house = new MyHouse();
        new Thread(() -> {
            try {
                int num = new Random().nextInt(10);
                for (int i = 0; i < num; i++) {
                    house.saleHouse();
                }
                System.out.println(Thread.currentThread().getName() + "卖出了:" + house.threadLocal.get() + "套房子");
            } finally {
                house.threadLocal.remove();
            }
        }, "销售1").start();

        new Thread(() -> {
            try {
                int num = new Random().nextInt(10);
                for (int i = 0; i < num; i++) {
                    house.saleHouse();
                }
                System.out.println(Thread.currentThread().getName() + "卖出了:" + house.threadLocal.get() + "套房子");
            } finally {
                house.threadLocal.remove();
            }
        }, "销售2").start();

        new Thread(() -> {
            try {
                int num = new Random().nextInt(10);
                for (int i = 0; i < num; i++) {
                    house.saleHouse();
                }
                System.out.println(Thread.currentThread().getName() + "卖出了:" + house.threadLocal.get() + "套房子");
            } finally {
                house.threadLocal.remove();
            }
        }, "销售3").start();

        TimeUnit.SECONDS.sleep(1);
    }

}


class MyHouse {
    // 初始化ThreadLocal,设置初始值为:0
    ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void saleHouse() {
        Integer value = threadLocal.get();
        value++;
        threadLocal.set(value);
    }
}

运行结果:

销售1卖出了:8套房子
销售2卖出了:3套房子
销售3卖出了:1套房子

4.2 总结

  • 因为每个 Thread 内有自己的实例副本且该副本只由当前线程自己使用
  • 既然其它 Thread 不可访问，那就不存在多线程间共享的问题。
  • 统一设置初始值，但是每个线程对这个值的修改都是各自线程互相独立的

多线程如何才能不争抢

  1. 加入synchronized或者Lock控制资源的访问顺序
  2. 使用ThreadLocal

二、ThreadLocal实际使用

1. 阿里ThreadLocal规范

阿里ThreadLocal规范

2. 非线程安全的SimpleDateFormat

2.1 官网文档

image-20241002072822670

上述翻译：SimpleDateFormat中的日期格式不是同步的。推荐（建议）为每个线程创建独立的格式实例。如果多个线程同时访问一个格式，则它必须保持外部同步。

写时间工具类，一般写成静态的成员变量，但此种写法在多线程下是不安全的！

2.2 错误示例代码

public class DateUtils {
    public static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     * 模拟并发环境下使用SimpleDateFormat的parse方法将字符串转换成Date对象
     *
     * @param stringDate
     * @return
     * @throws Exception
     */
    public static Date parseDate(String stringDate) throws Exception {
        return sdf.parse(stringDate);
    }

    public static void main(String[] args) throws Exception {
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                try {
                    System.out.println(DateUtils.parseDate("2020-11-11 11:11:11"));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }

}

报错如下:

java.lang.NumberFormatException: For input string: "..11111111EE22"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.base/java.lang.Long.parseLong(Long.java:678)
	at java.base/java.lang.Long.parseLong(Long.java:817)
	at java.base/java.text.DigitList.getLong(DigitList.java:195)
	at java.base/java.text.DecimalFormat.parse(DecimalFormat.java:2121)
	at java.base/java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1933)
	at java.base/java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1541)
	at java.base/java.text.DateFormat.parse(DateFormat.java:393)
	at com.atguigu.juc.tl.DateUtils.parseDate(DateUtils.java:22)
	at com.atguigu.juc.tl.DateUtils.lambda$main$0(DateUtils.java:29)
	at java.base/java.lang.Thread.run(Thread.java:834)
java.lang.NumberFormatException: multiple points
	at java.base/jdk.internal.math.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at java.base/jdk.internal.math.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.base/java.lang.Double.parseDouble(Double.java:543)
	at java.base/java.text.DigitList.getDouble(DigitList.java:169)
	at java.base/java.text.DecimalFormat.parse(DecimalFormat.java:2126)
	at java.base/java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2240)
	at java.base/java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1541)
	at java.base/java.text.DateFormat.parse(DateFormat.java:393)
	at com.atguigu.juc.tl.DateUtils.parseDate(DateUtils.java:22)
	at com.atguigu.juc.tl.DateUtils.lambda$main$0(DateUtils.java:29)
	at java.base/java.lang.Thread.run(Thread.java:834)
java.lang.NumberFormatException: For input string: ".2022020E"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.base/java.lang.Long.parseLong(Long.java:678)
	at java.base/java.lang.Long.parseLong(Long.java:817)
	at java.base/java.text.DigitList.getLong(DigitList.java:195)
	at java.base/java.text.DecimalFormat.parse(DecimalFormat.java:2121)
	at java.base/java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1933)
	at java.base/java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1541)
	at java.base/java.text.DateFormat.parse(DateFormat.java:393)
	at com.atguigu.juc.tl.DateUtils.parseDate(DateUtils.java:22)
	at com.atguigu.juc.tl.DateUtils.lambda$main$0(DateUtils.java:29)
	at java.base/java.lang.Thread.run(Thread.java:834)
java.lang.NumberFormatException: For input string: ".2220E0.202E4"
	at java.base/jdk.internal.math.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2054)
	at java.base/jdk.internal.math.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.base/java.lang.Double.parseDouble(Double.java:543)
	at java.base/java.text.DigitList.getDouble(DigitList.java:169)
	at java.base/java.text.DecimalFormat.parse(DecimalFormat.java:2126)
	at java.base/java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1933)
	at java.base/java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1541)
	at java.base/java.text.DateFormat.parse(DateFormat.java:393)
	at com.atguigu.juc.tl.DateUtils.parseDate(DateUtils.java:22)
	at com.atguigu.juc.tl.DateUtils.lambda$main$0(DateUtils.java:29)
	at java.base/java.lang.Thread.run(Thread.java:834)
java.lang.NumberFormatException: multiple points
	at java.base/jdk.internal.math.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at java.base/jdk.internal.math.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.base/java.lang.Double.parseDouble(Double.java:543)
	at java.base/java.text.DigitList.getDouble(DigitList.java:169)
	at java.base/java.text.DecimalFormat.parse(DecimalFormat.java:2126)
	at java.base/java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2240)
	at java.base/java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1541)
	at java.base/java.text.DateFormat.parse(DateFormat.java:393)
	at com.atguigu.juc.tl.DateUtils.parseDate(DateUtils.java:22)
	at com.atguigu.juc.tl.DateUtils.lambda$main$0(DateUtils.java:29)

2.3 源码分析结论

SimpleDateFormat类内部有一个Calendar对象引用,它用来储存和这个SimpleDateFormat相关的日期信息,例如 sdf.parse(dateStr) , sdf.format(date) 诸如此类的方法参数传入的日期相关String,Date等等, 都是交由Calendar引用来储存的.这样就会导致一个问题如果你的SimpleDateFormat是个static的, 那么多个thread 之间就会共享这个SimpleDateFormat, 同时也是共享这个Calendar引用。

  • java.text.SimpleDateFormat#parse

java.text.SimpleDateFormat#parse

  • java.text.CalendarBuilder#establish

    image-20241002074237666

3. 解决方式1

将SimpleDateFormat定义成局部变量。

缺点：每调用一次方法就会创建一个SimpleDateFormat对象，方法结束又要作为垃圾回收。

public class DateUtils {

    public static void main(String[] args) throws Exception {
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                try {
                    System.out.println(sdf.parse("2020-11-11 11:11:11"));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }

}

4. 解决方式2

使用ThreadLocal

public class DateUtils {

    private static final ThreadLocal<SimpleDateFormat> threadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-mm-dd HH:mm:ss"));


    /**
     * 模拟并发环境下使用SimpleDateFormat的parse方法将字符串转换成Date对象
     *
     * @param stringDate
     * @return
     * @throws Exception
     */
    public static Date parseDate(String stringDate) throws Exception {
        SimpleDateFormat sdf = threadLocal.get();
//        System.out.println("执行线程:" + Thread.currentThread().getName());
        return sdf.parse(stringDate);
    }

    public static void main(String[] args) throws Exception {
        for (int i = 1; i <= 30; i++) {
            new Thread(() -> {
                try {
                    System.out.println(parseDate("2020-11-11 11:11:11"));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }

}

其它方案

  • 加锁
  • 第3方时间库

三、ThreadLocal源码分析

1. Thread，ThreadLocal，ThreadLocalMap 关系

根据官方API，Thread是程序中执行的线程；ThreadLocal类提供线程局部变量。

1.1 Thread和ThreadLocal

先打开Thread.java类，发现每个Thread类里面有一个ThreadLocal类

ThreadLocal

1.2 ThreadLocal和ThreadLocalMap

而 ThreadLocalMap 是 ThreadLocal 的一个静态内部类

ThreadLocalMap

1.3 三者总概括

threadLocalMap 实际上就是一个以 threadLocal 实例为key，任意对象为value的 Entry对象 。
当我们为threadLocal变量赋值，实际上就是以当前threadLocal实例为key，值为value的Entry往这个threadLocalMap中存放

Thread，ThreadLocal，ThreadLocalMap

ThreadLocal set

2. 总结

近似的可以理解为:
ThreadLocalMap 从字面上就可以看出这是一个保存ThreadLocal对象的map(其实是以ThreadLocal为Key)，不过是经过了两层包装的ThreadLocal 对象：

ThreadLocalMap

JVM内部维护了一个线程版的 Map<Thread,T> (通过 ThreadLocal 对象的 set 方法，结果把 ThreadLocal 对象自己当做key，放进了ThreadLoalMap中),每个线程要用到这个T的时候，用当前的线程去Map里面获取，通过这样让每个线程都拥有了自己独立的变量，
人手一份，竞争条件被彻底消除，在并发模式下是绝对安全的变量。

四、ThreadLocal内存泄露问题

1. 阿里代码规范

阿里代码规范

2. 什么是内存泄漏

内存泄露为程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光.

广义并通俗的说，就是：不再会被使用的对象或者变量占用的内存不能被回收，就是内存泄露。

3. ThreadLocal的内存泄露分析

3.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;
        }
    }
    ...
   }

ThreadLocal的实现原理，每一个Thread维护一个ThreadLocalMap，key为使用弱引用的ThreadLocal实例，value为线程变量的副本。这些对象之间的引用关系如下,

img

实心箭头表示强引用，空心箭头表示弱引用

3.2 ThreadLocal 内存泄漏的原因

从上图中可以看出，ThreadLocalMap 使用 ThreadLocal 的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，Key(ThreadLocal)势必会被GC回收，这样就会导致 ThreadLocalMap 中key为 null， 而value还存在着强引用，只有thead线程退出以后,value的强引用链条才会断掉。

但如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：

Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value

永远无法回收，造成内存泄漏。

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

3.3.1 key 使用强引用

当 ThreadLocalMap 的key为强引用回收 ThreadLocal 时，因为 ThreadLocalMap 还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。

3.3.2 key使用弱引用

由于ThreadLocal对象是弱引用，如果外部没有强引用指向它，它就会被GC回收，导致Entry的Key为空(null)，如果这时Value外部也没有强引用指向它，那么Value就永远也访问不到了，按理也应该被GC回收，但是由于Entry对象还在强引用Value，导致Value无法被回收，这时「内存泄漏」就发生了，Value成了一个永远也无法被访问，但是又无法被回收的对象。

Entry对象属于ThreadLocalMap，ThreadLocalMap又属于Thread，如果线程本身的生命周期很短，短时间内就会被销毁，那么「内存泄漏」立刻就会得到解决，只要线程被销毁，Value也会随之被回收。

问题是，线程本身是非常珍贵的计算机资源，很少会去频繁的创建和销毁，一般都是通过线程池来使用，这就将线程的生命周期大大拉长，「内存泄漏」的影响也会越来越大。

内存泄漏的代码示例

线程池大小是3,但启动了6个线程,导致后面的线程直接复用了前面线程的 ThreadLocal数据.

public class ThreadLocalPoolTest {
    public static void main(String[] args) throws InterruptedException {
        MyCar car = new MyCar();
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 6; i++) {
            executorService.submit(() -> {
                int num = new Random().nextInt(10);
                for (int j = 0; j < num; j++) {
                    car.saleCar();
                }
                System.out.println(Thread.currentThread().getName() + "卖出了:" + car.threadLocal.get() + "辆车");
            });
        }

        executorService.shutdown();
    }
}

class MyCar {
    // 初始化ThreadLocal,设置初始值为:0
    ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void saleCar() {
        Integer value = threadLocal.get();
        value++;
        threadLocal.set(value);
        System.out.println(Thread.currentThread().getName() + "卖了:" + threadLocal.get() + "辆车");
    }
}

运行结果:

pool-1-thread-1卖了:1辆车
pool-1-thread-1卖了:2辆车
pool-1-thread-2卖了:1辆车
pool-1-thread-2卖了:2辆车
pool-1-thread-3卖了:1辆车
pool-1-thread-3卖了:2辆车
pool-1-thread-2卖了:3辆车
pool-1-thread-2卖了:4辆车
pool-1-thread-1卖了:3辆车
pool-1-thread-1卖了:4辆车
pool-1-thread-2卖了:5辆车
pool-1-thread-2卖出了:5辆车
pool-1-thread-3卖了:3辆车
pool-1-thread-1卖了:5辆车
pool-1-thread-3卖了:4辆车
pool-1-thread-2卖出了:5辆车
pool-1-thread-1卖了:6辆车
pool-1-thread-1卖了:7辆车
pool-1-thread-1卖了:8辆车
pool-1-thread-1卖了:9辆车
pool-1-thread-1卖出了:9辆车
pool-1-thread-3卖了:5辆车
pool-1-thread-2卖了:6辆车
pool-1-thread-2卖出了:6辆车
pool-1-thread-1卖了:10辆车
pool-1-thread-3卖出了:5辆车
pool-1-thread-1卖出了:10辆车

方案: 手动回收自定义的 ThreadLocal变量

public class ThreadLocalPoolTest {
    public static void main(String[] args) throws InterruptedException {
        MyCar car = new MyCar();
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 6; i++) {
            executorService.submit(() -> {
                try {
                    int num = new Random().nextInt(10);
                    for (int j = 0; j < num; j++) {
                        car.saleCar();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出了:" + car.threadLocal.get() + "辆车");
                } finally {
                    car.threadLocal.remove();
                }
            });
        }

        executorService.shutdown();
    }
}

class MyCar {
    // 初始化ThreadLocal,设置初始值为:0
    ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void saleCar() {
        Integer value = threadLocal.get();
        value++;
        threadLocal.set(value);
        System.out.println(Thread.currentThread().getName() + "卖了:" + threadLocal.get() + "辆车");
    }
}

4. 强引用、软引用、弱引用、虚引用

4.1 整体架构

引用架构

Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。

finalize()

finalize() 方法定义在Object类中,每个类都可以重写此方法(不建议重写)

class MyObject {
    //一般这个方法工作中不用
    @Override
    protected void finalize() throws Throwable {
        System.out.println("------------- gc ,finalize() invoked");
    }
}

4.2 强引用(默认支持模式)

当内存不足，JVM开始垃圾回收，对于强引用的对象，就算是出现了OOM也不会对该对象进行回收.

强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰这种对象。在 Java 中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到JVM也不会回收。因此强引用是造成Java内存泄漏的主要原因之一。

public static void strongReference() {
    MyObject myObject = new MyObject();//默认，强引用,死了都不放手
    System.out.println("gc before: " + myObject);

    myObject = null;
    System.gc();//手动挡的方式开启Gc回收。
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("gc after: " + myObject);
}

4.3 软引用

软引用是一种相对强引用弱化了一些的引用，需要用 java.lang.ref.SoftReference 类来实现，可以让对象豁免一些垃圾收集。

对于只有软引用的对象来说，

  • 当系统内存充足时它不会被回收，
  • 当系统内存不足时它会被回收。

4.3.1 测试代码

软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收！

public class ReferenceTest {
    public static void main(String[] args) {
        //当我们内存不够用的时候，soft会被回收的情况，设置我们的内存大小：-Xms10m -Xmx10m
        SoftReference<MyObject> softReference = new SoftReference<>(new MyObject());

        System.gc();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----gc after内存够用: " + softReference.get());

        try {
            byte[] bytes = new byte[9 * 1024 * 1024];
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("-----gc after内存不够: " + softReference.get());
        }
    }

}

class MyObject2 {
    //一般这个方法工作中不用，此处为了讲解gc，给学生们演示
    @Override
    protected void finalize() throws Throwable {
        System.out.println("------------- gc ,finalize() invoked");
    }
}

打印结果:

-----gc after内存够用: com.atguigu.juc.tl.MyObject@64616ca2
-----gc after内存不够: null
------------- gc ,finalize() invoked
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at com.atguigu.juc.tl.ReferenceTest.main(ReferenceTest.java:25)

4.3.2 适用场景

假如有一个应用需要读取大量的本地图片:

  • 如果每次读取图片都从硬盘读取则会严重影响性能,
  • 如果一次性全部加载到内存中又可能造成内存溢出。

如果每次读取图片都从硬盘读取则会严重影响性能,

设计思路是：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。

Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();

4.4 弱引用

弱引用需要用java.lang.ref.WeakReference类来实现，它比软引用的生存期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管JVM的内存空间是否足够，都会回收该对象占用的内存。 

public class ReferenceTest {
    public static void main(String[] args) {
        WeakReference<MyObject> weakReference = new WeakReference<>(new MyObject());
        System.out.println("-----gc before内存够用: "+weakReference.get());

        System.gc();
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        System.out.println("-----gc after内存够用: "+weakReference.get());

    }

}

打印结果:

-----gc before内存够用: com.atguigu.juc.tl.MyObject@64616ca2
------------- gc ,finalize() invoked
-----gc after内存够用: null

4.5 虚引用

虚引用需要 java.lang.ref.PhantomReference 类来实现。

顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，它不能单独使用也不能通过它访问对象，虚引用必须和引用队列 (ReferenceQueue)联合使用。

虚引用的主要作用是跟踪对象被垃圾回收的状态。 仅仅是提供了一种确保对象被 finalize以后，做某些事情的机制。 PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。

其意义在于：说明一个对象已经进入finalization阶段，可以被gc回收，用来实现比finalization机制更灵活的回收操作。

换句话说，设置虚引用关联的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理。

4.5.1 构造方法

构造方法

4.5.2 引用队列

引用队列

被回收前需要被引用队列保存下。

public class ReferenceTest {
    public static void main(String[] args) {
        // 设置内存: -Xms10m -Xmx10m
        ReferenceQueue<MyObject2> referenceQueue = new ReferenceQueue();
        PhantomReference<MyObject2> phantomReference = new PhantomReference<>(new MyObject2(), referenceQueue);
        //System.out.println(phantomReference.get());

        List<byte[]> list = new ArrayList<>();

        new Thread(() -> {
            while (true) {
                list.add(new byte[1 * 1024 * 1024]);
                try {
                    TimeUnit.MILLISECONDS.sleep(600);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(phantomReference.get()); // null
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                Reference<? extends MyObject2> reference = referenceQueue.poll();
                if (reference != null) {
                    System.out.println("***********有虚对象加入队列了");
                }
            }
        }, "t2").start();

        //暂停几秒钟线程
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class MyObject2 {
    //一般这个方法工作中不用
    @Override
    protected void finalize() throws Throwable {
        System.out.println("------------- gc ,finalize() invoked");
    }
}

打印结果:

null
------------- gc ,finalize() invoked
null
***********有虚对象加入队列了
null
Exception in thread "t1" java.lang.OutOfMemoryError: Java heap space
	at com.atguigu.juc.tl.ReferenceTest.lambda$main$0(ReferenceTest.java:26)
	at com.atguigu.juc.tl.ReferenceTest$$Lambda$14/0x0000000100066840.run(Unknown Source)
	at java.base/java.lang.Thread.run(Thread.java:834)

5. GCRoots和四大引用总结

GCRoots和四大引用

五、总结

  • ThreadLocal 并不解决线程间共享数据的问题
  • ThreadLocal 适用于变量在线程间隔离且在方法间共享的场景
  • ThreadLocal 通过隐式的在不同线程内创建独立实例副本避免了实例线程安全的问题
  • 每个线程持有一个只属于自己的专属Map并维护了ThreadLocal对象与具体实例的映射，该Map由于只被持有它的线程访问，故不存在线程安全以及锁的问题
  • ThreadLocalMap的Entry对ThreadLocal的引用为弱引用，避免了ThreadLocal对象无法被回收的问题
  • ThreadLocal 会通过expungeStaleEntry，cleanSomeSlots,replaceStaleEntry这三个方法回收键为 null 的 Entry 对象的值（即为具体实例）以及 Entry 对象本身从而防止内存泄漏，属于安全加固的方法
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 george_95@126.com

©2016-2020 George

Built with Hexo and 3-hexo theme