ConcurrentHashMap — 동시성을 보장하는 해시맵의 내부

// 위험한 코드: 멀티스레드에서 HashMap 사용
Map<String, Integer> map = new HashMap<>();

// 스레드 1과 2가 동시에 put → 데이터 손실 또는 무한 루프 가능
Thread t1 = new Thread(() -> { for (int i = 0; i < 10000; i++) map.put("key" + i, i); });
Thread t2 = new Thread(() -> { for (int i = 0; i < 10000; i++) map.put("key" + i, i); });

// Hashtable 내부 (간략화)
public synchronized V get(Object key) { ... }
public synchronized V put(K key, V value) { ... }
public synchronized V remove(Object key) { ... }

Segment 0: [락] → 버킷 0~3
Segment 1: [락] → 버킷 4~7
Segment 2: [락] → 버킷 8~11
...

// ConcurrentHashMap 내부 동작 (간략화)
final V putVal(K key, V value, boolean onlyIfAbsent) {
    int hash = spread(key.hashCode());

    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;

        if (tab == null || (n = tab.length) == 0)
            tab = initTable(); // 초기화 (CAS로 동시성 제어)

        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 빈 버킷 → CAS로 원자적 삽입 (락 없음!)
            if (casTabAt(tab, i, null, new Node<>(hash, key, value)))
                break;
        }

        else {
            // 버킷에 이미 노드가 있음 → 해당 버킷 헤드에 synchronized
            synchronized (f) {
                // 연결 리스트 또는 트리에 삽입
                if (tabAt(tab, i) == f) {
                    // ... 삽입 로직
                }
            }
        }
    }
}

// CAS: 현재 값이 예상 값과 같으면 새 값으로 교체 (원자적)
boolean casTabAt(Node<K,V>[] tab, int i, Node<K,V> c, Node<K,V> v) {
    return U.compareAndSetObject(tab,
        ((long)i << ASHIFT) + ABASE, c, v);
}

public V get(Object key) {
    // volatile 읽기만 사용 — 락 없음!
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode());

    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // ... 탐색
    }
    return null;
}

// HashMap에서는 이것이 가능
map.put("key", null);
map.get("key"); // null 반환 → 값이 null인가, 키가 없는가?
map.containsKey("key"); // true로 구분 가능

// ConcurrentHashMap에서는 동시성 때문에 이 패턴이 위험
// get과 containsKey 사이에 다른 스레드가 수정할 수 있음
if (map.get("key") == null) {
    // 이 사이에 다른 스레드가 값을 넣었을 수 있음!
    map.put("key", value);
}

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// putIfAbsent: 키가 없을 때만 삽입
map.putIfAbsent("counter", 0);

// compute: 키에 대한 값을 원자적으로 계산
map.compute("counter", (key, value) -> value == null ? 1 : value + 1);

// merge: 기존 값과 새 값을 합치기
map.merge("counter", 1, Integer::sum);

// computeIfAbsent: 키가 없을 때만 계산하여 삽입
map.computeIfAbsent("users", k -> new ArrayList<>()).add("Alice");

// computeIfPresent: 키가 있을 때만 값 변경
map.computeIfPresent("counter", (k, v) -> v + 10);

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager manager = new SimpleCacheManager();
        // 내부적으로 ConcurrentHashMap을 사용하는 캐시
        manager.setCaches(List.of(
            new ConcurrentMapCache("users"),
            new ConcurrentMapCache("products")
        ));
        return manager;
    }
}

@Service
public class UserService {
    @Cacheable("users")
    public User getUser(Long id) {
        return userRepository.findById(id).orElseThrow();
    }
}

// DefaultListableBeanFactory 내부
private final Map<String, BeanDefinition> beanDefinitionMap =
    new ConcurrentHashMap<>(256);

@Component
public class RequestCounter {
    private final ConcurrentHashMap<String, LongAdder> counters =
        new ConcurrentHashMap<>();

    public void increment(String endpoint) {
        // computeIfAbsent로 원자적으로 초기화 + LongAdder로 경합 최소화
        counters.computeIfAbsent(endpoint, k -> new LongAdder())
                .increment();
    }

    public long getCount(String endpoint) {
        LongAdder adder = counters.get(endpoint);
        return adder != null ? adder.sum() : 0;
    }

    public Map<String, Long> getAllCounts() {
        Map<String, Long> result = new HashMap<>();
        counters.forEach((k, v) -> result.put(k, v.sum()));
        return result;
    }
}

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// parallelismThreshold: 병렬 처리를 시작할 최소 요소 수
// 1이면 항상 병렬, Long.MAX_VALUE면 항상 직렬
map.forEach(1, (key, value) -> {
    System.out.println(key + ": " + value);
});

// 병렬 검색
String found = map.search(1, (key, value) ->
    value > 100 ? key : null
);

// 병렬 리듀스
int total = map.reduce(1,
    (key, value) -> value,     // 변환
    Integer::sum               // 합산
);

// size()는 추정치일 수 있음
int size = map.size(); // int 범위 초과 시 Integer.MAX_VALUE 반환

// 더 정확한 메서드
long count = map.mappingCount(); // long 반환