섹션 11. 동시성 컬렉션

[YONGHYNG]

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

• java.util 패키지에 소속되어 있는 컬렉션 프레임워크는 원자적인 연산을 제공할까?
• 예를 들어서 하나의 ArrayList 인스턴스에 여러 스레드가 동시에 접근해도 괜찮을까?

참고로 여러 스레드가 동시에 접근해도 괜찮은 경우를 스레드 세이프(Thread Safe)하다고 한다.그렇다면 ArrayList 는 스레드 세이프 할까?

package thread.collection.simple;

import java.util.ArrayList;
import java.util.List;

public class SimpleListMainV0 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("A");
        list.add("B");
        System.out.println(list);
    }
}

실행 결과

[A, B]

여기서는 멀티스레드를 사용하지 않지만, 스레드1과 스레드2가 동시에 다음 코드를 실행한다고 가정

• 스레드1: list 에 A 를 추가한다.
• 스레드2: list 에 B 를 추가한다.

컬렉션에 데이터를 추가하는 add() 메서드를 생각해보면, 단순히 컬렉션에 데이터를 하나 추가하는 것뿐이다. 따라서 이것은 마치 연산이 하나만 있는 원자적인 연산처럼 느껴진다. 원자적인 연산은 쪼갤 수 없기 때문에 멀티스레드 상황에 문제가 되지 않는다.

물론 멀티스레드는 중간에 스레드의 실행 순서가 변경될 수 있으므로 [A, B] 또는, [B, A] 로 데이터의 저장 순서
는 변경될 수 있지만, 결과적으로 데이터는 모두 안전하게 저장될 것 같다. 하지만 컬렉션 프레임워크가 제공하는 대부분의 연산은 원자적인 연산이 아니다.

컬렉션 직접 만들기

package thread.collection.simple.list;

public interface SimpleList {
    int size();

    void add(Object e);

    Object get(int index);
}

• 직접 만들 컬렉션의 인터페이스이다.
• 크기 조회, 데이터 추가, 데이터 조회의 3가지 메서드만 가진다.

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

• 단일 스레드로 실행했기 떄문에 아직까지는 아무런 문제 없이 잘 작동한다.

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

멀티스레드 문제 확인

• add() - 원자적이지 않은 연산

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

이 메서드는 단순히 데이터 하나를 추가하는 기능을 제공한다. 따라서 밖에서 보면 원자적인 것처럼 보인다. 이 메서드는 단순히 데이터를 추가하는 것으로 끝나지 않는다. 내부에 있는 배열에 데이터를 추가해야 하고, size 도 함께 하나 증가시켜야 한다. 심지어 size++ 연산 자체도 원자적이지 않다. size++ 연산은 size = size + 1연산과 같다.

이렇게 원자적이지 않은 연산을 멀티스레드 상황에 안전하게 사용하려면 synchronized , Lock 등을 사용해서 동기화를 해야한다.

package thread.collection.simple.list;

import static util.MyLogger.log;

public class SimpleListMainV2 {

    public static void main(String[] args) throws InterruptedException {
        //test(new BasicList());
        //test(new SyncList());
        test(new SyncProxyList(new BasicList()));
    }

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

        // A를 리스트에 저장하는 코드
        Runnable addA = new Runnable() {
            @Override
            public void run() {
                list.add("A");
                log("Thread-1: list.add(A)");
            }
        };

        // B를 리스트에 저장하는 코드
        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);
    }
}

실행 결과

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

• 참고로 어떤 스레드가 먼저 실행되는가에 따라 [ A, null]이 결과로 나올 수도 있다.
• 실행 결과를 보면 size는 2인데, 데이터는 B 하나만 입력되어 있다. 어떻게 된 걸까?

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

과정 1

스레드1, 스레드2가 elementData[size] = e 코드를 동시에 수행한다. 여기서는 스레드1이 약간 빠르게 수행했다.

• 스레드1 수행: elementData[0] = A , elementData[0] 의 값은 A가 된다.
• 스레드2 수행: elementData[0] = B , elementData[0] 의 값은 A B가 된다.

결과적으로 elementData[0] 의 값은 B가 된다.

과정 2

• 스레드1, 스레드2가 sleep() 에서 잠시 대기한다. 여기서 sleep() 을 사용한 이유는 동시성 문제를 쉽게 확인하기
  위해서다.
• 이 코드를 제거하면 size++ 이 너무 빨리 호출되기 때문에, 스레드1이 add() 메서드를 완전히 수행하고 나서 스레
  드2가 add() 메서드를 수행할 가능성이 높다.
• 당연한 이야기지만 sleep() 코드를 제거해도 멀티스레드 동시성 문제는 여전히 발생할 수 있다. (확률의 차이이다.)
  예를 들어서 sleep() 코드를 제거해도 다음과 같은 상황이 발생할 수 있다.

과정 3

상황 1

스레드1, 스레드2가 size++ 코드를 동시에 수행한다. 여기서는 스레드1이 약간 빠르게 수행했다.

• 스레드1 수행: size++ , size 의 값은 1이 된다.
• 스레드2 수행: size++ , size 의 값은 1 2가 된다.

결과적으로 size 의 값은 2이 된다.

상황 2

스레드1, 스레드2가 size++ 코드를 동시에 수행한다. 여기서는 스레드1, 스레드2가 거의 동시에 실행되었다.

• 스레드1 수행: size = size + 1 연산이다. size 의 값을 읽는다. 0이다.

• 스레드2 수행: size = size + 1 연산이다. size 의 값을 읽는다. 0이다.

• 스레드1 수행: size = 0 + 1 연산을 수행한다.

• 스레드2 수행: size = 0 + 1 연산을 수행한다.

• 스레드1 수행: size = 1 대입을 수행한다.

• 스레드2 수행: size = 1 대입을 수행한다.

결과적으로 size 의 값은 1이 된다.

우리가 본 케이스는 상황1이지만, size++ 연산도 원자적인 연산이 아니므로 때때로 상황2가 될 수도 있다. (따라서 로그에서 size 값이 1로 출력될 가능성도 있다.)

컬렉션 프레임워크 대부분은 스레드 세이프 하지 않다.

우리가 일반적으로 자주 사용하는 ArrayList , LinkedList , HashSet , HashMap 등 수 많은 자료 구조들은 단순한 연산을 제공하는 것 처럼 보인다. 예를 들어서 데이터를 추가하는 add() 와 같은 연산은 마치 원자적인 연산처럼 느껴진다.

하지만 그 내부에서는 수 많은 연산들이 함께 사용된다. 배열에 데이터를 추가하고, 사이즈를 변경하고, 배열을 새로 만들어서 배열의 크기도 늘리고, 노드를 만들어서 링크에 연결하는 등 수 많은 복잡한 연산이 함께 사용된다. 따라서 일반적인 컬렉션들은 절대로! 스레드 세이프 하지 않다!

단일 스레드가 컬렉션에 접근하는 경우라면 아무런 문제가 없지만, 멀티스레드 상황에서 여러 스레드가 동시에 컬렉션에 접근하는 경우라면 java.util 패키지가 제공하는 일반적인 컬렉션들은 사용하면 안된다! (물론 일부 예외도 있
다. 뒤에서 설명한다.)

최악의 경우 실무에서 두 명의 사용자가 동시에 컬렉션에 데이터를 보관했는데, 코드에 아무런 문제가 없어 보이는데, 한명의 사용자 데이터가 사라질 수 있다.

그럼 어떻게 해야할까?