🔒 Java AtomicReference: 안전한 동시성 프로그래밍

🌟 AtomicReference의 탄생 배경

멀티스레드 환경에서 객체 참조를 안전하게 다루는 것은 Java 개발자들에게 항상 도전이었습니다. 전통적인 synchronized 키워드는 성능 오버헤드가 크고, 데드락 위험성이 존재했습니다.

Java 5에서 도입된 java.util.concurrent.atomic 패키지는 이러한 문제를 해결하기 위해 등장했습니다. AtomicReference는 객체 참조에 대한 원자적(atomic) 연산을 제공하여, 락 없이도 스레드 안전성을 보장합니다.

🎯 AtomicReference가 필요한 상황

📌 주요 사용 시나리오

• 멀티스레드 환경에서 객체 참조 업데이트
• Compare-and-Swap (CAS) 연산이 필요한 경우
• 락프리(Lock-free) 알고리즘 구현
• 캐시 시스템에서 안전한 참조 관리
• 상태 머신의 상태 전환 관리

🔧 AtomicReference 핵심 메서드

메서드 설명

get()	현재 값을 반환
set(V newValue)	값을 설정
compareAndSet(V expected, V update)	기댓값과 같으면 업데이트
getAndSet(V newValue)	이전 값을 반환하고 새 값으로 설정

💡 실전 예제 코드

예제 1: 스레드 안전한 카운터 구현

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class AtomicCounterExample {
    private static class Counter {
        private final int value;
        
        public Counter(int value) {
            this.value = value;
        }
        
        public Counter increment() {
            return new Counter(value + 1);
        }
        
        public int getValue() {
            return value;
        }
    }
    
    private final AtomicReference<Counter> counter = new AtomicReference<>(new Counter(0));
    
    public void increment() {
        Counter current, updated;
        do {
            current = counter.get();
            updated = current.increment();
        } while (!counter.compareAndSet(current, updated));
    }
    
    public int getValue() {
        return counter.get().getValue();
    }
    
    public static void main(String[] args) throws InterruptedException {
        AtomicCounterExample example = new AtomicCounterExample();
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // 1000개의 증가 작업을 동시에 실행
        for (int i = 0; i < 1000; i++) {
            executor.submit(example::increment);
        }
        
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS);
        
        System.out.println("최종 카운터 값: " + example.getValue()); // 1000
    }
}

예제 2: 멀티스레드 환경에서의 캐시 시스템

import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;

public class AtomicCacheExample {
    private static class CacheEntry<T> {
        private final T value;
        private final long timestamp;
        private final long ttl; // Time To Live (milliseconds)
        
        public CacheEntry(T value, long ttl) {
            this.value = value;
            this.timestamp = System.currentTimeMillis();
            this.ttl = ttl;
        }
        
        public boolean isExpired() {
            return System.currentTimeMillis() - timestamp > ttl;
        }
        
        public T getValue() {
            return value;
        }
    }
    
    private final AtomicReference<CacheEntry<String>> cache = new AtomicReference<>();
    
    public String getValue(Supplier<String> dataLoader) {
        CacheEntry<String> current = cache.get();
        
        // 캐시가 비어있거나 만료된 경우
        if (current == null || current.isExpired()) {
            String newValue = dataLoader.get();
            CacheEntry<String> newEntry = new CacheEntry<>(newValue, 5000); // 5초 TTL
            
            // CAS를 사용하여 원자적으로 업데이트
            if (cache.compareAndSet(current, newEntry)) {
                return newValue;
            } else {
                // 다른 스레드가 이미 업데이트한 경우, 업데이트된 값을 반환
                return cache.get().getValue();
            }
        }
        
        return current.getValue();
    }
    
    public static void main(String[] args) throws InterruptedException {
        AtomicCacheExample cache = new AtomicCacheExample();
        
        // 여러 스레드가 동시에 캐시에 접근
        Runnable task = () -> {
            String result = cache.getValue(() -> {
                System.out.println("데이터 로딩 중... (Thread: " + Thread.currentThread().getName() + ")");
                try {
                    Thread.sleep(100); // 데이터 로딩 시뮬레이션
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                return "Cached Data at " + System.currentTimeMillis();
            });
            System.out.println("결과: " + result + " (Thread: " + Thread.currentThread().getName() + ")");
        };
        
        // 동시에 5개 스레드 실행
        for (int i = 0; i < 5; i++) {
            new Thread(task).start();
        }
        
        Thread.sleep(1000);
    }
}

예제 3: 상태 머신 구현

import java.util.concurrent.atomic.AtomicReference;

public class StateMachineExample {
    public enum State {
        IDLE, RUNNING, PAUSED, STOPPED
    }
    
    private final AtomicReference<State> currentState = new AtomicReference<>(State.IDLE);
    
    public boolean start() {
        return currentState.compareAndSet(State.IDLE, State.RUNNING);
    }
    
    public boolean pause() {
        return currentState.compareAndSet(State.RUNNING, State.PAUSED);
    }
    
    public boolean resume() {
        return currentState.compareAndSet(State.PAUSED, State.RUNNING);
    }
    
    public boolean stop() {
        State current = currentState.get();
        return (current == State.RUNNING || current == State.PAUSED) && 
               currentState.compareAndSet(current, State.STOPPED);
    }
    
    public boolean reset() {
        return currentState.compareAndSet(State.STOPPED, State.IDLE);
    }
    
    public State getState() {
        return currentState.get();
    }
    
    public static void main(String[] args) {
        StateMachineExample machine = new StateMachineExample();
        
        System.out.println("초기 상태: " + machine.getState());
        
        if (machine.start()) {
            System.out.println("시작 성공: " + machine.getState());
        }
        
        if (machine.pause()) {
            System.out.println("일시정지 성공: " + machine.getState());
        }
        
        if (machine.resume()) {
            System.out.println("재개 성공: " + machine.getState());
        }
        
        if (machine.stop()) {
            System.out.println("정지 성공: " + machine.getState());
        }
        
        if (machine.reset()) {
            System.out.println("리셋 성공: " + machine.getState());
        }
        
        // 잘못된 상태 전환 시도
        if (!machine.pause()) {
            System.out.println("IDLE 상태에서 일시정지 불가능");
        }
    }
}

⚡ 성능 고려사항

👍 장점

• 락프리: 데드락 위험 없음
• 높은 성능: 경합이 적을 때 뛰어난 성능
• 원자성 보장: 스레드 안전한 연산

👎 단점

• ABA 문제: 값이 A→B→A로 변경될 때 감지 못함
• 스핀 대기: 경합이 클 때 CPU 사용량 증가
• 메모리 할당: 불변 객체 사용 시 GC 압박

🔍 베스트 프랙티스

1. 불변 객체 사용: 상태 변경 시 새 객체 생성
2. CAS 루프 최적화: 무한 루프 방지를 위한 백오프 전략
3. 적절한 사용: 단순한 참조 업데이트에만 사용
4. 성능 테스트: 실제 환경에서 성능 검증