Object obj = new Object(); // 這就是強(qiáng)引用

public class StrongReferenceExample {
    private List<String> cache = new ArrayList<>();
    
    public void addToCache(String data) {
        cache.add(data); // 強(qiáng)引用保留對(duì)象
    }
    
    public void clearCache() {
        cache.clear(); // 必須顯式清除
    }
}

SoftReference<Object> softRef = new SoftReference<>(new Object());

public class ImageCache {
    private final Map<String, SoftReference<Bitmap>> cache = new HashMap<>();
    
    public Bitmap getImage(String key) {
        SoftReference<Bitmap> ref = cache.get(key);
        return ref != null ? ref.get() : null;
    }
    
    public void putImage(String key, Bitmap image) {
        cache.put(key, new SoftReference<>(image));
    }
}

import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;

public class MemorySensitiveCache<K, V> {
    private final Map<K, SoftReference<V>> cache = new HashMap<>();

    // 存入緩存（使用軟引用，內(nèi)存不足時(shí)可被GC回收）
    public void put(K key, V value) {
        cache.put(key, new SoftReference<>(value));
    }

    // 從緩存讀?。赡芊祷豱ull如果已被GC回收）
    public V get(K key) {
        SoftReference<V> ref = cache.get(key);
        return (ref != null) ? ref.get() : null;
    }

    // 示例：內(nèi)存監(jiān)控線程
    public void startMemoryMonitor() {
        new Thread(() -> {
            while (true) {
                long freeMem = Runtime.getRuntime().freeMemory();
                if (freeMem < 1024 * 1024) { // 如果剩余內(nèi)存 < 1MB
                    System.out.println("內(nèi)存緊張，清理緩存...");
                    cache.clear();
                }
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
            }
        }).start();
    }
}

WeakReference<Object> weakRef = new WeakReference<>(new Object());

import java.util.WeakHashMap;

public class WeakHashMapExample {
    public static void main(String[] args) {
        WeakHashMap<Object, String> map = new WeakHashMap<>();
        
        Object key = new Object();
        map.put(key, "Value");
        
        System.out.println("GC 前: " + map.size()); // 1
        
        key = null; // 斷開強(qiáng)引用
        System.gc(); // 觸發(fā) GC
        
        System.out.println("GC 后: " + map.size()); // 0（Entry 被自動(dòng)清理）
    }
}

ReferenceQueue<Object> queue = new ReferenceQueue<>();
PhantomReference<Object> phantomRef = new PhantomReference<>(new Object(), queue);

public class Room {
    private static final Set<String> LEAKED_KEYS = new HashSet<>();
    private String roomKey;

    public Room(String key) {
        this.roomKey = key;
        LEAKED_KEYS.add(key); // 登記鑰匙
        System.out.println("拿到鑰匙進(jìn)入房間: " + key);
    }

    // 主動(dòng)還鑰匙（推薦方式）
    public void returnKey() {
        if (roomKey != null) {
            System.out.println("主動(dòng)歸還鑰匙: " + roomKey);
            LEAKED_KEYS.remove(roomKey); // 注銷鑰匙
            roomKey = null;
        }
    }

    @Override
    protected void finalize() throws Throwable {
        if (roomKey != null) {
            System.out.println("警告！鑰匙未被歸還: " + roomKey + " (內(nèi)存泄漏)");
            LEAKED_KEYS.remove(roomKey); // 清理登記
        }
    }

    public static void main(String[] args) {
        // 好租客
        Room goodRoom = new Room("A101");
        goodRoom.returnKey();

        // 壞租客
        new Room("B202"); // 直接不保存引用
        
        System.gc();
        try { Thread.sleep(1000); } catch (Exception e) {}
        
        System.out.println("未歸還的鑰匙: " + LEAKED_KEYS);
    }
}

// 實(shí)現(xiàn) AutoCloseable，用 try-with-resources 確保資源釋放
class Resource implements AutoCloseable {
    @Override
    public void close() {
        System.out.println("Resource closed!");
    }
}

public class Main {
    public static void main(String[] args) {
        try (Resource r = new Resource()) {
            // 使用資源
        } // 自動(dòng)調(diào)用 close()
    }
}

// Cleaner 內(nèi)部實(shí)現(xiàn)偽代碼
public class Cleaner {
    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
    private final PhantomReference<Object> phantomRef;
    private final Runnable cleanupAction;
    
    public static Cleaner create() {
        return new Cleaner();
    }
    
    public Cleanable register(Object obj, Runnable action) {
        phantomRef = new PhantomReference<>(obj, queue);
        this.cleanupAction = action;
        startCleanerThread();  // 啟動(dòng)監(jiān)控線程
        return new CleanableImpl();
    }
    
    private void startCleanerThread() {
        Thread thread = new Thread(() -> {
            while (true) {
                Reference<?> ref = queue.remove(); // 阻塞等待
                if (ref == phantomRef) {
                    cleanupAction.run();
                }
            }
        });
        thread.setDaemon(true);
        thread.start();
    }
}

import java.lang.ref.Cleaner;

public class CleanerDemo {
    private static final Cleaner cleaner = Cleaner.create();

    static class Resource implements Runnable {
        @Override
        public void run() {
            System.out.println("Cleaner action executed!");
        }
    }

    public static void main(String[] args) {
        Resource resource = new Resource();
        cleaner.register(new Object(), resource); // 注冊(cè)清理動(dòng)作
        System.gc();
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
    }
}