[Java] 왜 HashSet 내부에서 사용되는 HashMap은 transient 예약어를 써서 선언됐을까

출처

ChatGPT

자바 1.8 소스 코드

---

자바 1.8의 HashSet 구현 중 코드

HashSet은 내부에 HashMap을 이용하고, 이 HashMap은 transient 키워드로 선언되어 있는 것을 확인할 수 있다.

private transient HashMap<E,Object> map;

// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();

public HashSet() {
    map = new HashMap<>();
}

public boolean add(E e) {
    return map.put(e, PRESENT) == null;
}

 

• 관련 글 -> [Java] transient 예약어

 

이유

HashSet 클래스 내부에서 HashMap이 transient 예약어로 선언된 이유는 HashSet이 직렬화될 때 특정한 방법으로 직렬화 과정을 제어하기 위해서이다.

 

1. 직렬화 형식 제어

• HashSet 클래스는 내부적으로 데이터를 저장하기 우해 HashMap을 사용하지만, HashSet의 직렬화 형식은 HshMap의 구조와 다르다. HashSet은 단순히 집합(set)으로서의 기능만을 제공하기 때문에 직렬화 시에도 HashMap 전체를 직렬화할 필요가 없다. 대신, HashSet에 저장된 요소들만 직렬화하면 된다.
• HashMap을 transient로 선언함으로써, 기본 직렬화 방식에서는 HashMap 자체가 직렬화되지 않도록 하고, HashSet의 직렬화 매커니즘을 통해 필요한 데이터를 별로 직렬화할 수 있게 한다.

2. 커스텀 직렬화 구현

• HashSet 클래스는 wirteObject와 readObject 메소드를 오버라이드해 커스텀 직렬화 및 역직렬화 로직을 구현하고 있다. 이 메소들은 HashSet에 포함된 요소들만 직렬화 및 역직렬화하도록 처리한다.
• 따라서, HashMap 필드가 transient로 선언되었기 때문에, JVM은 이 필드를 자동으로 직렬화하지 않고, 대신 HashSet 클래스의 커스텀 로직에 따라 요소들이 직렬화된다.

HashSet의 커스텀 직렬화 구현이 된 소스 코드는 아래에 있다.

3. 불필요한 데이터의 직렬화 방지

만약 HashMap이 직렬화 과정에서 그대로 직렬화된다면, HashSet에 필요한 것 이상의 데이터가 직렬화될 수 있다. 이는 불필요한 메모리 사용을 초래할 수 있고, 직렬화된 데이터의 크기가 커져 네트워크 전송 시 비효율적일 수 있다.

 

코드

자바 1.8의 HashSet 클래스의 직렬화 관련 부분의 코드다.

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    //Set의 요소들을 직렬화하는 로직
    
    // Write out any hidden serialization magic
    s.defaultWriteObject();
    // Write out HashMap capacity and load factor
    s.writeInt(map.capacity());
    s.writeFloat(map.loadFactor());
    // Write out size
    s.writeInt(map.size());
    // Write out all elements in the proper order.
    for (E e : map.keySet())
        s.writeObject(e);
}

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Set의 요소들을 역직렬화하는 로직
    
    // Read in any hidden serialization magic
    s.defaultReadObject();
    // Read capacity and verify non-negative.
    int capacity = s.readInt();
    if (capacity < 0) {
        throw new InvalidObjectException("Illegal capacity: " +
                                         capacity);
    }
    // Read load factor and verify positive and non NaN.
    float loadFactor = s.readFloat();
    if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
        throw new InvalidObjectException("Illegal load factor: " +
                                         loadFactor);
    }
    // Read size and verify non-negative.
    int size = s.readInt();
    if (size < 0) {
        throw new InvalidObjectException("Illegal size: " +
                                         size);
    }
    // Set the capacity according to the size and load factor ensuring that
    // the HashMap is at least 25% full but clamping to maximum capacity.
    capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
            HashMap.MAXIMUM_CAPACITY);
    // Constructing the backing map will lazily create an array when the first element is
    // added, so check it before construction. Call HashMap.tableSizeFor to compute the
    // actual allocation size. Check Map.Entry[].class since it's the nearest public type to
    // what is actually created.
    SharedSecrets.getJavaOISAccess()
                 .checkArray(s, Map.Entry[].class, HashMap.tableSizeFor(capacity));
    // Create backing HashMap
    map = (((HashSet<?>)this) instanceof LinkedHashSet ?
           new LinkedHashMap<E,Object>(capacity, loadFactor) :
           new HashMap<E,Object>(capacity, loadFactor));
    // Read in all elements in the proper order.
    for (int i=0; i<size; i++) {
        @SuppressWarnings("unchecked")
            E e = (E) s.readObject();
        map.put(e, PRESENT);
    }
}

 

transient 키워드를 사용해 HashMap을 직렬화 대상에서 제외하고, 대신 HashSet의 요소들만 직렬화해 효율성을 높인 것이다.

 

결론

HashSet 내부에서 HashMap 필드를 transient로 선언한 것은 직렬화 시 불필요한 데이터를 피하고, HashSet에 적합한 직렬화 형식을 사용하기 위한 조치이다. 이를 통해 메모리 사용량을 줄이고 직렬화/역직렬화 성능을 향상시킬 수 있다.