软引用弱引用(SoftReference WeakReference)

最新推荐文章于 2025-06-28 14:57:03 发布

weixin_34401479

最新推荐文章于 2025-06-28 14:57:03 发布

阅读量326

点赞数

CC 4.0 BY-SA版权

文章标签： php java 移动开发

原文链接：https://juejin.im/post/5b503e23e51d4519202e1346

本文通过实战案例详细介绍了Java中软引用(SoftReference)与弱引用(WeakReference)的区别及应用场景。通过逐步演示如何创建和使用这两种引用类型，并观察在内存压力增加时它们的行为变化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

public class SoftReferenceTest {
    public static void main(String[] args) {
        A a = new A();

        SoftReference<A> softReference = new SoftReference<>(a);


        //第一步
        //我要施加内存压力了，a 占用内存很大 ， 把 a =null 释放下内存
        a = null;
        addMemory();


        //第二步
        //诶呀，现在想起来还想再使用a一下，但是a找不到了，后悔莫及
        //于是 SoftReference 诞生了，让SoftReference 把 a 引用起来。
        //当GC 要回收 a 的时候，不好意思 a 被softReference引用了，暂时不能回收，
        //那么对象什么时候被回收呢，当内存快要满的时候，要在 OutOfMemoryError 之前。
        //这样以来可以说明，SoftReference的作用是最大的限度的使用内存，而又不至于让内存溢出。
        //A a = softReference.get(); 的方式取到对象。


        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        //第三步
                        //观察对象有没有被释放
                        System.out.println(softReference.get());
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    // 添加内存压力
    public static void addMemory() {
        List<B> list = new ArrayList<>();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        list.add(new B());
                        Thread.sleep(1000);
                        System.out.println("addMemory");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

class A {
    String[] str = new String[500000000];
}

class B {
    String[] str = new String[50000000];
}

复制代码

public class WeakReferenceTest {

    public static void main(String[] args) {
        A a = new A();

        WeakReference<A> weakReference = new WeakReference<>(a);


        //第一步
        //我要施加内存压力了，a 占用内存很大 ， 把 a =null 释放下内存
        a = null;
        addMemory();

        //第二步
        //诶呀，现在想起来还想再使用a一下，但是a找不到了，后悔莫及
        //于是 WeakReference 诞生了，让WeakReference 把 a 引用起来。
        //当GC 要回收 a 的时候，虽然 a 被weakReference引用了， 但是只是个弱引用，GC 大哥你可以回收。
        //这样以来可以说明，WeakReference的作用是可以检测一个对象是否被回收，当然也可以get()对象出来使用。
        //A a = weakReference.get(); 的方式取到对象。


        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        //第三步
                        //观察对象有没有被释放
                        System.out.println(weakReference.get());
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    // 添加内存压力
    public static void addMemory() {
        List<B> list = new ArrayList<>();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        list.add(new B());
                        Thread.sleep(1000);
                        System.out.println("addMemory");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

class A {
    String[] str = new String[500000000];
}

class B {
    String[] str = new String[50000000];
}
复制代码