Item 7. Obsolete Object
๋ค ์ด ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํด์ ํ๋ผ
Java๋ ๊ฐ๋น์ง ์ปฌ๋ ํฐ๋ฅผ ํตํด ๋ฉ๋ชจ๋ฆฌ ๋์๋ฅผ ๋ฐฉ์งํด์ฃผ๊ธฐ ๋๋ฌธ์, C/C++๊ณผ ๊ฐ์ ์ธ์ด์ฒ๋ผ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ง์ ๊ด๋ฆฌํ ํ์๊ฐ ์๋ค. ํ์ง๋ง ๊ทธ๋ ๋ค๊ณ ์ ํ ์ ๊ฒฝ์ฐ์ง ์์๋ ๋๋ ๊ฒ์ ์๋๋ค.
๋ฉ๋ชจ๋ฆฌ ๋์ ์์
public class Stack {
private static final int DEFAULT_INITIAL_CAPACITY = 16;
private Object[] elements;
private int size = 0;
public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}
public Object pop() {
if (size == 0) {
throw new EmptyStackException();
}
return elements[--size];
}
/**
* ์์๋ฅผ ์ํ ๊ณต๊ฐ์ ์ ์ด๋ ํ๋ ์ด์ ํ๋ณด
* ๋ฐฐ์ด ํฌ๊ธฐ๋ฅผ ๋๋ ค์ผ ํ ๋๋ง๋ค ์ฝ ๋ ๋ฐฐ์ฉ ์ฆ๊ฐ
*/
private void ensureCapacity() {
if (elements.length == size) {
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}
}
์ ์ฝ๋์ pop()
๋ฉ์๋์์ ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ๋ฐ์ํ ์ ์๋ค.
pop()
๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด elements
๋ฐฐ์ด์์ ์์๋ฅผ ๊บผ๋ด ๋ฐํํ๊ณ , size
๋ฅผ ๊ฐ์์ํค๊ณ ์์ง๋ง, ๋ฐฐ์ด์ด ์ฌ์ ํ ์ฐธ์กฐํ๊ณ ์๊ธฐ ๋๋ฌธ์ ๊ฐ๋น์ง ์ปฌ๋ ํฐ๊ฐ ํ์ํ์ง ์๋๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์๋ pop()
๋ฉ์๋์์ elements
๋ฐฐ์ด์์ ๊บผ๋ธ ์์๋ฅผ null
์ฒ๋ฆฌํด์ฃผ๋ฉด ๋๋ค.
public class Stack {
// ...
public Object pop() {
if (size == 0) {
throw new EmptyStackException();
}
Object result = elements[--size];
elements[size] = null; // ๋ค ์ด ์ฐธ์กฐ ํด์
return result;
}
// ...
}
์ด๋ ๊ฒ ํ๋ฉด pop
์ฒ๋ฆฌํ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ๋ ค๊ณ ํด๋ NullPointerException
์ด ๋ฐ์ํ๊ธฐ ๋๋ฌธ์, ์๋ํ์ง ์์ ์ฌ์ฉ์ ๋ฐฉ์งํ ์ ์๋ ํจ๊ณผ๋ ์๋ค.
์ค์ฝํ์ ์ํ ์ฐธ์กฐ ํด์
์ฌ์ค ํ๋ก๊ทธ๋๋ฐ ํ ๋ ์ ๊ฒฝ์ฐ์ฒ๋ผ ์ผ์ผ์ด null
์ฒ๋ฆฌ๋ฅผ ํด์ค ํ์๋ ์๋ค.(์ ์์๋ Stack ํด๋์ค๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ง์ ๊ด๋ฆฌํ๊ธฐ ๋๋ฌธ์ ๊ทธ๋ ๋ค.)
๋ค ์ด ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ํด์ ํ๋ ๊ฐ์ฅ ์ข์ ๋ฐฉ๋ฒ์ ํด๋น ์ฐธ์กฐ๋ฅผ ๋ด์ ๋ณ์๋ฅผ ์ ํจ ๋ฒ์(scope) ๋ฐ์ผ๋ก ๋ฐ์ด๋ด๋ ๊ฒ์ด๋ค.
์ข์ ํ๋ก๊ทธ๋๋ฐ ์ต๊ด์ ๊ฐ์ง๊ณ ์๋ค๋ฉด, ๋ณ์์ ์ ํจ ๋ฒ์๋ฅผ ์ต์ํํ๋ ค๊ณ ๋
ธ๋ ฅํ๊ธฐ ๋๋ฌธ์ ์ด๋ฌํ ๊ฒฝ์ฐ๋ ์์ฐ์ค๋ฝ๊ฒ ํด๊ฒฐ๋๋ค.
์บ์
์บ์๋ ๋ฉ๋ชจ๋ฆฌ ๋์๋ฅผ ์ผ์ผํค๋ ์ฃผ๋ฒ ์ค ํ๋์ด๊ธฐ ๋๋ฌธ์ ์ฃผ์ํด์ผ ํ๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๋ฐฉ๋ฒ๋ค ์ค ํ๋๋ก, ์บ์๋ฅผ ์ฌ์ฉํ ๋ WeakHashMap
์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ์๋ค.
(๋จ, ์ด ๋ฐฉ๋ฒ์ ์บ์ ์ธ๋ถ์์ ํค๋ฅผ ์ฐธ์กฐํ๋ ๋์๋ง ๊ฐ์ด ์ด์์๋ ์บ์๋ฅผ ๋ง๋ค ์ ์๋ค.)
class Test {
public static void main(String[] args) {
/*
WeakHashMap์ ์ฃผ์ ํน์ง์ ํค์ ๋ํด ์ฝํ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ๋ค๋ ๊ฒ์ผ๋ก,
์ฝํ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ๊ฐ๋ ฅํ ์ฐธ์กฐ๊ฐ ์์ ๋ ๊ฐ์ฒด๊ฐ ๊ฐ๋น์ง ์ปฌ๋ ์
์ ๋์์ด ๋๋ค.
*/
WeakHashMap<Integer, Integer> weakHashMap = new WeakHashMap<>();
Integer key1 = 59;
Integer key2 = 95;
weakHashMap.put(key1, 1);
weakHashMap.put(key2, 2);
System.out.println("before call gc() : " + weakHashMap.size()); // 2
key1 = null; // ํค๋ฅผ null๋ก ๋ง๋ค์ด์ GC ๋์์ด ๋๋๋ก ํ๋ค.
System.gc(); // ์ ์ฝ๋์์ testWeakKey1์ null์ด ๋์์ผ๋ฏ๋ก GC ๋์์ด ๋๋ค.(๋ณด์ฅ๋์ง ์์)
System.out.println("after call gc() : " + weakHashMap.size()); // GC๊ฐ ๋์ํ์ง ์์๋ค๋ฉด 2, ๋์ํ๋ค๋ฉด 1
}
}
Last updated
Was this helpful?