Java WeakReference如何避免内存泄漏

在Java中，WeakReference是一种特殊的引用类型，它允许对象在没有强引用指向它时被垃圾回收器回收。这有助于避免内存泄漏，特别是在缓存等场景中。以下是如何使用WeakReference来避免内存泄漏的一些建议：

1. 使用WeakReference包装对象

将需要缓存的强引用对象包装在WeakReference中。这样，当没有其他强引用指向该对象时，垃圾回收器可以回收它。

import java.lang.ref.WeakReference;

public class Cache {
    private WeakReference<MyObject> weakRef;

    public Cache(MyObject obj) {
        weakRef = new WeakReference<>(obj);
    }

    public MyObject get() {
        return weakRef.get();
    }

    public void clear() {
        weakRef.clear();
    }
}

2. 使用ReferenceQueue

结合ReferenceQueue使用WeakReference，可以在对象被回收时得到通知，从而进行一些清理工作。

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

public class Cache {
    private WeakReference<MyObject> weakRef;
    private ReferenceQueue<MyObject> queue;

    public Cache(MyObject obj) {
        queue = new ReferenceQueue<>();
        weakRef = new WeakReference<>(obj, queue);
    }

    public MyObject get() {
        return weakRef.get();
    }

    public void checkForEvictions() {
        WeakReference<? extends MyObject> ref;
        while ((ref = (WeakReference<? extends MyObject>) queue.poll()) != null) {
            // 对象已被回收，进行清理工作
            System.out.println("Object has been evicted from cache");
        }
    }
}

3. 避免循环引用

虽然WeakReference本身不会导致内存泄漏，但如果存在循环引用，仍然可能导致内存泄漏。确保在使用WeakReference时没有创建循环引用。

4. 定期清理

定期检查并清理不再需要的缓存对象。可以使用ReferenceQueue来帮助检测哪些对象已经被回收。

5. 使用SoftReference

对于缓存场景，有时使用SoftReference比WeakReference更合适。SoftReference允许对象在内存不足时被回收，而不是立即回收。

import java.lang.ref.SoftReference;

public class Cache {
    private SoftReference<MyObject> softRef;

    public Cache(MyObject obj) {
        softRef = new SoftReference<>(obj);
    }

    public MyObject get() {
        return softRef.get();
    }
}

6. 注意线程安全

如果缓存是多线程访问的，确保对缓存的访问是线程安全的。可以使用ConcurrentHashMap等并发集合来存储缓存对象。

import java.lang.ref.WeakReference;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentCache {
    private ConcurrentHashMap<String, WeakReference<MyObject>> cache = new ConcurrentHashMap<>();

    public void put(String key, MyObject obj) {
        cache.put(key, new WeakReference<>(obj));
    }

    public MyObject get(String key) {
        WeakReference<MyObject> ref = cache.get(key);
        return ref != null ? ref.get() : null;
    }

    public void remove(String key) {
        cache.remove(key);
    }
}

通过以上方法，可以有效地使用WeakReference来避免内存泄漏。