0
点赞
收藏
分享

微信扫一扫

Java的软引用、弱引用和强引用学习

一、强引用

强引用可以直接访问目标对象,所指向的对象在任何时候都不会被系统回收,JVM宁愿抛出OOM异常也不会回收强引用所指向的对象,但是有可能会导致内存泄漏。

package learn;


/**
 * @author qx
 * @date 2024/1/5
 * @des
 */
public class Demo {
    public static void main(String[] args) {
        // 强引用
        Person person = new Person(1, "admin");
    }
}

二、软引用和弱引用

软引用:如果一个对象只具有软引用,而当前虚拟机堆内存空间足够,那么垃圾回收器不会回收它,反之机会回收这些软引用指向的对象。

弱引用:垃圾回收器一旦发现某块内存上只有弱引用,不管当前内存是否足够,那么都会回收这块内存。

三、代码实例

软引用工具类

package learn;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.HashMap;

/**
 * @author qx
 * @date 2024/2/5
 * @des 软引用工具类
 */
public class SoftHashMap<K, V> extends HashMap<K, V> {
    /**
     * queue,软引用标记队列
     * <p>
     * ★★★★★★★ 解释 ★★★★★★★
     * 当SoftNode中 Value 被回收时,SoftNode 对象会被放入 queue中,以表示当前SoftNode 中的Value不存在
     * 对我们的使用好处就是,我们读取 queue 队列,取出 SoftNode对象,取出其内部的 Key
     * 以便于 temp 通过 key remove
     */
    private ReferenceQueue<V> queue;
    /**
     * 真正的map对象
     * 1、temp 内部 封装的 Node 强引用 K 和 SoftNode
     * 2、SoftNode 内部强引用K,弱引用真正的Value
     */
    private HashMap<K, SoftNode<K, V>> temp;

    public SoftHashMap() {
        queue = new ReferenceQueue<>();
        temp = new HashMap<>();
    }

    @Override
    public V get(Object key) {
        clearQueue();
        // 通过 key进行取值,如果为null,返回null,否则返回 SoftNode 软引用的值
        SoftNode softNode = temp.get(key);
        return softNode == null ? null : (V) softNode.get();
    }

    @Override
    public V put(K key, V value) {
        clearQueue();
        // 创建 SoftNode对象
        SoftNode softNode = new SoftNode(key, value, queue);
        // 返回key之前所对应的SoftNode对象,即oldSoftNode
        SoftNode oldSoftNode = temp.put(key, softNode);
        // 如果oldSoftNode为null,就返回null,否则就返回 oldSoftNode所软引用的 Value
        return oldSoftNode == null ? null : (V) oldSoftNode.get();
    }

    @Override
    public boolean containsKey(Object key) {
        clearQueue();
        return temp.containsKey(key);
    }

    @Override
    public V remove(Object key) {
        clearQueue();
        SoftNode<K, V> remove = temp.remove(key);
        return remove == null ? null : remove.get();
    }

    @Override
    public int size() {
        clearQueue();
        return temp.size();
    }

    /**
     * 通过软引用队列内的 SoftNode,获取Key,然后temp 清除此 Key
     *
     * @see ReferenceQueue poll()
     * poll() -- 类似于 stack 的pop(),移除并返回此对象
     */
    private void clearQueue() {
        SoftNode poll;
        while ((poll = (SoftNode) queue.poll()) != null) {
            temp.remove(poll.key);
        }
    }


    /**
     * 对V进行软引用的类
     *
     * @param <K> key,用于当 V 被回收后,temp 可以通过 key 进行移除
     * @param <V> Value,真正的值
     *            <p>
     *            传入的queue,用于当Value被回收后,将 SoftNode对象放入 queue中,
     *            以便于表示 某 SoftNode对象中的Value 已经被收回了。
     */
    private class SoftNode<K, V> extends SoftReference<V> {
        K key;

        public SoftNode(K k, V v, ReferenceQueue queue) {
            super(v, queue);
            key = k;
        }
    }
}

四、测试

强引用:

package learn;

import java.util.HashMap;
import java.util.Map;

/**
 * @author qx
 * @date 2024/2/5
 * @des 强引用测试
 */
public class ReferenceDemo {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        System.out.println(Integer.MAX_VALUE);
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            map.put(i, "hello");
            System.out.println(i);
        }
    }
}

Java的软引用、弱引用和强引用学习_软引用

软引用:

package learn;

import java.util.HashMap;
import java.util.Map;

/**
 * @author qx
 * @date 2024/2/5
 * @des
 */
public class SoftReferenceDemo {
    public static void main(String[] args) {
        SoftHashMap<Integer, String> map = new SoftHashMap<>();
        System.out.println(Integer.MAX_VALUE);
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            map.put(i, "hello");
            System.out.println(i);
        }
    }
}

Java的软引用、弱引用和强引用学习_强引用_02

测试中可以明显的看到:

  1. 强引用时,加载的String更多,但会造成内存溢出;
  2. 弱引用时,由于弱引用的机制(内存满时会进行垃圾回收),不会造成内存溢出,但由于需要对String进行处理,所以加载的String没有强引用时多;


举报

相关推荐

0 条评论