[이펙티브 자바] Item07 완벽공략. WeakHashMap

item07. 다 쓴 객체 참조를 해제하라. 

" p38. WeakHashMap, 약한 참조 (Weak reference)"

 

 

 

WeakHashMap이란? 

: 더이상 사용하지 않는 객체를 GC할 때 자동으로 삭제해주는 Map이다. 

이때 맵의 value가 아니라 key를 기준으로 key를 더이상 강하게 참조되는 곳이 없다면 해당 엔트리를 제거한다. 

그러므로 맵의 key에 의존하는 경우에 사용할 수 있다. 

 

그리고 이때 조심해야 하는 것은 Integer, String 과 같은 값들은 더이상 사용하지 않는다고 하더라도 제거되지 않는다..!!

어딘가에 값이 저장? 되어 있기 때문이다. 

 

package chapter01.item07.cache;

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

import org.springframework.cglib.core.WeakCacheKey;

/**
 * item07. 다 쓴 객체 참조를 해제하라.
 */
public class PostRepository
{
   private Map<CacheKey, Post> cache;
   
   public PostRepository()
   {
      this.cache = new WeakHashMap<>();
   }
   
   public Post getPostById(Integer id)
   {
      CacheKey key = new CacheKey(id);
      
      if (cache.containsKey(key)) {
         return cache.get(key);
      }else {
         Post post = new Post(); // TODO DB에서 읽어오거나 REST API를 통해 읽어올 수 있다.
         cache.put(key, post);
         return post;
      }
   }
   
   public Map<CacheKey, Post> getCache()
   {
      return cache;
   }
}

@Test
void cache() throws InterruptedException
{
   PostRepository postRepository = new PostRepository();
   Integer p1 = 1;
   postRepository.getPostById(p1);
   
   assertFalse(postRepository.getCache().isEmpty());
   
   System.out.println("run gc");
   System.gc();
   System.out.println("wait");
   Thread.sleep(3000L);
   
   assertTrue(postRepository.getCache().isEmpty());
}

해당 테스트를 실행해보면 key를 강하게 참조하는 곳이 없기 때문에 GC할 때 캐시가 지워지면서 테스트 성공하는 것을 알 수 있다. 

 

 

💡 WeakHashMap는 캐시를 구현하는데 사용할 수 있지만, 캐시를 직접 구현하는 것은 권장하지 않는다!!

 

 

 

레퍼런스 종류

 

- strong reference 

: 그냥 흔하게 = 를 사용해서 하는 방법을 strong reference라고 한다. 

ArrayList<Channel> channelList = new ArrayList<>();  -> 이런 방법 

 

 

- soft reference

public class SoftReferenceExample {

    public static void main(String[] args) throws InterruptedException {
        Object strong = new Object();
        SoftReference<Object> soft = new SoftReference<>(strong);
        strong = null;

        System.gc();
        Thread.sleep(3000L);

        // softReference도 GC의 대상이 되기는 하지만..
        // 메모리가 부족할 때 제거하기 때문에 지금은 사라지지 않을 것이다. (메모리가 지금은 충분하기 때문)
        System.out.println(soft.get());
    }
}

SoftReference는 GC의 대상이 되기는 하지만 바로 제거되는게 아니라 메모리가 부족해진 상황이면 그때 제거한다. 

 

 

- weak reference

public class WeakReferenceExample {
    public static void main(String[] args) throws InterruptedException {
        Object strong = new Object();
        WeakReference<Object> weak = new WeakReference<>(strong);
        strong = null;

        System.gc();
        Thread.sleep(3000L);

        // WeakReference는 제거된다. (soft보다 약하게 참조하는 상태이기 때문에)
        System.out.println("weak.get() = " + weak.get());
    }
}

weak referecnce는 soft보다 약한 참조로 weak referecne는 참조되는 부분이 없다면 GC 할 때 제거한다. 

 

 

- phantom reference 

public class PhantomReferenceExample {
    public static void main(String[] args) throws InterruptedException {
        BigObject strong = new BigObject();
        ReferenceQueue<BigObject> rq = new ReferenceQueue<>();

        PhantomReference<BigObject> phantom = new PhantomReference<>(strong,rq);
        strong = null;

        System.gc();
        Thread.sleep(3000L);

        // 사라지지는 않고 queue에 들어간다.
        System.out.println("phantom.isEnqueued() = " + phantom.isEnqueued());

        Reference<? extends BigObject> reference = rq.poll();
        reference.clear(); // 이렇게 하면 최종적으로 사라진다.

    }
}

phantom reference는 좀 더 어려운데 GC할 때 사라지는 것이 아니라 ReferenceQueue에 들어간다. 

들어간 것을 확인할 수 있고, reference에 대해서 clear를 하면 queue에 들어갔던 값도 제거하게 되고, 이러면 최종적으로 제거된다. 

 

 

Phantom reference로 자원 해제할 때 사용할 수도 있는데 그럴 때는 직접 커스텀해서 사용해야 한다. 

package chapter01.item07.reference;

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

/**
 * 자원을 반납하고 싶은 용도로 사용할 때
 */
public class BigObjectReference<BigObject> extends PhantomReference<BigObject> {

    /**
     * Creates a new phantom reference that refers to the given object and
     * is registered with the given queue.
     *
     * <p> It is possible to create a phantom reference with a {@code null}
     * queue, but such a reference is completely useless: Its {@code get}
     * method will always return {@code null} and, since it does not have a queue,
     * it will never be enqueued.
     *
     * @param referent the object the new phantom reference will refer to
     * @param q        the queue with which the reference is to be registered,
     *                 or {@code null} if registration is not required
     */
    public BigObjectReference(BigObject referent, ReferenceQueue<? super BigObject> q) {
        super(referent, q);
    }

    // 임의로 만든 것 (여기서 자원 반납을 하겠다~)
    public void cleanUp() {
        System.out.println("clean up!!");
    }
}

 

public class PhantomReferenceExample {
    public static void main(String[] args) throws InterruptedException {
        BigObject strong = new BigObject();
        ReferenceQueue<BigObject> rq = new ReferenceQueue<>();

        PhantomReference<BigObject> phantom = new PhantomReference<>(strong,rq);
        strong = null;

        System.gc();
        Thread.sleep(3000L);

        // 사라지지는 않고 queue에 들어간다.
        System.out.println("phantom.isEnqueued() = " + phantom.isEnqueued());

        Reference<? extends BigObject> reference = rq.poll();
        BigObjectReference bigObjectCleaner = (BigObjectReference) reference;
        bigObjectCleaner.cleanUp(); // 자원 반납 메서드 실행
        reference.clear(); // 이렇게 하면 최종적으로 사라진다.

    }
}

이렇게 해서 자원 반납을 할 수도 있다. 

 

 

 

🐥 근데 지금까지 SoftReference 나 WeakReference, PhantomReference는 본 적이 없는데 

엄청 큰 Object가 있다거나 이러지 않는다면 사실 거의 사용될 일이 없다고 한다. 

SoftReference나 Weak 이런건 언제 자원 해제 되는지도 알기 어렵고 애매하기 때문에 나도 그냥 명시적으로 자원 해제해주는 것이 더 좋다고 생각한다.