섹션 11. 동시성 컬렉션

[ljh468]

1. 동시성 컬렉션이 필요한 이유 - 시작

• 자바의 기본 컬렉션 프레임워크(java.util)는 대부분 스레드 세이프(Thread Safe)하지 않음
• 즉, 여러 스레드가 동시에 접근하여 데이터를 변경할 경우 데이터 유실이나 정합성 문제가 발생할 수 있음 (심각한 오류)

SimpleList 인터페이스와 구현체

동시성 테스트를 위한 리스트 구현

// 리스트의 기본 기능을 정의한 인터페이스
public interface SimpleList {
    int size();
    void add(Object e);
    Object get(int index);
}

// 가장 기본적인 리스트 구현체 (비동기화 상태)
public class BasicList implements SimpleList {
    
    private static final int DEFAULT_CAPACITY = 5;
    
    private Object[] elementData = new Object[DEFAULT_CAPACITY];
    
    private int size = 0;

    @Override
    public void add(Object e) {
        elementData[size] = e; // 1. 배열에 데이터 저장
        
        // 멀티스레드 문제를 의도적으로 발생시키기 위한 지연
        try {
            Thread.sleep(100);
        } catch (InterruptedException ex) { } 
        
        size++; // 2. 사이즈 증가
    }

    @Override
    public int size() { return size;}

    @Override
    public Object get(int index) { return elementData[index];

    @Override
    public String toString() {
        return Arrays.toString(Arrays.copyOf(elementData, size)) + 
               " size=" + size + ", capacity=" + elementData.length;
    }
}

---

2. 동시성 문제 분석 - 멀티스레드 테스트

2개의 스레드가 동시에 BasicList에 데이터를 추가할 때 어떤 결과가 발생하는지 확인

멀티스레드 실행 코드

public class SimpleListMainV2 {
    
    public static void main(String[] args) throws InterruptedException {
        test(new BasicList()); // 동시성 문제가 발생하는 리스트 전달
    }

    private static void test(SimpleList list) throws InterruptedException {
        
        log(list.getClass().getSimpleName());

        // 스레드 1: "A" 추가
        Runnable addA = () -> {
            list.add("A");
            log("Thread-1: list.add(A)");
        };

        // 스레드 2: "B" 추가
        Runnable addB = () -> {
            list.add("B");
            log("Thread-2: list.add(B)");
        };

        Thread thread1 = new Thread(addA, "Thread-1");
        Thread thread2 = new Thread(addB, "Thread-2");
        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
        log(list); // 최종 결과 출력
    }
}

실행 결과 및 문제점

• 결과

[ main] BasicList
[ Thread-1] Thread-1: list.add(A)
[ Thread-2] Thread-2: list.add(B)
[ main] [B, null] size=2, capacity=5

• 1,000번을 수행하면 1,000개의 데이터가 들어있어야 하지만, 실제로는 데이터가 유실되어 null이 포함되거나 사이즈가 맞지 않는 현상이 발생함
• 어떤 스레드가 먼저 실행되는가에 따라 [A, null] 이 결과로 나올 수도 있음

---

3. 원인 파악: add() 연산의 비원자성

add() 메서드는 겉으로 보기엔 단순하지만 내부적으로는 여러 단계로 나뉘어 실행

• 1단계: 데이터 덮어쓰기 (Data Overwrite)

• 스레드 1: size가 0인 것을 확인하고 elementData[0]에 "A"를 넣습니다.

• 스레드 2: 거의 동시에 size를 0으로 읽고 elementData[0]에 "B"를 넣습니다.

• 결과: 인덱스 0번에 저장되었던 "A"는 사라지고 "B"만 남게 됩니다. (Lost Update 발생)

---

• 2단계: 원자적이지 않은 size++ 연산

size++는 내부적으로 다음과 같은 과정을 거침

1. Read: 현재 size 값을 읽음.
2. Add: 읽은 값에 1을 더함.
3. Store: 더한 값을 다시 size 변수에 저장.

만약 두 스레드가 동시에 size를 0으로 읽었다면, 둘 다 1을 더해 저장하게 되어 최종 size가 2가 아닌 1이 될 수도 있게 됨

• 핵심 요약
• ArrayList, LinkedList, HashMap 등 우리가 자주 사용하는 컬렉션들은 절대로 스레드 세이프 하지 않음.
• 멀티스레드 환경에서 이들을 동기화 장치 없이 공유하면 데이터가 유실되는 치명적인 버그가 생기게 됨 (완전히 믿을 수 없는 시스템)

---

4. 동시성 컬렉션이 필요한 이유 3 - 동기화

컬렉션의 복잡한 연산을 멀티스레드 환경에서 안전하게 보호하기 위해 synchronized 키워드를 사용하여 **임계 영역(Critical Section)**을 설정할 수 있음

SyncList 구현 (동기화 적용)

public class SyncList implements SimpleList {

    private Object[] elementData = new Object[5];

    private int size = 0;

    // 모든 메서드에 synchronized를 추가하여 한 번에 하나의 스레드만 접근 허용
    @Override
    public synchronized void add(Object e) {
        elementData[size] = e;
        sleep(100); 
        size++;
    }

    @Override
    public synchronized int size() { return size; }

    @Override
    public synchronized Object get(int index) { return elementData[index]; }
}

• 실행 결과

[ main] SyncList
[ Thread-1] Thread-1: list.add(A)
[ Thread-2] Thread-2: list.add(B)
[ main] [A, B] size=2, capacity=5

• 원리
  • 스레드 1이 add()를 호출하여 **락(Lock)**을 획득하면, 스레드 2는 락이 반납될 때까지 BLOCKED 상태로 대기하여 데이터 유실을 방지함 .
  • 하지만, 모든 컬렉션 클래스(ArrayList, LinkedList 등)를 동기화용으로 새로 만드는 것은 매우 비효율적임.

---

5. 동시성 컬렉션이 필요한 이유 4 - 프록시 도입

기존 코드를 수정하지 않고 동기화 기능만 추가하고 싶을 때 프록시 패턴을 사용할 수 있음

프록시 패턴의 구조

• **나(클라이언트) → 친구(프록시) → 피자 가게(서버)**와 같이 중간에서 대신 처리해주는 구조임
  • 프록시는 실제 객체와 같은 인터페이스를 구현하며, 부가 기능(동기화)만 수행한 뒤 실제 로직은 원본 객체에 위임하는 것임

SyncProxyList 구현

public class SyncProxyList implements SimpleList {
    
   private SimpleList target; // 실제 BasicList 등의 원본 객체 (컴포지션)

    public SyncProxyList(SimpleList target) {
        this.target = target;
    }

    @Override
    public synchronized void add(Object e) {
        target.add(e); // 동기화 처리 후 원본 메서드 호출
    }

    @Override
    public synchronized int size() { return target.size(); }
}

• 장점
  • 원본 코드(BasicList)를 전혀 수정하지 않고도 동기화 기능을 적용할 수 있으며, 인터페이스만 같다면 어떤 리스트 구현체에도 재사용이 가능함

---

프록시 패턴이란?

객체에 대한 접근 제어하는 것이 핵심 목적

• 원래 객체에 대한 접근을 통제하거나, 원격 호출이나 지연 로딩(lazy loading)과 같은 추가 기능을 제공하기 위해 사용됨 (성능향상, 부가기능 추가)

• 주로 원래 객체와 동일한 인터페이스를 구현하여, 원래 객체와 동일하게 동작하도록 보장

• 주요 예시:

  • 가상 프록시 (Virtual Proxy): 실제 객체의 생성을 지연 (ex. 대규모 리소스 로드).
  • 보호 프록시 (Protection Proxy): 접근 권한을 제어.
  • 원격 프록시 (Remote Proxy): 네트워크를 통해 객체에 접근.

• 특징:

  • 클라이언트는 원래 객체가 아닌 프록시를 통해 간접적으로 작업을 수행.
  • 프록시는 원래 객체를 감싸면서 동작을 대체하거나 추가 동작을 삽입.

---

6. 자바 동시성 컬렉션 1 - synchronized 프록시

• 자바가 제공하는 java.util 패키지에 있는 컬렉션 프레임워크들은 대부분 스레드 안전(Thread Safe)하지 않음
• 자바는 java.util.Collections 클래스를 통해 기존 컬렉션을 스레드 세이프하게 감싸주는 프록시 생성 메서드들을 제공

동시성 컬렉션 메서드

• Collections.synchronizedList(new ArrayList<>())
• Collections.synchronizedMap(), Collections.synchronizedSet() 등

그러나, synchronized 프록시 방식은 단점이 존재

1. 동기화 오버헤드: 모든 메서드 호출 시마다 락을 걸기 때문에 성능 저하가 발생함.
2. 넓은 잠금 범위: 컬렉션 전체에 락을 걸어 잠금 경합(Lock Contention)이 증가하고 병렬 처리 효율이 떨어짐.
3. 최적화 부족: 단순 무식하게 모든 메서드에 synchronized를 걸기 때문에 상황에 따른 미세한 조정이 불가능함.

---

7. 자바 동시성 컬렉션 2 - 고성능 컬렉션

자바 1.5부터 java.util.concurrent 패키지에서 고성능 멀티스레드 환경을 위한 **동시성 컬렉션(Concurrent Collection)**을 제공

동시성 컬렉션의 특징

• synchronized 대신 Lock(ReentrantLock), CAS, 분할 잠금(Segment Lock) 등 정교한 기술을 사용하여 성능을 최적화함.

주요 클래스

일반 컬렉션 (Unsafe)	동시성 대안 (Safe)	특징
ArrayList	CopyOnWriteArrayList	쓰기 시 복사본을 만들어 처리, 읽기 성능 극대화
HashSet	CopyOnWriteArraySet	CopyOnWriteArrayList 기반의 Set
HashMap	ConcurrentHashMap	가장 널리 쓰이는 고성능 맵, 분할 잠금 사용
TreeSet/TreeMap	ConcurrentSkipListSet/Map	정렬 순서를 유지하는 동시성 컬렉션

블로킹 큐 (BlockingQueue)

생산자-소비자 패턴에서 사용되며, 큐가 가득 차거나 비었을 때 스레드를 대기시키는 기능을 제공

• ArrayBlockingQueue: 크기 고정.
• LinkedBlockingQueue: 크기 무한/고정 선택 가능.
• SynchronousQueue: 데이터를 저장하지 않고 직접 전달(Hand-off).

---

8.정리

1. 일반 컬렉션: 단일 스레드 전용. 멀티스레드에서 사용 시 데이터 유실 가능성 높음.
2. synchronized 프록시: 구현은 쉽지만 잠금 범위가 넓어 고부하 환경에는 부적합함.
3. 동시성 컬렉션: java.util.concurrent 사용 권장. 고성능 멀티스레드 최적화가 적용되어 있음.

---

• 대부분의 실무 애플리케이션에서는 충돌 가능성이 낮더라도 안전을 위해 단순 연산은 AtomicInteger를, 복합 데이터 구조는 ConcurrentHashMap 등을 우선적으로 고려하게됨