Java的四种引用详解与使用案例

Java有四种引用:强引用、软引用、弱引用和虚引用

整体结构

java.lang.ref包下

  • 强引用:Reference

  • 软引用:SoftReference

  • 弱引用:WeakReference

  • 虚引用:PhantomReference

  • 引用队列:ReferenceQueue

强引用

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

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

对于一个普通的对象,如果没有其他的引用关系,只要超过了引用的作用域或者显式地将相应(强)引用赋值为null,就是可以被垃圾收集的了。

Student s = new Student

软引用

内存空间足够,垃圾回收器就不会回收它,如果内存空间不足了,就会回收这些对象的内存。

软引用作用是实现内存敏感的高速缓存。软引用可以和一个引用队列联合使用,如果软引用所引用的对象被垃圾回收,Java虚拟机会把软应用加入到与之关联的引用队列中。

package ref;

import java.lang.ref.SoftReference;

public class SoftReferenceDemo {

    /**
     * 内存够用就保留,不够就回收
     */
    public static void softRef_Memory_Enough() {
        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);
        System.out.println(o1); //java.lang.Object@14ae5a5
        System.out.println(softReference.get()); //java.lang.Object@14ae5a5

        o1 = null;
        System.gc();

        System.out.println(o1); //null
        System.out.println(softReference.get()); //java.lang.Object@14ae5a5
    }

    /**
     * 生成大对象,设置小内存,自动GC
     * -Xms5m -Xmx5m -XX:+PrintGCDetails
     */
    public static void softRef_Memory_NotEnough() {
        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);
        System.out.println(o1);
        System.out.println(softReference.get());

        o1 = null;

        try {
            // 创建大对象
            byte[] bytes = new byte[30 * 1024 * 1024];
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(o1); //null
            System.out.println(softReference.get()); //null
        }
    }

    public static void main(String[] args) {
        softRef_Memory_Enough();
        softRef_Memory_NotEnough();
    }
}

软引用队列案例

作为一个Java对象,SoftReference对象除了具有保存软引用的特殊性之外,也具有Java对象的一般性。所以,当软可及对象被回收之后,虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值,需要一个适当的清除机制,避免大量SoftReference对象带来的内存泄漏。在java.lang.ref包里还提供了ReferenceQueue。如果在创建SoftReference对象的时候,使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法,如:

ReferenceQueue queue = new ReferenceQueue(); 
SoftReference ref=new SoftReference(aMyObject, queue);   

当这个SoftReference所软引用的aMyOhject被垃圾收集器回收的同时,ref所强引用的SoftReference对象被列入ReferenceQueue中。可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强引用对象被回收,再把这些失去所软引用的对象的SoftReference对象清除掉。

例如:

//继承SoftReference,实现对对象的软引用  
//这个类所引用的目标对象会在JVM内存不足时自动回收  
private class WeakEmployee extends WeakReference<Employee> {  
  
    private String key;  
          
    public String getKey() {  
        return key;  
    }  
  
    public WeakEmployee(Employee referent, ReferenceQueue<Employee> queue) {  
        super(referent, queue);  
        this.key = referent.getId();  
    }     
} 

private void cleanCache() {  
    WeakEmployee se = null;  
    while((se = (WeakEmployee)queue.poll()) != null) { 
        referent.remove(se.getKey());  
        System.out.println("对象ID : " + se.getKey() + "已经被JVM回收");  
    }  
} 

参考:https://www.cnblogs.com/daxin/archive/2013/06/03/3114679.html

弱引用

一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。很软引用类似,只是回收的更快。weak引用对象常常用于Map数据结构中,引用占用的内存空间较大的对象。

import java.lang.ref.WeakReference;

public class WeakReferenceDemo {
    public static void main(String[] args) {
        Object o1 = new Object();
        WeakReference<Object> weakReference = new WeakReference<>(o1);
        System.out.println(o1); //java.lang.Object@14ae5a5
        System.out.println(weakReference.get()); //java.lang.Object@14ae5a5

        o1 = null;
        System.gc();

        System.out.println(o1); //null
        System.out.println(weakReference.get()); //null
    }
}

应用场景

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

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

此时可以使用软引用或弱引用解决。

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

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

WeakHashMap

WeakHashMap的键是"弱键"。在WeakHashMap中,当某个键不再正常使用时,会被从WeakHashMap中被自动移除。

public class TestWeakHashMap {
 
    public static void main(String[] args) {
        WeakHashMap<String, String> weakHashMap = new WeakHashMap<>(10);
 
        String key0 = new String("kuang");
        String key1 = new String("zhong");
        String key2 = new String("wen");
 
        // 存放元素
        weakHashMap.put(key0, "q1");
        weakHashMap.put(key1, "q2");
        weakHashMap.put(key2, "q3");
        System.out.printf("weakHashMap: %s\n", weakHashMap);
 
        // 是否包含某key
        System.out.printf("contains key kuang : %s\n", weakHashMap.containsKey(key0));
        System.out.printf("contains key zhong : %s\n", weakHashMap.containsKey(key1));
 
        // 是否包含某value
        System.out.printf("contains value 0 : %s\n", weakHashMap.containsValue(0));
 
        // 移除key
        weakHashMap.remove(key2);
        System.out.printf("weakHashMap after remove: %s", weakHashMap);
 
        // 这意味着"弱键"key0再没有被其它对象引用,调用gc时会回收WeakHashMap中与key0对应的键值对
        key0 = null;
        // 内存回收,这里会回收WeakHashMap中与"key0"对应的键值对
        System.gc();
 
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 遍历WeakHashMap
        Iterator iter = weakHashMap.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry en = (Map.Entry) iter.next();
            System.out.printf("next : %s - %s\n", en.getKey(), en.getValue());
        }
        // 打印WeakHashMap的实际大小
        System.out.printf("after gc WeakHashMap size: %s\n", weakHashMap.size());
    }
}

依次输出
weakHashMap: {wen=q3, zhong=q2, kuang=q1}
contains key kuang : true
contains key zhong : true
contains value 0 : false
weakHashMap after remove: {zhong=q2, kuang=q1}
next : zhong - q2
after gc WeakHashMap size: 1

参考:https://blog.csdn.net/u014294681/article/details/86522487

虚引用

虚引用不会决定对象的生命周期,如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收,它不能单独使用也不能通过它访问对象。

当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

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

public class PhantomReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        PhantomReference<Object> phantomReference = new PhantomReference<>(o1,referenceQueue);

        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());

        o1 = null;
        System.gc();
        Thread.sleep(500);

        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());
    }
}

输出
java.lang.Object@14ae5a5
null
null
null
null
java.lang.ref.PhantomReference@7f31245a
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值