Android中的引用类型：Weak Reference, Soft Reference, Phantom Reference 和 WeakHashMap

井九

发布于 2024-10-12 10:19:16

16800

代码可运行

运行总次数：0

代码可运行

在Android开发中，内存管理是一个非常重要的话题。为了更好地管理内存，Java和Android提供了多种引用类型，包括Weak Reference、Soft Reference、Phantom Reference以及WeakHashMap。这些引用类型在不同的场景下可以帮助我们更有效地管理内存，避免内存泄漏。

1. Weak Reference（弱引用）

Weak Reference是一种弱化版的引用类型。当一个对象只有弱引用指向它时，垃圾回收器会在下一次垃圾回收时回收该对象，即使内存还没有达到紧张的程度。

使用场景

缓存：当你需要缓存一些对象，但又不想这些对象占用太多内存时，可以使用弱引用来缓存。当内存紧张时，垃圾回收器会自动回收这些缓存对象。
监听器：在Android中，Activity或Fragment的生命周期可能会比它们的监听器更短。使用弱引用可以避免监听器持有Activity或Fragment的强引用，从而避免内存泄漏。

代码示例

import java.lang.ref.WeakReference;

public class WeakReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object();
        WeakReference<Object> weakRef = new WeakReference<>(obj);

        obj = null; // 清除强引用

        // 尝试获取对象
        Object retrievedObj = weakRef.get();
        if (retrievedObj != null) {
            System.out.println("Object still alive");
        } else {
            System.out.println("Object has been garbage collected");
        }
    }
}

2. Soft Reference（软引用）

Soft Reference比弱引用稍微强一些。当一个对象只有软引用指向它时，垃圾回收器会在内存紧张时回收该对象，但在内存不紧张时，该对象不会被回收。

使用场景

内存敏感的缓存：当你需要缓存一些对象，但又希望在内存紧张时自动释放这些缓存对象时，可以使用软引用。
图片缓存：在Android中，图片缓存是一个常见的场景。使用软引用可以确保在内存紧张时，图片缓存会被自动清理。

代码示例

import java.lang.ref.SoftReference;

public class SoftReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object();
        SoftReference<Object> softRef = new SoftReference<>(obj);

        obj = null; // 清除强引用

        // 尝试获取对象
        Object retrievedObj = softRef.get();
        if (retrievedObj != null) {
            System.out.println("Object still alive");
        } else {
            System.out.println("Object has been garbage collected");
        }
    }
}

3. Phantom Reference（虚引用）

Phantom Reference是最弱的一种引用类型。虚引用主要用于在对象被垃圾回收时执行一些清理操作。虚引用必须与ReferenceQueue一起使用。

使用场景

资源清理：当你需要在对象被垃圾回收时执行一些清理操作（如关闭文件、释放资源等），可以使用虚引用。
监控对象的生命周期：虚引用可以用于监控对象的生命周期，当对象被垃圾回收时，虚引用会被加入到ReferenceQueue中。

代码示例

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

public class PhantomReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object();
        ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
        PhantomReference<Object> phantomRef = new PhantomReference<>(obj, refQueue);

        obj = null; // 清除强引用

        // 尝试获取对象
        Object retrievedObj = phantomRef.get();
        if (retrievedObj != null) {
            System.out.println("Object still alive");
        } else {
            System.out.println("Object has been garbage collected");
        }

        // 检查ReferenceQueue
        PhantomReference<?> ref = (PhantomReference<?>) refQueue.poll();
        if (ref != null) {
            System.out.println("Object has been finalized");
        }
    }
}

4. WeakHashMap（弱哈希映射）

WeakHashMap是一种特殊的Map，它的键是弱引用。当键对象没有其他强引用指向它时，垃圾回收器会自动回收该键对象，并从WeakHashMap中移除对应的键值对。

使用场景

缓存：当你需要缓存一些对象，但又希望在对象不再被使用时自动清理缓存时，可以使用WeakHashMap。
临时数据存储：当你需要临时存储一些数据，但又不想这些数据占用太多内存时，可以使用WeakHashMap。

代码示例

import java.util.Map;
import java.util.WeakHashMap;

public class WeakHashMapExample {
    public static void main(String[] args) {
        Map<Object, String> weakMap = new WeakHashMap<>();

        Object key = new Object();
        weakMap.put(key, "Value");

        key = null; // 清除强引用

        // 触发垃圾回收
        System.gc();

        // 检查WeakHashMap
        if (weakMap.isEmpty()) {
            System.out.println("Key has been garbage collected");
        } else {
            System.out.println("Key still alive");
        }
    }
}

5. Strong Reference（强引用）

Strong Reference是最常见的引用类型。只要一个对象有强引用指向它，垃圾回收器就不会回收该对象。

使用场景

常规对象引用：大多数情况下，我们使用强引用来引用对象。

代码示例

public class StrongReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object(); // 强引用

        // 即使内存紧张，obj也不会被垃圾回收
        System.out.println("Object still alive");
    }
}

6. ReferenceQueue（引用队列）

ReferenceQueue与弱引用、软引用和虚引用一起使用，用于监控对象的生命周期。当引用对象被垃圾回收时，它们会被加入到ReferenceQueue中。

使用场景

资源清理：当你需要在对象被垃圾回收时执行一些清理操作，可以使用ReferenceQueue。
生命周期监控：用于监控对象的生命周期，当对象被垃圾回收时，可以执行一些自定义操作。

代码示例

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

public class ReferenceQueueExample {
    public static void main(String[] args) {
        Object obj = new Object();
        ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
        PhantomReference<Object> phantomRef = new PhantomReference<>(obj, refQueue);

        obj = null; // 清除强引用

        // 触发垃圾回收
        System.gc();

        // 检查ReferenceQueue
        PhantomReference<?> ref = (PhantomReference<?>) refQueue.poll();
        if (ref != null) {
            System.out.println("Object has been finalized");
        }
    }
}

7. FinalReference（最终引用）

FinalReference是一个内部类，用于支持Java的finalize()方法。当对象被垃圾回收时，如果该对象实现了finalize()方法，垃圾回收器会调用该方法。

使用场景

资源清理：在对象被垃圾回收时，执行一些清理操作。

代码示例

public class FinalizeExample {
    @Override
    protected void finalize() throws Throwable {
        try {
            System.out.println("Finalize method called");
        } finally {
            super.finalize();
        }
    }

    public static void main(String[] args) {
        FinalizeExample obj = new FinalizeExample();
        obj = null; // 清除强引用

        // 触发垃圾回收
        System.gc();
    }
}