3 Weeks - [ConcurrentHashMap과 HashMap]

HashMap과 ConcurrentHashMap은 어떤점들이 다르고 어떤상황에 적합한가요?

HashMap

내부 구현

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {

...

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

...
}

key와 value에 null을 허용한다.
thread-safe하지 않다.
- 내부 구현에서 볼 수 있듯, 입력함수에 대해서 어떠한 동기화 과정도 찾을 수 없다.
동기화 문제를 막기 위해, 반복자(iterator 등)를 생성 후 HashMap이 수정되면 ConcurrentModificationException을 발생시킨다.
- 문제 발생은 막지만, 여전히 동시성 문제를 해결한 상태로 사용할수는 없다.
그 대신 속도가 빠르기 때문에, 단일 쓰레드 환경에서 입력과 수정이 잦은 경우라면 hashmap을 사용하는 것이 효율적이다.

ConcurrentHashMap

내부구현

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {

...

public V put(K key, V value) {
    return putVal(key, value, false);
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) {
        throw new NullPointerException();
    }
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}
...
}

key와 value에 null을 허용하지 않는다.
동기화를 보장한다. (thread safe하다)
추가 및 삭제와 같은 수정 작업만 동기화를 유발한다.
- 읽기에 대해서는 hashmap과 속도가 같다.
  - 수정과 읽기가 동시에 일어나는 경우 어떤 값이 나올지는 장담할 수 없다.
동기화 처리를 할 때, 어떤 entry를 조작하는 경우에 해당 entry에 대해서만 락을 건다.
- entry 아이템 별로 락을 거는 방식으로 속도를 높였다.
- 코드 내부 for문에서 else부분을 보면 f에 대해서 syncronized block 이 있는 것을 확인 할 수 있다.

번외 : HashTable

ConcurrentHashMap과 같이, null을 허용하지 않고 동기화를 보장한다.
내부적으로 put 함수 자체에 syncronized 키워드가 붙어있다.
syncronized를 통한 쓰레드 간 동기화 락은 매우 느린 동작이기에 ConcurrentHashMap보다 훨씬 비효율적이다.

결론적으로...

HashMap은 신뢰성과 안정성이 낮은 대신 수정 속도가 빠릅니다.
- 단일 쓰레드 환경에서 사용하기 좋습니다.
ConcurrentHashMap은 속도는 HashMap보다 느리지만 신뢰성과 안정성이 좋습니다.
- HashMap의 동기화 문제를 (HashTable보다 효율적으로) 해결하기 위해 만들어졌습니다.
- 멀티 쓰레드 환경에서 수정이 빈번히 일어날 때 사용하기 좋습니다.

HashMap은 동시성 이슈를 해결하지 못하는걸까요?

내부적 구조 자체가 동시성을 고려하지 않았기에 HashMap을 상속하여 구현을 다르게 하지 않는 이상 힘들 것 같아요.

참고 : https://tecoble.techcourse.co.kr/post/2021-11-26-hashmap-hashtable-concurrenthashmap/

SSAFY-Book-Study / modern-java-in-action

3 Weeks - [ConcurrentHashMap과 HashMap] #44

문제

contents - 세부 내용

참고

HashMap

ConcurrentHashMap

번외 : HashTable

syncronized를 통한 쓰레드 간 동기화 락은 매우 느린 동작이기에 ConcurrentHashMap보다 훨씬 비효율적이다.