Java Concurrent Collections: 스레드 안전 컬렉션 완벽 가이드

// ❌ 동기화 컬렉션 - 전체 락
Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());

// 모든 연산에 전체 락 →  심각한 병목
syncMap.put("key1", 1);  // 전체 맵 락
syncMap.get("key1");     // 전체 맵 락

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

// 기본 연산 (스레드 안전)
map.put("key1", 1);
map.get("key1");
map.remove("key1");

// 원자적 복합 연산 ⭐
map.putIfAbsent("key", 100);           // 없으면 추가
map.computeIfAbsent("key", k -> 100);  // 없으면 계산 후 추가
map.computeIfPresent("key", (k, v) -> v + 1);  // 있으면 업데이트
map.merge("key", 1, Integer::sum);     // 있으면 합계, 없으면 추가

// ⚠️ 주의: 아래는 원자적이지 않음!
if (!map.containsKey("key")) {  // check
    map.put("key", value);      // then act → 경쟁 조건!
}

// ✅ 올바른 방법
map.computeIfAbsent("key", k -> expensiveComputation());

public class SimpleCache<K, V> {
    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();
    private final Function<K, V> loader;
    
    public SimpleCache(Function<K, V> loader) {
        this.loader = loader;
    }
    
    public V get(K key) {
        // 원자적으로 캐시 로드
        return cache.computeIfAbsent(key, loader);
    }
    
    public void invalidate(K key) {
        cache.remove(key);
    }
    
    public void invalidateAll() {
        cache.clear();
    }
}

// ✅ 읽기가 대부분, 쓰기가 드문 경우
CopyOnWriteArrayList<EventListener> listeners = new CopyOnWriteArrayList<>();

// 읽기: 락 없이 안전한 순회
for (EventListener listener : listeners) {
    listener.onEvent(event);  // ConcurrentModificationException 없음
}

// 쓰기: 전체 복사 (비용 높음)
listeners.add(newListener);

// ✅ 적합한 경우
// - 이벤트 리스너 관리
// - 설정(Configuration) 목록
// - 화이트리스트/블랙리스트

// ❌ 부적합한 경우
// - 자주 변경되는 데이터
// - 대용량 데이터

// 중복 없는 CopyOnWrite Set
CopyOnWriteArraySet<String> allowedIps = new CopyOnWriteArraySet<>();

allowedIps.add("192.168.1.1");
allowedIps.add("192.168.1.2");

// 읽기 (락 없음)
if (allowedIps.contains(clientIp)) {
    // 허용
}

// 작업 큐
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(100);

// 생산자
public void submitTask(Runnable task) throws InterruptedException {
    workQueue.put(task);  // 큐가 가득 차면 블로킹
}

// 소비자 (Worker Thread)
public void processLoop() {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            Runnable task = workQueue.take();  // 비어있으면 블로킹
            task.run();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            break;
        }
    }
}

// 타임아웃 있는 offer
boolean success = queue.offer(task, 5, TimeUnit.SECONDS);
if (!success) {
    // 5초 내 삽입 실패 처리
    handleQueueFull();
}

// 타임아웃 있는 poll
Runnable task = queue.poll(1, TimeUnit.SECONDS);
if (task == null) {
    // 1초 내 작업 없음
    handleIdleState();
}

public class ConcurrentCounter {
    private final ConcurrentHashMap<String, LongAdder> counters = 
        new ConcurrentHashMap<>();
    
    public void increment(String key) {
        counters.computeIfAbsent(key, k -> new LongAdder()).increment();
    }
    
    public long get(String key) {
        LongAdder adder = counters.get(key);
        return adder != null ? adder.sum() : 0;
    }
}

// 사용
ConcurrentCounter hitCounter = new ConcurrentCounter();
hitCounter.increment("/api/users");
hitCounter.increment("/api/orders");

public class ServiceRegistry {
    private static final ConcurrentHashMap<Class<?>, Object> services = 
        new ConcurrentHashMap<>();
    
    @SuppressWarnings("unchecked")
    public static <T> T getService(Class<T> type, Supplier<T> factory) {
        return (T) services.computeIfAbsent(type, t -> factory.get());
    }
}

// 사용
UserService userService = ServiceRegistry.getService(
    UserService.class, 
    UserServiceImpl::new
);