java面试基础篇--强引用、软引用、弱引用、虚引用，避免OOM问题

最新推荐文章于 2024-04-16 00:52:52 发布

刘沐Mu

最新推荐文章于 2024-04-16 00:52:52 发布

阅读量410

点赞数 1

分类专栏： Java面试文章标签： java 面试

本文链接：https://blog.csdn.net/jiu_mu_mu/article/details/120541726

版权

Java面试专栏收录该内容

6 篇文章 1 订阅

订阅专栏

本文章参考学习相关文章：
https://www.cnblogs.com/dolphin0520/p/3784171.html

https://blog.csdn.net/qq_39192827/article/details/85611873

https://www.cnblogs.com/rgever/p/8902210.html

在大家学习Java的过程中，不可避免的应该都遇到过OOM（OutOfMemory）。那么怎么才能避免这种情况的发生呢，接下来我会就这个问题进行解释。

本文大纲：
1、什么是强引用、软引用、弱引用、虚引用？
2、进一步解释软引用、弱引用
3、如何解决OOM问题

一、强引用、软引用、弱引用、虚引用

在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这就像在商店购买了某样物品后，如果有用就一直保留它，否则就把它扔到垃圾箱，由清洁工人收走。一般说来，如果物品已经被扔到垃圾箱，想再把它捡回来使用就不可能了。

但有时候情况并不这么简单，可能会遇到可有可无的"鸡肋"物品。这种物品现在已经无用了，保留它会占空间，但是立刻扔掉它也不划算，因为也许将来还会派用场。对于这样的可有可无的物品：如果家里空间足够，就先把它保留在家里，如果家里空间不够，即使把家里所有的垃圾清除，还是无法容纳那些必不可少的生活用品，那么再扔掉这些可有可无的物品。

在Java中，虽然不需要程序员手动去管理对象的生命周期，但是如果希望某些对象具备一定的生命周期的话（比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误）就需要用到软引用和弱引用了。

从Java SE2开始，就提供了四种类型的引用：强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的：第一是可以让程序员通过代码的方式决定某些对象的生命周期；第二是有利于JVM进行垃圾回收。

1、强引用

强引用就是我们经常使用的普通引用。
下面用代码和图来解释：

String str = new String("dasdasd");

这里的这个str就是强引用
在这里插入图片描述
局部变量str会被放进到栈的局部变量表中，而创建的String实例对象会被放在堆中

String str1 = str;

在这里插入图片描述
这个str1也是强引用

特点：
1、通过强引用可以直接访问目标对象
2、强引用指向的对象在任何时候都不会被JVM所回收，宁愿抛出OutOfMemoryError，也不会回收强引用的、所指向对象
3、强应用会导致内存泄漏

public class Test {
    public static void main(String[] args) {
        Object[] obj = new Object[Integer.MAX_VALUE];
    }
}

在这里插入图片描述
在java虚拟机中，有一个方法可以取消强连接和某个实例对象之间的关联，就是可以将引用赋值为null，这样JVM就会在合适的时间将这个没有和CG Roots对象存在关联的实例对象给清理掉。

这里我就以ArrayList为例子，其中的clear()方法就是将强引用给赋值为null，以下是源码：

    /**
     * Removes all of the elements from this list.  The list will
     * be empty after this call returns.
     */
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

通过这个方法就可以将强引用的对象给清除

2、软引用

软引用是用来描述一些有用但是不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题。

public class Test {
    public static void main(String[] args) {
        // 创建软引用实例对象
        SoftReference<User> userSoft = new SoftReference<>(new User(1, "jack"));

        // 用软引用的get方法获取对象
        System.out.println("第一次获取：" + userSoft.get());

        // 手动进行一次垃圾处理
        System.gc();

        // 用软引用的get方法获取对象
        System.out.println("内存不紧张：" + userSoft.get());

        // 模拟内存紧张的情况
        byte[] bytes = new byte[Integer.MAX_VALUE - (1024 * 1024 * 706) + 379630];

        // 手动进行一次垃圾处理
        System.gc();

        // 用软引用的get方法获取对象
        System.out.println("内存紧张：" + userSoft.get());
    }
}
class User {
    public int id;
    public String name;

    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。下面是一个使用示例：

3、弱引用

弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用java.lang.ref.WeakReference类来表示。

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。所以被软引用关联的对象只有在内存不足时才会被回收，而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。

public class Test {
    public static void main(String[] args) {


        // 创建弱引用实例对象
        WeakReference<User> userWeak = new WeakReference<>(new User(2, "tom"));


        System.out.println(userWeak.get());
        System.gc();
        System.out.println(userWeak.get());


    }
}

class User {
    public int id;
    public String name;

    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

在这里插入图片描述
在使用软引用和弱引用的时候，我们可以显示地通过System.gc()来通知JVM进行垃圾回收，但是要注意的是，虽然发出了通知，JVM不一定会立刻执行，也就是说这句是无法确保此时JVM一定会进行垃圾回收的。

根据软引用和弱引用的特性，非常适合保存一些可有可无的缓存，如果这么做，当系统内存空间不足时，会及时回收他们，不会导致内存溢出，当系统内存资源充足时，这些还存有可以存在相当长的时间，提升系统速度。

4、虚引用

虚引用（PhantomReference）和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收的活动。

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

        // 创建虚引用实例对象
        ReferenceQueue<User> userReferenceQueue = new ReferenceQueue<>();
        PhantomReference<User> userPhantom = new PhantomReference<>(new User(), userReferenceQueue);

        System.out.println(userPhantom.get());

在这里插入图片描述

二、进一步解释软引用、弱引用

软引用底层代码：

public class SoftReference<T> extends Reference<T> {

    static private long clock;

    private long timestamp;

    public SoftReference(T referent) {
        super(referent);
        this.timestamp = clock;
    }

    public SoftReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
        this.timestamp = clock;
    }

    public T get() {
        T o = super.get();
        if (o != null && this.timestamp != clock)
            this.timestamp = clock;
        return o;
    }

}

弱引用底层代码：

public class WeakReference<T> extends Reference<T> {

    public WeakReference(T referent) {
        super(referent);
    }

    public WeakReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }

}

他们两个的共同父类：


package java.lang.ref;

import sun.misc.Cleaner;
import sun.misc.JavaLangRefAccess;
import sun.misc.SharedSecrets;

public abstract class Reference<T> {
    private T referent;         /* Treated specially by GC */

    volatile ReferenceQueue<? super T> queue;

    /* When active:   NULL
     *     pending:   this
     *    Enqueued:   next reference in queue (or this if last)
     *    Inactive:   this
     */
    @SuppressWarnings("rawtypes")
    Reference next;

    transient private Reference<T> discovered;  /* used by VM */
    static private class Lock { }
    private static Lock lock = new Lock();

    private static Reference<Object> pending = null;

    /* High-priority thread to enqueue pending References
     */
    private static class ReferenceHandler extends Thread {

        private static void ensureClassInitialized(Class<?> clazz) {
            try {
                Class.forName(clazz.getName(), true, clazz.getClassLoader());
            } catch (ClassNotFoundException e) {
                throw (Error) new NoClassDefFoundError(e.getMessage()).initCause(e);
            }
        }

        static {
            // pre-load and initialize InterruptedException and Cleaner classes
            // so that we don't get into trouble later in the run loop if there's
            // memory shortage while loading/initializing them lazily.
            ensureClassInitialized(InterruptedException.class);
            ensureClassInitialized(Cleaner.class);
        }

        ReferenceHandler(ThreadGroup g, String name) {
            super(g, name);
        }

        public void run() {
            while (true) {
                tryHandlePending(true);
            }
        }
    }

    static boolean tryHandlePending(boolean waitForNotify) {
        Reference<Object> r;
        Cleaner c;
        try {
            synchronized (lock) {
                if (pending != null) {
                    r = pending;
                    // 'instanceof' might throw OutOfMemoryError sometimes
                    // so do this before un-linking 'r' from the 'pending' chain...
                    c = r instanceof Cleaner ? (Cleaner) r : null;
                    // unlink 'r' from 'pending' chain
                    pending = r.discovered;
                    r.discovered = null;
                } else {
                    // The waiting on the lock may cause an OutOfMemoryError
                    // because it may try to allocate exception objects.
                    if (waitForNotify) {
                        lock.wait();
                    }
                    // retry if waited
                    return waitForNotify;
                }
            }
        } catch (OutOfMemoryError x) {
            // Give other threads CPU time so they hopefully drop some live references
            // and GC reclaims some space.
            // Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above
            // persistently throws OOME for some time...
            Thread.yield();
            // retry
            return true;
        } catch (InterruptedException x) {
            // retry
            return true;
        }

        // Fast path for cleaners
        if (c != null) {
            c.clean();
            return true;
        }

        ReferenceQueue<? super Object> q = r.queue;
        if (q != ReferenceQueue.NULL) q.enqueue(r);
        return true;
    }

    static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        Thread handler = new ReferenceHandler(tg, "Reference Handler");
        /* If there were a special system-only priority greater than
         * MAX_PRIORITY, it would be used here
         */
        handler.setPriority(Thread.MAX_PRIORITY);
        handler.setDaemon(true);
        handler.start();

        // provide access in SharedSecrets
        SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
            @Override
            public boolean tryHandlePendingReference() {
                return tryHandlePending(false);
            }
        });
    }

    public T get() {
        return this.referent;
    }

    public void clear() {
        this.referent = null;
    }
    public boolean isEnqueued() {
        return (this.queue == ReferenceQueue.ENQUEUED);
    }

    public boolean enqueue() {
        return this.queue.enqueue(this);
    }


    /* -- Constructors -- */

    Reference(T referent) {
        this(referent, null);
    }

    Reference(T referent, ReferenceQueue<? super T> queue) {
        this.referent = referent;
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }

}

三、如何解决OOM问题

前面讲了关于软引用和弱引用相关的基础知识，那么到底如何利用它们来优化程序性能，从而避免OOM的问题呢？

下面举个例子，假如有一个应用需要读取大量的本地图片，如果每次读取图片都从硬盘读取，则会严重影响性能，但是如果全部加载到内存当中，又有可能造成内存溢出，此时使用软引用可以解决这个问题。

设计思路是：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。在Android开发中对于大量图片下载会经常用到。

下面这段代码是摘自博客：

　http://blog.csdn.net/arui319/article/details/8489451

private Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();
<br>....
public void addBitmapToCache(String path) {
 
        // 强引用的Bitmap对象
 
        Bitmap bitmap = BitmapFactory.decodeFile(path);
 
        // 软引用的Bitmap对象
 
        SoftReference<Bitmap> softBitmap = new SoftReference<Bitmap>(bitmap);
 
        // 添加该对象到Map中使其缓存
 
        imageCache.put(path, softBitmap);
 
    }
 
 public Bitmap getBitmapByPath(String path) {
 
        // 从缓存中取软引用的Bitmap对象
 
        SoftReference<Bitmap> softBitmap = imageCache.get(path);
 
        // 判断是否存在软引用
 
        if (softBitmap == null) {
 
            return null;
 
        }
 
        // 取出Bitmap对象，如果由于内存不足Bitmap被回收，将取得空
 
        Bitmap bitmap = softBitmap.get();
 
        return bitmap;
 
    }

在这里插入图片描述

刘沐Mu

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java面试基础篇--强引用、软引用、弱引用、虚引用，避免OOM问题

本文章参考学习相关文章：https://www.cnblogs.com/dolphin0520/p/3784171.htmlhttps://blog.csdn.net/qq_39192827/article/details/85611873https://www.cnblogs.com/rgever/p/8902210.html在大家学习Java的过程中，不可避免的应该都遇到过OOM（OutOfMemory）。那么怎么才能避免这种情况的发生呢，接下来我会就这个问题进行解释。本文大纲：1、什么是强
复制链接

扫一扫

专栏目录