[JAVA] 동시성 컬렉션이 필요한 이유

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

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

아래 예제 코드를 보며 알아보겠습니다.

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

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

        // 스레드1, 스레드2가 동시에 실행 가정
        list.add("A"); // 스레드1 실행 가정
        list.add("B"); // 스레드2 실행 가정

        System.out.println(list);
    }
}

실행 결과

[A, B]

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

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

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

물론 멀티스레드는 중간에 스레드의 실행 순서가 변경될 수 있으므로 [A, B] 또는, [B, A]로 데이터의 저장 순서는 변경될 수 있지만, 결과적으로 데이터는 모두 안전하게 저장될 것 같습니다.

하지만 컬렉션 프레임워크가 제공하는 대부분의 연산은 원자적인 연산이 아닙니다.

컬렉션 직접 만들어보기

이 부분을 이해하기 위해 아주 간단한 컬렉션을 직접 만들어보겠습니다.

public interface SimpleList {
    int size();

    void add(Object e);

    Object get(int index);
}

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

import java.util.Arrays;

public class BasicList implements SimpleList {
    private static final int DEFAULT_CAPACITY = 5;
    private final Object[] elementData;
    private int size = 0;

    public BasicList() {
        elementData = new Object[DEFAULT_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;
    }
}

• 가장 간단한 컬렉션의 구현입니다. 내부에서는 배열을 사용해서 데이터를 보관합니다.
• ArrayList의 최소 구현 버전이라 생각하면 됩니다.
• DEFAULT_CAPACITY : 최대 5의 데이터를 저장할 수 있습니다.
• size : 저장한 데이터의 크기를 나타냅니다.
• add() : 컬렉션에 데이터를 추가합니다.
  • sleep(100) : 잠시 대기합니다. 이렇게 하면 멀티스레드 상황에 발생하는 문제를 확인하기 쉽습니다.

만든 컬렉션을 실행해보겠습니다.

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

단일 스레드로 실행했기 때문에 아직까지는 아무런 문제 없이 잘 작동하는 것을 보실 수 있습니다.

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

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

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());

        // 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);
    }

    private static void log(Object message) {
        System.out.println(message);
    }
}

실행 결과

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하나만 입력되어 있습니다. 이게 어떻게 된 것일까요?

과정 1

@Override
public void add(Object e) {
    elementData[size] = e; // 스레드1, 스레드2 동시에 실행
    sleep(100);
    size++;
}

스레드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

@Override
public void add(Object e) {
    elementData[size] = e; 
    sleep(100); // 스레드1, 스레드2 동시에 실행
    size++;
}

스레드1, 스레드2가 sleep()에서 잠시 대기합니다. 여기서 sleep()을 사용한 이유는 동시성 문제를 쉽게 확인하기 위해서입니다. 이 코드를 제거하면 size++이 너무 빨리 호출되기 때문에, 스레드1이 add() 메서드를 완전히 수행하고 나서 스레드2가 add() 메서드를 수행할 가능성이 높습니다.

과정3

@Override
public void add(Object e) {
    elementData[size] = e; 
    sleep(100);
    size++; // 스레드1, 스레드2 동시에 실행
}

여기서는 2가지 상황이 발생할 수 있습니다.

상황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 패키지가 제공하는 일반적인 컬렉션들은 사용하면 안됩니다.
최악의 경우 실무에서 두 명의 사용자가 동시에 컬렉션에 데이터를 보관했는데, 코드에 아무런 문제가 없어 보이는데, 한명의 사용자 데이터가 사라질 수 있습니다.

동시성 컬렉션이 필요한 이유2 - 동기화

컬렉션은 수 많은 복잡한 연산으로 이루어져 있습니다.
따라서 여러 스레드가 접근해야 한다면 synchronized, Lock 등을 통해 안전한 임계 영역을 적절히 만들면 문제를 해결할 수 있습니다.

import java.util.Arrays;

public class SyncList implements SimpleList {
    private static final int DEFAULT_CAPACITY = 5;
    private final Object[] elementData;
    private int size = 0;

    public SyncList() {
        elementData = new Object[DEFAULT_CAPACITY];
    }

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

    @Override
    public synchronized void add(Object e) {
        elementData[size] = e;
        sleep(100); // 멀티스레드 문제를 만드는 코드
        size++;
    }

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

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

    private void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

• 앞서 만든 BasicList 에 synchronized 키워드만 추가했습니다.
• 모든 메서드가 동기화 되어 있으므로 멀티스레드 상황에 안전하게 사용할 수 있습니다.

public class SimpleListMainV2 {
    public static void main(String[] args) throws InterruptedException {
        // test(new BasicList());
        test(new SyncList()); // 동기화 버전 테스트 시
    }

    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);
    }

    private static void log(Object message) {
        System.out.println(message);
    }
}

• BasicList를 사용하는 코드는 주석 처리한 뒤, SyncList를 사용하도록 코드를 추가합니다.

실행 결과

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

실행 결과를 보면 데이터가 [A,B], size=2로 정상 수행된 것을 확인 할 수 있습니다.
add() 메서드에 synchronized를 통해 안전한 임계 영역을 만들었기 때문에, 한 번에 하나의 스레드만 add()메서드를 수행합니다.

실행 순서
스레드1, 스레드2가 add()코드를 동시에 수행합니다. 여기서는 스레드1이 약간 빠르게 수행했습니다.

• 스레드1 수행: add("A")를 수행한다.

  • 락을 획득한다.
  • size 값은 0이다.
  • elementData[0]=A: elementData[0]의 값은 A가 된다.
  • size++을 호출해서 size는 1이 된다.
  • 락을 반납한다.

• 스레드2 수행: add("B")를 수행한다.

  • 스레드1이 가져간 락을 획득하기 위해 BLOCKED 상태로 대기한다.
  • 스레드 1이 락을 반납하면 락을 획득한다.
  • size 값은 1이다.
  • elementData[1]=B, elementData[1]의 값은 B가 된다. size++을 호출해서 size는 2가 된다.
  • 락을 반납한다.

동시성 문제는 해결되었지만, 이 코드의 문제라면 BasicList 코드를 거의 그대로 복사해서 synchronized기능만 추가한 SyncList를 만들었다는 점입니다.
이렇게 되면 모든 컬렉션을 다 복사해서 동기화 용으로 새로 구현해야 하는데, 이는 매우 비효율적입니다.

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

위와 같이 복사 + 붙여넣기 하는식으로 코드를 만들면 이후에 구현이 변경될 때마다 같은 모양의 코드를 2곳에서 변경해야 합니다. 기존 코드를 그대로 사용하면서 synchronized 기능만 살짝 추가하고 싶다면 어떻게 하면 좋을까요?

예를 들어서 BasicList는 그대로 사용하면서, 멀티스레드 상황에 동기화가 필요할 때만 synchronized 기능을 살짝 추가하고 싶다면 어떻게 하면 될까요?

이럴때 사용하는 것이 바로 프록시입니다.

프록시(Proxy)

프록시를 쉽게 풀어서 설명하자면 친구에게 대신 음식을 주문해달라고 부탁하는 상황을 생각해 볼 수 있습니다다.
예를 들어, 피자를 먹고 싶은데, 직접 전화하는 게 부담스러워서 친구에게 대신 전화해서 피자를 주문해달라고 부탁한다고 해보겠습니다. 친구가 피자 가게에 전화를 걸어 주문하고, 피자가 도착하면 저에게 가져다주는 것입니다. 여기서 친구가 바로 프록시 역할을 하는 것입니다.

• 나(클라이언트) -> 피자 가게(서버)
• 나(클라이언트) -> 친구(프록시) -> 피자 가게(서버)

객체 세상에도 이런 프록시를 만들 수 있습니다. 여기서는 프록시가 대신 동기화(synchronized) 기능을 처리해주는 것입니다.

아래에서 코드를 만들면서 확인해보겠습니다.

public class SyncProxyList implements SimpleList {
    private final SimpleList target;

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

    @Override
    public synchronized void add(Object e) {
        target.add(e);
    }

    @Override
    public synchronized Object get(int index) {
        return target.get(index);
    }

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

    @Override
    public synchronized String toString() {
        return target.toString() + " by " + this.getClass().getSimpleName();
    }
}

• 프록시 역할을 하는 클래스입니다.
• SyncProxyList는 BasicList와 같은 SimpleList 인터페이스를 구현합니다.
• 이 클래스는 생성자를 통해 SimpleList target을 주입 받습니다. 여기에 실제 호출되는 대상이 들어갑니다.
• 이 클래스는 마치 빈껍데기처럼 보입니다. 이 클래스의 역할은 모든 메서드에 synchronized를 걸어주는 일을 할뿐입니다. 그리고나서 target 에 있는 같은 기능을 호출합니다.
• 이 프록시 클래스는 synchronized만 걸고, 그 다음에 바로 실제 호출해야 하는 원본 대상(target)을 호출합니다.

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);
    }

    private static void log(Object message) {
        System.out.println(message);
    }
}

• SyncProxyList는 프록시입니다. 생성자에 실제 대상인 BasicList가 필요합니다.

기존에 BasicList 를 직접 사용하고 있었다면, 이제 중간에 프록시를 사용하므로 다음과 같은 구조로 변경됩니다.

• 기존 구조: 클라이언트 -> BasicList(서버)
• 변경 구조: 클라이언트 -> SyncProxyList(프록시) -> BasicList(서버)

실행 결과

10:39:58.693 [     main] SyncProxyList
10:39:58.800 [ Thread-1] Thread-1: list.add(A)
10:39:58.905 [ Thread-2] Thread-2: list.add(B)
10:39:58.905 [     main] [A, B] size=2, capacity=5 by SyncProxyList

실행 결과를 보면 [A, B] , size=2 로 synchronized 를 통한 동기화가 잘 이루어진 것을 확인할 수 있습니다. 프록시를 사용한 구조를 분석해보겠습니다.

프록시 구조 분석

• 그림과 같이 정적인 클래스의 의존 관계를 정적 의존 관계라 합니다.
• test() 메서드를 클라이언트라고 가정하겠습니다. test() 메서드는 SimpleList 라는 인터페이스에만 의존합니다. 이것을 추상화에 의존한다고 표현합니다.
• 덕분에 SimpleList 인터페이스의 구현체인 BasicList, SyncList, SyncProxyList 중에 어떤 것을 사용하든, 클라이언트인 test()의 코드는 전혀 변경하지 않아도 됩니다.
• 클라이언트인 test() 입장에서 생각해보면 BasicList가 넘어올지, SyncProxyList가 넘어올지 알 수 없습니다. 단순히 SimpleList의 구현체 중의 하나가 넘어와서 실행된다는 정도만 알 수 있습니다. 때문에 클라이언트인 test()는 매우 유연합니다. SimpleList의 어떤 구현체든지 다 받아들일 수 있습니다.

런타임 의존 관계 - BasicList
먼저 BasicList를 직접 사용하는 경우부터 알아보겠습니다.

그림과 같이 실제 런타임에 발생하는 인스턴스의 의존 관계를 런타임 의존 관계라 합니다.

• test(new BasicList())를 실행하면 BasicList(x001)의 인스턴스가 만들어지면서 test() 메서드에 전달됩니다.
• test()메서드는 BasicList(x001) 인스턴스의 참조를 알고 사용하게 됩니다.

BasicList - add() 호출 과정

• test() 메서드에서 스레드를 만들고, 스레드에 있는 run()에서 list.add()를 호출합니다.
• BasicList(x001) 인스턴스에 있는 add()가 호출됩니다.

런타임 의존 관계 - SyncProxyList
이번에는 BasicList 가 아니라 SyncProxyList 를 사용하는 예를 보겠습니다.

• BasicList(x001)의 참조를 SyncProxyList의 생성자에 전달하며 SyncProxyList(x002)가 만들어집니다.
• 내부에는 원본 대상을 가르키는 target 변수를 포함하고 있습니다. 이 변수는 BasicList(x001)의 참조를 보관합니다.
• test() 메서드는 SyncProxyList(x002) 인스턴스를 사용합니다.

SyncProxyList - add() 호출 과정

1. test() 메서드에서 스레드를 만들고, 스레드에 있는 run()에서 list.add()를 호출합니다.

   • SyncProxyList(x002)에 있는 add()가 호출됩니다.

2. 프록시인 SyncProxyList는 synchronized를 적용합니다. 그리고 나서 target에 있는 add()를 호출합니다.

3. 원본 대상인 BasicList(x001)의 add()가 호출됩니다.

4. 원본 대상의 호출이 끝나면 결과를 반환합니다.

5. SyncProxyList에 있는 add()로 흐름이 돌아옵니다. 메서드를 반환하면서 synchronized를 해제합니다.

6. test()로 흐름이 돌아옵니다.

여기서 중요한 핵심은 원본 코드인 BasicList를 전혀 손대지 않고, 프록시인 SyncProxyList를 통해 동기화 기능을 적용했다는 점입니다. 또한, 이후에 SimpleList를 구현한 BasicLinkedList 같은 연결 리스트를 만들더라도 서로 같은 인터페이스를 사용하기 때문에 SyncProxyList를 그대로 활용할 수 있습니다.

프록시 패턴

위에서 구현한 것이 바로 프록시 패턴입니다.

프록시 패턴(Proxy Pattern)은 객체지향 디자인 패턴 중 하나로, 어떤 객체에 대한 접근을 제어하기 위해 그 객체의 대리인 또는 인터페이스 역할을 하는 객체를 제공하는 패턴입니다. 프록시 객체는 실제 객체에 대한 참조를 유지하면서, 그 객체에 접근하거나 행동을 수행하기 전에 추가적인 처리를 할 수 있도록 합니다.

프록시 패턴의 주요 목적

• 접근 제어: 실제 객체에 대한 접근을 제한하거나 통제할 수 있습니다.
• 성능 향상: 실제 객체의 생성을 지연시키거나 캐싱하여 성능을 최적화할 수 있습니다.
• 부가 기능 제공: 실제 객체에 추가적인 기능(로깅, 인증, 동기화 등)을 투명하게 제공할 수 있습니다.