Reference Types — WeakReference, SoftReference, PhantomReference

Strong > Soft > Weak > Phantom

// 가장 기본적인 참조 — Strong Reference
Object obj = new Object();

public class Cache {
    // 키를 넣으면 영원히 GC되지 않는 구조
    private static final Map<String, byte[]> cache = new HashMap<>();

    public static void put(String key, byte[] data) {
        cache.put(key, data);
        // 제거 로직이 없으면 데이터가 계속 쌓임
    }
}

import java.lang.ref.SoftReference;

// SoftReference로 감싸기
Object obj = new Object();
SoftReference<Object> softRef = new SoftReference<>(obj);

// Strong 참조 제거
obj = null;

// 메모리가 충분하면 여전히 접근 가능
Object retrieved = softRef.get(); // null이 아닐 수 있음

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

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

    public void put(K key, V value) {
        cache.put(key, new SoftReference<>(value));
    }

    public V get(K key) {
        SoftReference<V> ref = cache.get(key);
        if (ref == null) return null;

        V value = ref.get();
        if (value == null) {
            // GC에 의해 수거됨 — 엔트리 정리
            cache.remove(key);
        }
        return value;
    }
}

import java.lang.ref.WeakReference;

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

// Strong 참조 제거
obj = null;

// 다음 GC에서 수거될 수 있음
System.gc(); // GC 유도 (보장은 아님)
System.out.println(weakRef.get()); // null일 가능성 높음

import java.util.WeakHashMap;

WeakHashMap<Object, String> map = new WeakHashMap<>();

Object key = new Object();
map.put(key, "데이터");

System.out.println(map.size()); // 1

// 키에 대한 Strong 참조 제거
key = null;

// GC 유도
System.gc();

// 약간의 지연 후 확인
try { Thread.sleep(100); } catch (InterruptedException e) {}

System.out.println(map.size()); // 0일 가능성 높음

// WeakHashMap 내부 구조 (개념적 의사 코드)
class WeakHashMap<K, V> {
    private ReferenceQueue<Object> queue = new ReferenceQueue<>();

    // 키를 WeakReference로 감싸서 저장
    static class Entry<K, V> extends WeakReference<Object> {
        V value;
        Entry(Object key, V value, ReferenceQueue<Object> queue) {
            super(key, queue); // 키를 약한 참조로, 큐에 등록
            this.value = value;
        }
    }

    // 맵 접근 시마다 호출되어 GC된 엔트리 정리
    private void expungeStaleEntries() {
        // queue에서 수거된 참조를 꺼내서 맵에서 제거
    }
}

WeakHashMap<String, String> map = new WeakHashMap<>();

// 문자열 리터럴은 String Pool에 Strong 참조가 있어서 수거 안 됨
map.put("hello", "world");

// new String()으로 만들어야 수거 가능
map.put(new String("hello2"), "world2");

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

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

// get()은 항상 null
System.out.println(phantomRef.get()); // null

// Strong 참조 제거
obj = null;
System.gc();

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

public class ResourceCleaner {
    private static final ReferenceQueue<Object> queue = new ReferenceQueue<>();

    // 정리해야 할 리소스 정보를 별도로 보관
    private static final Map<PhantomReference<Object>, Runnable> cleanupActions
        = new ConcurrentHashMap<>();

    // 리소스 등록
    public static void register(Object obj, Runnable cleanupAction) {
        PhantomReference<Object> ref = new PhantomReference<>(obj, queue);
        cleanupActions.put(ref, cleanupAction);
    }

    // 정리 스레드 — 백그라운드에서 계속 실행
    static {
        Thread cleanerThread = new Thread(() -> {
            while (true) {
                try {
                    // 큐에서 수거된 참조를 꺼냄 (블로킹)
                    Reference<?> ref = queue.remove();
                    Runnable action = cleanupActions.remove(ref);
                    if (action != null) {
                        action.run(); // 리소스 정리 실행
                    }
                    ref.clear(); // 참조 해제
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        cleanerThread.setDaemon(true);
        cleanerThread.start();
    }
}

import java.lang.ref.Cleaner;

public class NativeResource implements AutoCloseable {
    private static final Cleaner cleaner = Cleaner.create();

    // 정리 로직은 static 내부 클래스로 분리 (외부 객체 참조 방지)
    private static class CleanupAction implements Runnable {
        private long nativePointer;

        CleanupAction(long nativePointer) {
            this.nativePointer = nativePointer;
        }

        @Override
        public void run() {
            // 네이티브 리소스 해제
            System.out.println("네이티브 리소스 정리: " + nativePointer);
            nativePointer = 0;
        }
    }

    private final long nativePointer;
    private final Cleaner.Cleanable cleanable;

    public NativeResource() {
        this.nativePointer = allocateNative(); // 네이티브 리소스 할당
        this.cleanable = cleaner.register(this, new CleanupAction(nativePointer));
    }

    @Override
    public void close() {
        cleanable.clean(); // 명시적 정리
    }

    private static long allocateNative() {
        return System.nanoTime(); // 예시용
    }
}

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

ReferenceQueue<Object> queue = new ReferenceQueue<>();

Object obj1 = new Object();
Object obj2 = new Object();

// 큐와 함께 WeakReference 생성
WeakReference<Object> ref1 = new WeakReference<>(obj1, queue);
WeakReference<Object> ref2 = new WeakReference<>(obj2, queue);

// Strong 참조 하나만 제거
obj1 = null;

System.gc();

// 큐에서 수거된 참조 확인
Reference<?> polled = queue.poll(); // ref1이 들어있을 수 있음
if (polled == ref1) {
    System.out.println("obj1이 GC되었습니다");
}

// 1. static 컬렉션에 계속 추가
private static final List<Object> list = new ArrayList<>();

// 2. 리스너 등록 후 해제 안 함
button.addActionListener(listener);
// removeActionListener를 안 하면 listener가 계속 살아있음

// 3. 내부 클래스가 외부 클래스를 참조
class Outer {
    byte[] data = new byte[1024 * 1024]; // 1MB

    class Inner {
        // Inner는 Outer에 대한 암묵적 Strong 참조를 가짐
    }
}

// 리스너를 WeakReference로 관리하는 패턴
public class EventBus {
    private final List<WeakReference<EventListener>> listeners = new ArrayList<>();

    public void register(EventListener listener) {
        listeners.add(new WeakReference<>(listener));
    }

    public void fire(Event event) {
        // 순회하면서 GC된 리스너는 자동 정리
        Iterator<WeakReference<EventListener>> it = listeners.iterator();
        while (it.hasNext()) {
            EventListener listener = it.next().get();
            if (listener == null) {
                it.remove(); // GC된 참조 제거
            } else {
                listener.onEvent(event);
            }
        }
    }
}