深入理解Java四大引用：强引用、软引用、弱引用与虚引用

// 强引用示例
String str = new String("Hello World");  // str是强引用
Object obj = new Object();               // obj是强引用

// 将引用置为null，对象变为可回收状态
str = null;
obj = null;

@Service
public class UserService {
    // userRepository是强引用
    @Autowired
    private UserRepository userRepository;
    
    // users列表中的元素都是强引用
    private List<User> users = new ArrayList<>();
    
    public void addUser(User user) {
        users.add(user);  // 添加强引用
    }
}

import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.List;

public class SoftReferenceExample {
    public static void main(String[] args) {
        // 创建软引用
        String str = new String("Hello Soft Reference");
        SoftReference<String> softRef = new SoftReference<>(str);
        
        // 清除强引用
        str = null;
        
        // 获取软引用对象
        String retrieved = softRef.get();
        if (retrieved != null) {
            System.out.println("对象还存在: " + retrieved);
        } else {
            System.out.println("对象已被回收");
        }
    }
}

package com.example.demo.cache;

import org.springframework.stereotype.Component;
import java.lang.ref.SoftReference;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 基于软引用的缓存实现
 * 当内存不足时，缓存会自动释放，避免OOM
 */
@Component
public class SoftReferenceCache<K, V> {
    
    private final ConcurrentHashMap<K, SoftReference<V>> cache = new ConcurrentHashMap<>();
    
    /**
     * 放入缓存
     */
    public void put(K key, V value) {
        cache.put(key, new SoftReference<>(value));
    }
    
    /**
     * 获取缓存
     */
    public V get(K key) {
        SoftReference<V> softRef = cache.get(key);
        if (softRef == null) {
            return null;
        }
        
        V value = softRef.get();
        // 如果对象已被回收，移除该条目
        if (value == null) {
            cache.remove(key);
        }
        return value;
    }
    
    /**
     * 清除已被回收的引用
     */
    public void cleanUp() {
        cache.entrySet().removeIf(entry -> entry.getValue().get() == null);
    }
    
    /**
     * 获取缓存大小
     */
    public int size() {
        cleanUp();
        return cache.size();
    }
}

package com.example.demo.service;

import com.example.demo.cache.SoftReferenceCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ProductService {
    
    @Autowired
    private SoftReferenceCache<String, Product> productCache;
    
    /**
     * 获取产品信息（带缓存）
     */
    public Product getProduct(String productId) {
        // 先从缓存获取
        Product product = productCache.get(productId);
        if (product != null) {
            return product;
        }
        
        // 缓存未命中，从数据库加载
        product = loadProductFromDatabase(productId);
        
        // 放入缓存（使用软引用，内存不足时自动释放）
        productCache.put(productId, product);
        
        return product;
    }
    
    private Product loadProductFromDatabase(String productId) {
        // 模拟数据库查询
        return new Product(productId, "Product Name", 99.99);
    }
}

import java.lang.ref.WeakReference;
import java.util.WeakHashMap;

public class WeakReferenceExample {
    public static void main(String[] args) {
        // 创建弱引用
        String str = new String("Hello Weak Reference");
        WeakReference<String> weakRef = new WeakReference<>(str);
        
        // 清除强引用
        str = null;
        
        // 强制GC（仅用于演示，生产环境不推荐）
        System.gc();
        
        // 检查对象是否被回收
        String retrieved = weakRef.get();
        if (retrieved != null) {
            System.out.println("对象还存在: " + retrieved);
        } else {
            System.out.println("对象已被GC回收");
        }
    }
}

package com.example.demo.listener;

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

/**
 * 基于弱引用的事件监听器管理器
 * 当监听器对象不再被使用时，自动清理引用
 */
@Component
public class WeakReferenceListenerManager {
    
    private final List<WeakReference<ApplicationListener<?>>> listeners = new ArrayList<>();
    
    /**
     * 注册监听器（使用弱引用）
     */
    public void registerListener(ApplicationListener<?> listener) {
        listeners.add(new WeakReference<>(listener));
        // 清理已被回收的引用
        cleanUp();
    }
    
    /**
     * 获取所有活跃的监听器
     */
    public List<ApplicationListener<?>> getActiveListeners() {
        cleanUp();
        List<ApplicationListener<?>> activeListeners = new ArrayList<>();
        for (WeakReference<ApplicationListener<?>> ref : listeners) {
            ApplicationListener<?> listener = ref.get();
            if (listener != null) {
                activeListeners.add(listener);
            }
        }
        return activeListeners;
    }
    
    /**
     * 清理已被回收的引用
     */
    private void cleanUp() {
        listeners.removeIf(ref -> ref.get() == null);
    }
}

package com.example.demo.cache;

import org.springframework.stereotype.Component;
import java.util.WeakHashMap;
import java.util.Map;

/**
 * 基于WeakHashMap的元数据缓存
 * 当key对象不再被使用时，自动清理对应的缓存条目
 */
@Component
public class MetadataCache {
    
    // WeakHashMap：当key对象被回收时，对应的entry也会被自动移除
    private final Map<Object, String> metadataCache = new WeakHashMap<>();
    
    /**
     * 存储元数据
     */
    public void putMetadata(Object key, String metadata) {
        metadataCache.put(key, metadata);
    }
    
    /**
     * 获取元数据
     */
    public String getMetadata(Object key) {
        return metadataCache.get(key);
    }
    
    /**
     * 获取缓存大小
     */
    public int size() {
        return metadataCache.size();
    }
}

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

public class PhantomReferenceExample {
    public static void main(String[] args) {
        // 创建引用队列
        ReferenceQueue<String> queue = new ReferenceQueue<>();
        
        // 创建对象和虚引用
        String str = new String("Hello Phantom Reference");
        PhantomReference<String> phantomRef = new PhantomReference<>(str, queue);
        
        // 清除强引用
        str = null;
        
        // 虚引用无法直接获取对象
        System.out.println("通过虚引用获取对象: " + phantomRef.get()); // 输出: null
        
        // 强制GC
        System.gc();
        
        // 检查引用队列
        try {
            PhantomReference<?> ref = (PhantomReference<?>) queue.remove(1000);
            if (ref != null) {
                System.out.println("对象已被回收，可以进行资源清理");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.example.demo.resource;

import org.springframework.stereotype.Component;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 基于虚引用的资源清理管理器
 * 当对象被GC回收时，自动清理相关资源
 */
@Component
public class ResourceCleanupManager {
    
    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
    private final ConcurrentHashMap<PhantomReference<Object>, Runnable> cleanupTasks = new ConcurrentHashMap<>();
    private final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
    
    public ResourceCleanupManager() {
        // 启动清理线程
        executor.scheduleWithFixedDelay(this::processQueue, 1, 1, TimeUnit.SECONDS);
    }
    
    /**
     * 注册需要清理的资源
     * @param object 被监控的对象
     * @param cleanupTask 清理任务
     */
    public void registerCleanup(Object object, Runnable cleanupTask) {
        PhantomReference<Object> ref = new PhantomReference<>(object, queue);
        cleanupTasks.put(ref, cleanupTask);
    }
    
    /**
     * 处理引用队列，执行清理任务
     */
    private void processQueue() {
        PhantomReference<Object> ref;
        while ((ref = (PhantomReference<Object>) queue.poll()) != null) {
            Runnable cleanupTask = cleanupTasks.remove(ref);
            if (cleanupTask != null) {
                try {
                    cleanupTask.run();
                    System.out.println("资源清理完成");
                } catch (Exception e) {
                    System.err.println("资源清理失败: " + e.getMessage());
                }
            }
        }
    }
    
    /**
     * 关闭管理器
     */
    public void shutdown() {
        executor.shutdown();
    }
}

package com.example.demo.service;

import com.example.demo.resource.ResourceCleanupManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

@Service
public class FileService {
    
    @Autowired
    private ResourceCleanupManager cleanupManager;
    
    /**
     * 打开文件，当文件对象被GC回收时自动关闭流
     */
    public FileInputStream openFile(String filePath) throws IOException {
        File file = new File(filePath);
        FileInputStream fis = new FileInputStream(file);
        
        // 注册清理任务：当file对象被回收时，关闭文件流
        cleanupManager.registerCleanup(file, () -> {
            try {
                if (fis != null) {
                    fis.close();
                    System.out.println("文件流已自动关闭: " + filePath);
                }
            } catch (IOException e) {
                System.err.println("关闭文件流失败: " + e.getMessage());
            }
        });
        
        return fis;
    }
}

package com.example.demo.resource;

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

/**
 * 结合ReferenceQueue的缓存实现
 */
public class ReferenceQueueCache<K, V> {
    
    private final ConcurrentHashMap<K, WeakReference<V>> cache = new ConcurrentHashMap<>();
    private final ReferenceQueue<V> queue = new ReferenceQueue<>();
    
    /**
     * 放入缓存
     */
    public void put(K key, V value) {
        // 清理已被回收的引用
        cleanUp();
        
        // 创建弱引用并关联队列
        WeakReference<V> ref = new WeakReference<>(value, queue);
        cache.put(key, ref);
    }
    
    /**
     * 获取缓存
     */
    public V get(K key) {
        cleanUp();
        WeakReference<V> ref = cache.get(key);
        return ref != null ? ref.get() : null;
    }
    
    /**
     * 清理已被回收的引用
     */
    private void cleanUp() {
        WeakReference<? extends V> ref;
        while ((ref = (WeakReference<? extends V>) queue.poll()) != null) {
            // 从缓存中移除已被回收的条目
            cache.entrySet().removeIf(entry -> entry.getValue() == ref);
            System.out.println("清理了已被回收的缓存条目");
        }
    }
}

package com.example.demo.cache;

import org.springframework.stereotype.Component;
import java.lang.ref.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 智能缓存系统
 * - 热点数据使用强引用（快速访问）
 * - 普通数据使用软引用（内存敏感）
 * - 临时数据使用弱引用（自动清理）
 */
@Component
public class SmartCache<K, V> {
    
    // 热点数据：使用强引用
    private final ConcurrentHashMap<K, V> hotCache = new ConcurrentHashMap<>();
    private static final int HOT_CACHE_SIZE = 100;
    
    // 普通数据：使用软引用
    private final ConcurrentHashMap<K, SoftReference<V>> softCache = new ConcurrentHashMap<>();
    
    // 临时数据：使用弱引用
    private final ConcurrentHashMap<K, WeakReference<V>> weakCache = new ConcurrentHashMap<>();
    private final ReferenceQueue<V> queue = new ReferenceQueue<>();
    
    /**
     * 放入缓存（根据访问频率自动选择引用类型）
     */
    public void put(K key, V value, CacheLevel level) {
        switch (level) {
            case HOT:
                // 热点数据：强引用
                if (hotCache.size() >= HOT_CACHE_SIZE) {
                    // 移除最旧的数据，降级为软引用
                    Map.Entry<K, V> oldest = hotCache.entrySet().iterator().next();
                    hotCache.remove(oldest.getKey());
                    softCache.put(oldest.getKey(), new SoftReference<>(oldest.getValue()));
                }
                hotCache.put(key, value);
                break;
            case NORMAL:
                // 普通数据：软引用
                softCache.put(key, new SoftReference<>(value));
                break;
            case TEMPORARY:
                // 临时数据：弱引用
                weakCache.put(key, new WeakReference<>(value, queue));
                cleanUp();
                break;
        }
    }
    
    /**
     * 获取缓存
     */
    public V get(K key) {
        // 1. 先从热点缓存获取
        V value = hotCache.get(key);
        if (value != null) {
            return value;
        }
        
        // 2. 从软引用缓存获取
        SoftReference<V> softRef = softCache.get(key);
        if (softRef != null) {
            value = softRef.get();
            if (value != null) {
                // 提升为热点数据
                promoteToHot(key, value);
                return value;
            } else {
                softCache.remove(key);
            }
        }
        
        // 3. 从弱引用缓存获取
        WeakReference<V> weakRef = weakCache.get(key);
        if (weakRef != null) {
            value = weakRef.get();
            if (value != null) {
                return value;
            } else {
                weakCache.remove(key);
            }
        }
        
        return null;
    }
    
    /**
     * 提升为热点数据
     */
    private void promoteToHot(K key, V value) {
        if (hotCache.size() < HOT_CACHE_SIZE) {
            hotCache.put(key, value);
            softCache.remove(key);
        }
    }
    
    /**
     * 清理已被回收的弱引用
     */
    private void cleanUp() {
        WeakReference<? extends V> ref;
        while ((ref = (WeakReference<? extends V>) queue.poll()) != null) {
            weakCache.entrySet().removeIf(entry -> entry.getValue() == ref);
        }
    }
    
    /**
     * 缓存级别枚举
     */
    public enum CacheLevel {
        HOT,        // 热点数据
        NORMAL,     // 普通数据
        TEMPORARY   // 临时数据
    }
}

package com.example.demo.service;

import com.example.demo.cache.SmartCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DataService {
    
    @Autowired
    private SmartCache<String, Object> smartCache;
    
    /**
     * 获取数据（带智能缓存）
     */
    public Object getData(String key) {
        // 先从缓存获取
        Object data = smartCache.get(key);
        if (data != null) {
            return data;
        }
        
        // 缓存未命中，从数据源加载
        data = loadFromDataSource(key);
        
        // 根据数据特性选择缓存级别
        SmartCache.CacheLevel level = determineCacheLevel(key, data);
        smartCache.put(key, data, level);
        
        return data;
    }
    
    /**
     * 根据数据特性确定缓存级别
     */
    private SmartCache.CacheLevel determineCacheLevel(String key, Object data) {
        // 业务逻辑：根据key或data的特性决定缓存级别
        if (key.startsWith("hot_")) {
            return SmartCache.CacheLevel.HOT;
        } else if (key.startsWith("temp_")) {
            return SmartCache.CacheLevel.TEMPORARY;
        } else {
            return SmartCache.CacheLevel.NORMAL;
        }
    }
    
    private Object loadFromDataSource(String key) {
        // 模拟数据加载
        return "Data for " + key;
    }
}

// ❌ 错误：不要这样使用软引用
SoftReference<String> ref = new SoftReference<>(new String("test"));
String str = ref.get();  // 可能立即返回null（如果对象被回收）

// ✅ 正确：先创建强引用，再创建软引用
String str = new String("test");
SoftReference<String> ref = new SoftReference<>(str);
// 使用完str后，再清除强引用
str = null;