【Java】弱引用的相关使用

本文主要是介绍【Java】弱引用的相关使用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java的四种引用

1.强引用

最常见的引用类型，即使内存不够也不会回收。

思考：obj1这个强引用自身是否也是对象？占用内存吗？

public class StrongReferenceDemo {
    public static void main(String[] args) {
        //obj1是一个强引用，指向new出来的实际对象
        Object obj1 = new Object();
        Object obj2 = obj1;
        obj1 = null;
        System.gc();
        System.out.println(obj2);
    }
}

输出结果：java.lang.Object@4d7e1886

2.软引用

内存不够了就回收仅有软引用指向的对象，内存够的时候不用管。

package com.shin.demo05;

import java.lang.ref.SoftReference;

public class SoftReferenceDemo {
    public static void memoryEnough(){
        Object obj1 = new Object();
        //创建一个软引用，指向强引用obj所指的对象。
        SoftReference<Object> softReference = new SoftReference<Object>(obj1);
        System.out.println(obj1);
        System.out.println(softReference.get());
        obj1 = null;
        System.gc();
        System.out.println(obj1);
        System.out.println(softReference.get());
    }
    //-Xms5m -Xmx5m 故意制造OOM
    public static void memoryNotEnough(){
        Object obj1 = new Object();
        SoftReference<Object> softReference = new SoftReference<Object>(obj1);
        System.out.println(obj1);
        System.out.println(softReference.get());
        //此时只剩软引用
        obj1 = null;
        try{
            byte[] bytes = new byte[300*1024*1024];
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            System.out.println(obj1);
            System.out.println(softReference.get());
        }
    }
    public static void main(String[] args) {
        memoryEnough();
        System.out.println("=========================");
        memoryNotEnough();
    }
}

故意制造OOM，JVM参数-Xms5m -Xmx5m。自动GC的时候把软引用指向的对象回收了。使用softReference.get()可以获得指向的对象。

输出结果：

java.lang.Object@4d7e1886
java.lang.Object@4d7e1886
null
java.lang.Object@4d7e1886
=============
java.lang.Object@3cd1a2f1
java.lang.Object@3cd1a2f1
java.lang.OutOfMemoryError: Java heap space
	at com.shin.demo05.SoftReferenceDemo.memoryNotEnough(SoftReferenceDemo.java:25)
	at com.shin.demo05.SoftReferenceDemo.main(SoftReferenceDemo.java:36)
null
null

3.弱引用

仅被弱引用指向的对象在GC的时候一定会被回收，无论内存是否足够。

import java.lang.ref.WeakReference;

public class WeakReferenceDemo {
    public static void memoryEnough(){
        Object obj1 = new Object();
        WeakReference<Object> weakReference = new WeakReference<Object>(obj1);
        System.out.println(obj1);
        System.out.println(weakReference.get());
        obj1 = null;
        System.gc();
        System.out.println(obj1);
        System.out.println(weakReference);
        System.out.println(weakReference.get());
    }
    public static void main(String[] args) {
        memoryEnough();
    }
}

同样是使用weakReference.get()获取弱引用指向的对象。weakReference本身也要占用内存，可以理解为引用类型的对象。

输出结果：

java.lang.Object@4d7e1886
java.lang.Object@4d7e1886
null
java.lang.ref.WeakReference@3cd1a2f1
null

4.虚引用

仅被虚引用指向的对象也是只要GC就会回收，此外不可以通过虚引用get到指向的对象。

但是可以将虚引用回收的时候入引用队列ReferenceQueue。

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

public class PhantomReferenceDemo {
    public static void main(String[] args) {
        Object obj1 = new Object();
        ReferenceQueue queue = new ReferenceQueue();
        PhantomReference<Object> phantomReference = new PhantomReference<Object>(obj1,queue);

        System.out.println(obj1);
        System.out.println(phantomReference.get());
        System.out.println(queue.poll());
        System.out.println("===========================");
        obj1 = null;
        System.gc();
        System.out.println(obj1);
        System.out.println(phantomReference.get());
        System.out.println(queue.poll());
    }

}

输出结果：

java.lang.Object@4d7e1886
null
null
===========================
null
null
java.lang.ref.PhantomReference@3cd1a2f1

5.引用队列

软弱虚引用都可以和引用队列配合，在被回收的时候进入引用队列。注意入队的是引用，不是引用指向的对象。

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

public class ReferenceQueueDemo {
    public static void main(String[] args) {
        Object obj1 = new Object();
        ReferenceQueue queue = new ReferenceQueue();

        WeakReference<Object> weakReference = new WeakReference<Object>(obj1,queue);

        System.out.println(obj1);
        System.out.println(weakReference.get());
        System.out.println(queue.poll());
        System.out.println("===========================");
        //只剩下weak-reference，实际对象会被GC回收
        obj1 = null;
        System.gc();
        System.out.println(obj1);
        System.out.println(weakReference.get());
        //回收之后入队
        System.out.println(queue.poll());
    }
}

输出结果：

java.lang.Object@4d7e1886
java.lang.Object@4d7e1886
null
===========================
null
null
java.lang.ref.WeakReference@3cd1a2f1

弱引用的使用

WeakHashMap的使用

WeakHashMap实现原理和HashMap差不多，区别在于WeakHashMap的key是一个弱引用。

public class WeakHashMapDemo {
    public static void notWeak(){
        HashMap<Integer, String> map = new HashMap<>();
        Integer key = new Integer(1);
        String value = "HashMap";
        map.put(key,value);
        System.out.println(map);
        key = null;
        //显然还在，想要删除的话需要使用remove()方法
        System.out.println(map);
        System.gc();
        //显然还在，HashMap内部都是强引用
        System.out.println(map);
    }
    public static void weak(){
        WeakHashMap<Integer, String> map = new WeakHashMap<>();
        Integer key = new Integer(1);
        String value = "WeakHashMap";
        map.put(key,value);
        System.out.println(map);
        key = null;
        //不GC的话还在
        System.out.println(map);
        System.gc();
        //WeakHashMap的key是一个弱引用，GC之后key原来指向的对象被回收了
        //但是这里看到的是整个键值对都没了，其实用到了引用队列
        System.out.println(map);
    }

    public static void main(String[] args) {
        notWeak();
        weak();
    }

输出结果：

{1=HashMap}
{1=HashMap}
{1=HashMap}
{1=WeakHashMap}
{1=WeakHashMap}
{}

下面一段话摘自《Java核心技术卷1》：

设计 WeakHashMap类是为了解决一个有趣的问题。如果有一个值，对应的键已经不再使用了，将会出现什么情况呢？ 假定对某个键的最后一次引用已经消亡，不再有任何途径引用这个值的对象了。但是，由于在程序中的任何部分没有再出现这个键，所以，这个键值对无法从映射中删除。为什么垃圾回收器不能够删除它呢？ 难道删除无用的对象不是垃圾回收器的工作吗？

遗憾的是，事情没有这样简单。垃圾回收器跟踪活动的对象。只要映射对象是active的，其中的所有桶也是active的，它们不能被回收。因此，需要由程序负责从长期存活的映射表中删除那些无用的值。 或者使用 WeakHashMap完成这件事情。当对键的唯一引用来自散列条目时， 这一数据结构将与垃圾回收器协同工作一起删除键 / 值对。

下面是这种机制的内部运行情况。WeakHashMap使用弱引用（weak references) 保存键。WeakReference对象将引用保存到另外一个对象中，在这里，就是散列键。对于这种类型的对象，垃圾回收器用一种特有的方式进行处理。通常，如果垃圾回收器发现某个特定的对象已经没有他人引用了，就将其回收。然而，如果某个对象只能由 WeakReference引用，垃圾回收器仍然回收它，但要将引用这个对象的弱引用放人队列中。WeakHashMap将周期性地检查队列，以便找出新添加的弱引用。一个弱引用进人队列意味着这个键不再被他人使用，并且已经被收集起来。于是， WeakHashMap将删除对应的条目。

具体看WeakHashMap源码中的expungeStaleEntries()方法。

弱引用的子类MyEntry

如果一个类继承了WeakReference会怎样？

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

//MyEntry继承了WeakReference，那么MyEntry本身就是一个弱引用
//通过父类的构造方法可以指定referent和queue。
public class MyEntry extends WeakReference {

    //MyEntry是一个弱引用，自身还携带了一个属性value
    private Object value;
    //调用这个构造函数会返回一个MyEntry类型的弱引用
    //指向的是key所指的实际对象，引用队列是queue
    public MyEntry(Object key, Object value, ReferenceQueue queue) {
        //调用父类构造函数
        super(key,queue);
        this.value = value;
    }

    public static void main(String[] args) {
        //1、key是一个强引用
        Object key = new Object();
        Object value = new Object();
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        //2、创建了弱引用myEntry，指向强引用key所指的对象
        //   当只剩myEntry的时候，GC回收指向的实际对象，然后把myEntry放进queue中
        //   注意这里是把谁入队。引用队列入队的一定是引用，而不是引用指向的实际对象。
        MyEntry myEntry = new MyEntry(key, value, queue);
        System.out.println("key:        "+key);
        System.out.println("value:      "+value);
        System.out.println("myEntry指向: "+myEntry.get());
        System.out.println("queue:      "+queue.poll());
        System.out.println("===============================");
        key = null;
        System.gc();
        System.out.println("key:        "+key);
        System.out.println("value:      "+value);
        System.out.println("myEntry指向: "+myEntry.get());
        System.out.println("queue:      "+queue.poll());
    }
}

输出结果：

key:        java.lang.Object@4d7e1886
value:      java.lang.Object@3cd1a2f1
myEntry指向: java.lang.Object@4d7e1886
queue:      null
===============================
key:        null
value:      java.lang.Object@3cd1a2f1
myEntry指向: null
queue:      com.shin.demo05.MyEntry@2f0e140b

可以看到myEntry指向的是原本key所指的对象，GC之后被回收了，并且myEntry进入引用队列。

这篇关于【Java】弱引用的相关使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！