Java--引用类型--强引用、软引用、弱引用、虚引用--区别/使用/实例-CFANZ编程社区

简介

说明

本文用示例介绍Java中的引用类型的区别及使用。

从JDK 1.2版本开始，对象的引用被划分为4种级别，由高到低依次为：强引用、软引用、弱引用和虚引用。

本内容也是Java后端面试常见的问题。

为什么分为四种引用类型？

Java设计这四种引用的主要目的有两个：

可以让程序员通过代码的方式来决定某个对象的生命周期
有利于垃圾回收

引用类型简介

强引用

强引用是使用最普遍的引用，我们写的代码，99.9999%都是强引用
只要某个对象有强引用与之关联，这个对象永远不会被回收，即使内存不足，JVM宁愿抛出OOM，也不会去回收。

软引用

只有在内存不足时，JVM才会回收该对象。
当内存不足时，会触发JVM的GC，如果GC后，内存还是不足，就会把软引用包裹的对象给干掉。

弱引用

不管内存是否足够，只要发生GC，弱引用就会被回收。

虚引用

无法通过虚引用来获取对一个对象的真实引用。
虚引用必须与ReferenceQueue一起使用。当GC准备回收一个对象时，如果发现它还有虚引用，就会在回收之前，把这个虚引用加入到与之关联的ReferenceQueue中。

强引用

简介

强引用是使用最普遍的引用，我们写的代码，99.9999%都是强引用。

只要某个对象有强引用与之关联，这个对象永远不会被回收，即使内存不足，JVM宁愿抛出OOM，也不会去回收。

强引用写法：Object o = new Object();

让强引用的对象被回收的写法：o = null;

代码实例

用代码展示回收强引用的对象。

finalize方法在垃圾回收的时候会被调用。

package com.example.a;

class User{
    @Override
    protected void finalize() {
        System.out.println("User 被回收了");
    }
}

public class Demo {
    public static void main(String[] args) {
        User user = new User();
        user = null;
        System.gc();
    }
}

结果

User 被回收了

总结

可以看到资源被回收了。
在实际开发中，不要重写finalize方法
在实际开发中，若看到有对象被手动赋值为null，很大可能就是为了“特意提醒”JVM这块资源可以进行垃圾回收了。

软引用

简介

说明

只有在内存不足时，JVM才会回收该对象。

当内存不足时，会触发JVM的GC，如果GC后，内存还是不足，就会把软引用包裹的对象给干掉。

应用场景：

软引用主要用于缓存：当内存足够时，可以正常的拿到缓存，当内存不够时，就会先干掉缓存，不至于马上抛出OOM。

比如：浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢？这就要看具体的实现策略了。

如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建；
如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出。

这时候就可以使用软引用，很好的解决了实际的问题：

// 获取浏览器对象进行浏览
    Browser browser = new Browser();
    // 从后台程序加载浏览页面
    BrowserPage page = browser.getPage();
    // 将浏览完毕的页面置为软引用
    SoftReference softReference = new SoftReference(page);

    // 回退或者再次浏览此页面时
    if(softReference.get() != null) {
        // 内存充足，还没有被回收器回收，直接获取缓存
        page = softReference.get();
    } else {
        // 内存不足，软引用的对象已经回收
        page = browser.getPage();
        // 重新构建软引用
        softReference = new SoftReference(page);
    }

代码实例

代码写法

创建一个软引用：

SoftReference<User> softReference = new SoftReference<User>(new User());

从软引用对象获得包裹的对象：

User User = softReference.get();
System.out.println(User);

实例：用代码展示回收软引用的对象

定义一个软引用对象，里面包裹了byte[]，byte[]占用了10M，然后又创建了10Mbyte[]。

package com.example.a;

import java.lang.ref.SoftReference;

public class Demo {
    public static void main(String[] args) {
        SoftReference<byte[]> softReference = new SoftReference<byte[]>(new byte[1024*1024*10]);
        System.out.println(softReference.get());
        System.gc();
        System.out.println(softReference.get());

        byte[] bytes = new byte[1024 * 1024 * 10];
        System.out.println(softReference.get());
    }
}

执行结果

[B@1b6d3586
[B@1b6d3586
[B@1b6d3586

现在我们手动制造内存不足：设置最大堆大小为15M：-Xmx15m

法1：先编译程序，再java -Xmx15m xxx

法2：Idea指定参数

Java--引用类型--强引用、软引用、弱引用、虚引用--区别/使用/实例_java

Java--引用类型--强引用、软引用、弱引用、虚引用--区别/使用/实例_spring cloud_02

执行结果

[B@1b6d3586
[B@1b6d3586
null

结论

手动GC后，软引用对象包裹的byte[]还活的好好的，但是当我们创建了一个10M的byte[]后，最大堆内存不够了，所以JVM把软引用对象包裹的byte[]给干掉了。

弱引用

简介

说明

不管内存是否足够，只要发生GC，弱引用就会被回收。

使用场景

若引用主要用于缓存：当没有发生GC时，可以正常的拿到缓存，当发生GC时，就会先干掉缓存，不至于马上抛出OOM。

JDK里对弱引用的使用：ThreadLocal、WeakHashMap。

如果一个对象是偶尔(很少)的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，就可以使用弱引用。

代码实例

代码写法

弱引用的使用和软引用类似，只是关键字变成了WeakReference

创建一个软引用：

WeakReference<User> weakReference = new WeakReference<User>(new User());

从软引用对象获得包裹的对象：

User User = weakReference.get();
System.out.println(User);

实例：用代码展示回收弱引用的对象

package com.example.a;

import java.lang.ref.WeakReference;

public class Demo {
    public static void main(String[] args) {
        WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[1]);
        System.out.println(weakReference.get());
        System.gc();
        System.out.println(weakReference.get());
    }
}

结果

[B@1b6d3586
null

结论

不管内存是否足够，只要发生GC，弱引用就会被回收。

虚引用

简介

说明

无法通过虚引用来获取对一个对象的真实引用。

虚引用必须与ReferenceQueue一起使用。当GC准备回收一个对象时，如果发现它还有虚引用，就会在回收之前，把这个虚引用加入到与之关联的ReferenceQueue中。

使用场景

虚引用主要用来跟踪对象被垃圾回收器回收的活动。

程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要进行垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

NIO运用了虚引用管理堆外内存。

代码实例

简单实例

package com.example.a;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class Demo {
    public static void main(String[] args) {
        ReferenceQueue queue = new ReferenceQueue();
        PhantomReference<byte[]> reference = new PhantomReference<byte[]>(new byte[1], queue);
        System.out.println(reference.get());
    }
}

结果

null

看源码：竟然直接返回了null。

Java--引用类型--强引用、软引用、弱引用、虚引用--区别/使用/实例_分布式_03

这就是虚引用特点之一：无法通过虚引用来获取对一个对象的真实引用。

实例：用代码展示回收弱引用的对象

package com.example.a;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class User {
    @Override
    protected void finalize() {
        System.out.println("User 被回收了");
    }
}

public class Demo {
    public static void main(String[] args) {
        ReferenceQueue queue = new ReferenceQueue();
        List<byte[]> bytes = new ArrayList<>();
        PhantomReference<User> phantomReference = new PhantomReference<User>(new User(), queue);
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                bytes.add(new byte[1024 * 1024]);
            }
        }).start();

        new Thread(() -> {
            while (true) {
                Reference poll = queue.poll();
                if (poll != null) {
                    System.out.println("虚引用被回收了：" + poll);
                }
            }
        }).start();
        Scanner scanner = new Scanner(System.in);
        scanner.hasNext();
    }
}

我们手动制造内存不足：设置最大堆大小为15M：-Xmx15m

结果：

User 被回收了
Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space
  at com.example.a.Demo.lambda$main$0(Demo.java:24)
  at com.example.a.Demo$$Lambda$1/2003749087.run(Unknown Source)
  at java.lang.Thread.run(Thread.java:748)
虚引用被回收了：java.lang.ref.PhantomReference@2c4772fc