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

[YuDeokRin]

섹션 11. 동시성 컬렉션

1️⃣ 동시성 컬렉션이 필요한 이유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<>();
        
        // 스레드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]로 데이터의 저장 순서는 변경될 수 있지만, 결과적으로 데이터는 모두 안전하게 저장될 것 같다.

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

✅ 컬렉션 직접 만들기

package thread.collection.simple.list;

public interface SimpleList {
    int size();

    void add(Object e);

    Object get(int index);
}

• BasicList

package thread.collection.simple.list;

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];
    }
    
    @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) : 잠시 대기한다. 이렇게 하면 멀티스레드 상황에 발생하는 문제를 확인하기 쉽다.

• SimpleListMainV1

package thread.collection.simple;

import thread.collection.simple.list.BasicList;
import thread.collection.simple.list.SimpleList;

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️⃣ 동시성 컬렉션이 필요한 이유2 -동시성 문제

public void add(Object e) {
		elementData[size] = e;
		sleep(100); // 멀티스레드 문제를 쉽게 확인하는 코드
		size++;
}

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

package thread.collection.simple;

import thread.collection.simple.list.BasicList;
import thread.collection.simple.list.SimpleList;

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

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

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

✅ 과정 1

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

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

• 스레드1, 스레드2가 sleep() 에서 잠시 대기한다. 여기서 sleep() 을 사용한 이유는 동시성 문제를 쉽게 확인하기 위해서다.

• 이 코드를 제거하면 size++ 이 너무 빨리 호출되기 때문에, 스레드1이 add() 메서드를 완전히 수행하고 나서 스레드2가 add() 메서드를 수행할 가능성이 높다.

• 당연한 이야기지만 sleep() 코드를 제거해도 멀티스레드 동시성 문제는 여전히 발생할 수 있다. (확률의 차이이다.)

• 예를 들어서 sleep() 코드를 제거해도 다음과 같은 상황이 발생할 수 있다.

public void add(Object e) {
		elementData[size] = e;
		size++; // 스레드1, 스레드2 size++ 실행 전 대기
}

✅ 과정 3

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이 된다.

1. 상황

• 스레드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로 출력될 가능성도 있다.)