섹션 11. 동시성 컬렉션 (1)

[manijang2]

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

1. 코드

1) 인터페이스 정의

package thread.collection.simple.list;  
  
public interface SimpleList {  
    int size();  
    void add(Object e);  
    Object get(int index);  
}

• SimpleList는 “추가, 조회, 크기 확인” 등 단순한 기능을 제공한다.

package thread.collection.simple.list;  
  
import java.util.Arrays;  
  
import static util.ThreadUtils.sleep;  
  
public class BasicList implements SimpleList {  
  
    private static final int DEFAULT_CAPACITY = 5;  
  
    private Object[] elementData;  
    private int size = 0;  
  
    public BasicList() {  
        elementData = new Object[DEFAULT_CAPACITY];  
    }  
    public BasicList(int capacity) {}  
  
    @Override  
    public int size() {  
        return size;  
    }  
  
    @Override  
    public void add(Object e) {  
        elementData[size] = e;  
        sleep(100);  
        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;  
    }  
}

• add(Object e)는 현재 size 위치에 값을 넣고 잠깐 대기한 뒤 size를 증가시키는 방식으로 동작한다.
• 이 구현은 단일 스레드에서는 자연스럽게 동작해 보이지만, 멀티스레드에서 size와 elementData[size] 갱신이 원자적으로 보장되지 않기 때문에 쉽게 데이터 손상이 발생할 수 있는 구조이다.
• toString()은 Arrays.copyOf(elementData, size)를 통해 “현재 size만큼만” 잘라서 출력하기 때문에, 내부 배열의 남는 공간은 출력에서 제외된다.

package thread.collection.simple.list;  
  
public class SimpleListMainV1 {  
    public static void main(String[] args) {  
        SimpleList list = new BasicList();  
        list.add("A");  
        list.add("B");  
        System.out.println("list = " + list);  
    }  
}

list = [A, B], size = 2, capacity = 5

• 단일 스레드에서는 add()가 순차적으로 실행되므로 size가 예측 가능한 흐름으로 증가하고, 배열 인덱스도 충돌하지 않기 때문에 특별한 문제가 발생하지 않는다.
• sleep()을 넣었음에도 단일 스레드에서는 경합이 없으므로 결과가 안정적으로 유지된다.

---

동시성 컬렉션이 필요한 이유2 - 동시성 문제

1. 코드

package thread.collection.simple.list;  
  
import static util.MyLogger.log;  
  
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());  
  
        Runnable addA = new Runnable() {  
            @Override  
            public void run() {  
                list.add("A");  
                log("Thread-1: list.add(A)");  
            }  
        };  
  
        Runnable addB = new Runnable() {  
            @Override  
            public void run() {  
                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);  
    }  
}

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

• size는 2이지만, 실제로는 "B"만 남고 "A"가 사라진 것처럼 보이는 현상이 발생한다.
• 출력이 [B, null]로 나온 이유는 내부 배열의 0번 인덱스에 "B"가 남아 있고, 1번 인덱스에는 아무 값도 들어가지 않았는데도 size가 2로 증가했기 때문이다.

2. 분석

• BasicList.add()는 “배열에 저장”과 “size 증가”가 분리되어 있으며, 이 두 연산이 원자적으로 보장되지 않는다.
• 또한, size++연산도 원자적이지 않다.
• 그 결과 멀티스레드 환경에서는 두 스레드가 같은 size 값을 기준으로 같은 위치에 쓰거나, size++가 꼬이면서 배열 상태와 size 값이 불일치할 수 있다.

@Override  
    public void add(Object e) {  
        elementData[size] = e;  
        sleep(100);  
        size++;  
    }  

1) 데이터가 덮어씌워지는 흐름이 발생한다

• 두 스레드가 거의 동시에 elementData[size] = e를 실행하면, 두 스레드 모두 같은 시점의 size 값을 읽을 수 있다.
• 두 스레드가 모두 size가 0일때 읽으면, 둘 다 elementData[0]에 값을 쓰게 된다.
• 이때 마지막으로 실행된 스레드의 값이 elementData[0]에 남기 때문에, "A" 또는 "B" 중 하나가 덮어씌워져 사라진 것처럼 보이는 현상이 발생한다.

2) sleep()는 문제를 “만드는 것”이 아니라 “잘 드러내는 것”이다

• sleep(100)은 멀티스레드 충돌을 더 자주 재현하기 위한 장치로 동작한다.
• sleep()이 없으면 운 좋게 스케줄링이 순차적으로 일어나서 문제가 안 보일 수도 있지만, 이는 코드가 안전해진 것이 아니라 단지 충돌 타이밍이 덜 겹친 것뿐이다.
• 따라서 sleep()은 레이스 컨디션을 확대해서 관찰하기 쉽게 만드는 역할을 한다.

3) size는 1보다는 2가 될 수 있다

• 현재 코드 구조에서는 오히려 size가 2로 끝날 가능성이 매우 높다.
• 이유는 두 스레드 모두 sleep(100) 이후에 size++를 실행하기 때문에, 실제로는 size++가 충돌 없이 “두 번” 수행되는 경우가 많기 때문이다.
• 지금 출력이 [B, null], size = 2로 나온 흐름은 다음처럼 설명할 수 있다.

3. 정리

• 컬렉션 프레임워크 대부분은 기본 구현만으로는 스레드에 대하여 안전하지 않으며, 동시 접근 시 별도의 동기화 전략이 필요하다.
• 컬렉션의 추가 작업은 단순히 값을 넣는 행위로 끝나지 않고, 인덱스 계산, 배열 쓰기, 크기 증가처럼 여러 단계의 연산이 묶여 동작하는 경우가 많다.
• 이런 구조에서 동기화 없이 여러 스레드가 동시에 접근하면, 데이터가 추가되었는데도 사라지거나(덮어쓰기), size만 증가하고 실제 데이터가 비어 있는(불일치) 현상이 발생한다.
• 특히 데이터가 “누락”되는 문제는 예외가 터지지 않고 조용히 발생할 수 있으며, 로그가 남지 않거나 겉으로 정상 동작처럼 보여서 실제 서비스에서는 더 치명적인 장애로 이어질 수 있다.