所有分类
  • 所有分类
  • 未分类

Java引用类型(强引用、软引用、弱引用、虚引用)的区别

简介

说明

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

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

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

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

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

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

引用类型简介

  • 强引用
    • 强引用是使用最普遍的引用,我们写的代码,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 被回收了

总结

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

软引用

简介

说明

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

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

应用场景:

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

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

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

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

    // 获取浏览器对象进行浏览
    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指定参数

执行结果

[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。

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

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

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
2

评论0

请先

显示验证码
没有账号?注册  忘记密码?

社交账号快速登录