이펙티브 자바 완벽 공략 2부

아이템 32. 제네릭과 가변인수를 함께 쓸 때는 신중하라

아이템 32. 제네릭과 가변인수를 함께 쓸 때는 신중하라


아이템 32. 핵심 정리

아이템 32. 제네릭과 가변인수를 함께 쓸 때는 신중하라

Java의 가변인자(Varargs)는 메서드를 호출하는 쪽에서 전달할 인자의 개수를 자유롭게 정할 수 있도록 해준다.

다음과 같이 ... 문법을 사용한다.

public static void print(
        String... values
) {
    for (String value : values) {
        System.out.println(value);
    }
}

호출하는 쪽에서는 원하는 개수만큼 인자를 넘길 수 있다.

print("A");

print("A", "B");

print("A", "B", "C");

문법만 보면 단순하고 편리하다.

문제는 여기에 제네릭 타입이 결합할 때 발생한다.

public static void method(
        List<String>... lists
) {
    // ...
}

이 코드는 컴파일 자체는 가능하다.

하지만 컴파일러는 다음과 비슷한 경고를 발생시킬 수 있다.

Possible heap pollution from parameterized vararg type

정확한 용어는 Heap Pollution이다.

왜 단순히 List<String>...라고 선언했을 뿐인데 이런 경고가 발생하는 것일까?

이를 이해하려면 가변인자가 내부적으로 어떻게 동작하는지부터 다시 살펴봐야 한다.


가변인자는 내부적으로 배열을 사용한다

다음 메서드를 보자.

public static void print(
        String... values
) {
    System.out.println(values.length);
}

메서드 내부에서 values는 사실상 배열처럼 사용된다.

String[]

호출하는 쪽에서

print(
        "A",
        "B",
        "C"
);

라고 작성하면 개념적으로는 다음과 비슷한 배열이 만들어져 전달된다.

String[]

[
    "A",
    "B",
    "C"
]

즉 가변인자 문법은 사용하기 편하도록 감싼 문법이고, 실제 메서드 내부에서는 배열을 사용한다.

여기까지는 큰 문제가 없다.

문제는 다음과 같은 코드다.

public static void method(
        List<String>... lists
) {
}

이 경우 가변인자 배열의 요소 타입이 List<String>이라는 매개변수화 타입이 된다.

바로 여기서 제네릭과 배열의 충돌이 다시 등장한다.


배열과 제네릭은 타입 시스템의 성격이 다르다

아이템 28에서 배열과 제네릭에는 중요한 차이가 있다고 살펴봤다.

배열은 공변이다.

String[] strings = new String[10];

Object[] objects = strings;

String[]을 Object[]로 사용할 수 있다.

반면 제네릭은 기본적으로 불공변이다.

List<String> strings =
        new ArrayList<>();

List<Object> objects =
        strings;

이 코드는 컴파일되지 않는다.

그리고 또 하나의 중요한 차이가 있다.

배열은 런타임에 자신의 원소 타입을 알고 있는 실체화 타입이다.

String[]

이라면 JVM은 해당 배열이 String을 담는 배열이라는 사실을 런타임에도 알고 있다.

반면

List<String>

의 String 같은 제네릭 타입 인수는 런타임에 그대로 실체화되는 방식이 아니다.

Java 제네릭은 타입 소거를 중심으로 구현되기 때문이다.


그래서 제네릭 배열 생성을 금지한다

다음 코드는 작성할 수 없다.

List<String>[] lists =
        new List<String>[10];

컴파일러가 막는다.

generic array creation

이라는 컴파일 오류가 발생한다.

왜일까?

배열은 런타임에 자신의 원소 타입을 검사해야 한다.

하지만 List<String>의 String 타입 인수는 런타임에 완전히 실체화되지 않는다.

결국 JVM이

List<String>

과

List<Integer>

를 배열 저장 검사에서 완벽하게 구별할 수 없기 때문에 타입 안전성을 보장하기 어려워진다.

그래서 Java에서는 이런 배열 생성을 아예 막는다.


그런데 제네릭 가변인자는 허용된다

이상한 점이 하나 생긴다.

다음은 불가능하다.

new List<String>[10];

그런데 다음은 가능하다.

static void method(
        List<String>... lists
) {
}

가변인자는 내부적으로 배열을 사용한다.

따라서 제네릭 가변인자를 사용하면 언어 차원에서 결국 제네릭 타입과 배열이 만나는 상황이 생긴다.

Java는 이 문법을 완전히 금지하지는 않았다.

대신 컴파일러가 경고한다.

Possible heap pollution
from parameterized vararg type

즉

이 코드는 사용할 수 있지만 타입 안전성이 깨질 가능성이 있으니 주의하라.

는 의미다.


Heap Pollution이란?

Heap Pollution은 단순히 Heap 메모리가 물리적으로 손상된다는 뜻이 아니다.

제네릭 문맥에서는 다음과 같은 상황을 의미한다.

매개변수화 타입이 기대하는 타입과 실제 객체의 타입 관계가 깨진 상태

예를 들어 원래

List<String>

이 들어 있다고 믿고 있는 위치에 실제로는

List<Integer>

가 들어가 있다면 타입 시스템이 기대하는 상태와 실제 객체 상태가 달라진다.

이런 상황이 Heap Pollution이다.


실제 Heap Pollution을 만들어보자

다음 메서드를 보자.

static void dangerous(
        List<String>... stringLists
) {

    Object[] objects =
            stringLists;

    objects[0] =
            List.of(42);

    String value =
            stringLists[0]
                    .get(0);
}

하나씩 살펴보자.

먼저

List<String>... stringLists

는 메서드 내부에서 배열 형태로 다뤄진다.

그리고 배열은 공변이므로 다음이 가능하다.

Object[] objects =
        stringLists;

이제 objects의 컴파일타임 타입은 Object[]이다.

따라서 다음 코드도 문법적으로 가능하다.

objects[0] =
        List.of(42);

List<Integer>도 결국 하나의 객체이므로 Object[]에 저장할 수 있다.

그런데 원래 stringLists를 사용하는 코드는 해당 위치에

List<String>

이 있다고 믿고 있다.

실제로는

List<String>[]이라고 기대

        ↓

Object[] 참조로 우회

        ↓

List<Integer> 삽입

        ↓

타입 계약 붕괴

가 된 것이다.

이것이 Heap Pollution이다.


문제는 값을 꺼낼 때 드러난다

다음 코드를 실행한다고 해보자.

String value =
        stringLists[0]
                .get(0);

컴파일러 입장에서는 stringLists[0]의 타입이

List<String>

이다.

따라서 get(0)의 결과 역시 String이라고 생각한다.

하지만 실제 객체는 앞에서 넣은

List.of(42)

다.

따라서 실제 반환값은 Integer다.

제네릭의 타입 소거 때문에 컴파일러는 필요한 위치에 형변환 코드를 추가한다.

개념적으로는 다음과 비슷하다.

Object 반환

↓

String으로 cast

↓

실제 객체는 Integer

↓

ClassCastException

결국 제네릭을 사용했음에도 런타임에 타입 안전성이 깨졌다.


배열이 왜 List 삽입을 막지 못했을까?

다음 코드는 즉시 실패한다.

Object[] objects =
        new String[1];

objects[0] =
        Integer.valueOf(10);

실제 배열 객체가 String[]이라는 것을 JVM이 알고 있기 때문이다.

따라서 Integer를 넣으려고 하는 순간

ArrayStoreException

이 발생한다.

하지만 제네릭 가변인자의 경우 배열의 런타임 요소 타입은 타입 소거의 영향을 받는다.

List<String>과 List<Integer>의 String, Integer까지 배열의 런타임 저장 검사가 구별하지 못한다.

둘 다 런타임에서는 List 계열 객체다.

그래서 배열 저장 검사에서는 문제가 드러나지 않고, 이후 값을 꺼내 제네릭 타입에 맞게 사용할 때 문제가 드러날 수 있다.


그래서 제네릭 가변인자는 기본적으로 위험하다

핵심 구조를 정리하면 다음과 같다.

Generic Varargs

List<String>...

↓

가변인자는 배열 사용

↓

제네릭 타입 + 배열 결합

↓

타입 소거 때문에
런타임 원소 타입을 완전히 검사하기 어려움

↓

Heap Pollution 가능

↓

ClassCastException 가능

그래서 가능하면 제네릭 타입과 가변인자를 무심코 함께 사용하지 않는 것이 좋다.

하지만 실제 Java API를 보면 제네릭 가변인자를 사용하는 코드가 존재한다.

왜냐하면 특정 조건을 만족하면 안전하게 사용할 수 있기 때문이다.


언제 제네릭 가변인자가 안전할까?

가장 중요한 기준은 두 가지다.

첫 번째는 가변인자 배열에 타입 안전성을 깨뜨리는 값을 저장하지 않는 것이다.

두 번째는 가변인자 배열의 참조가 메서드 밖으로 탈출하지 않도록 하는 것이다.

이 두 조건을 중심으로 생각하면 된다.


첫 번째 원칙: 배열을 변조하지 않는다

다음처럼 가변인자로 받은 값을 읽기만 한다고 해보자.

static <T> void printAll(
        T... values
) {

    for (T value : values) {
        System.out.println(value);
    }
}

메서드 안에서는 배열을 순회하면서 원소를 읽기만 한다.

values

↓

읽기

↓

출력

다른 타입의 객체를 배열에 집어넣지 않는다.

이런 코드는 타입 안전성을 깨뜨릴 가능성이 낮다.


위험한 형태는 배열을 우회해서 변경하는 것이다

반면 다음 코드는 위험하다.

static void dangerous(
        List<String>... lists
) {

    Object[] objects =
            lists;

    objects[0] =
            List.of(100);
}

Object[]로 우회한 뒤 원래 제네릭 계약과 다른 값을 삽입했다.

이런 메서드에는 절대로

@SafeVarargs

를 붙여서 문제를 숨기면 안 된다.

먼저 구현 자체를 수정해야 한다.


두 번째 원칙: 배열 참조를 외부로 노출하지 않는다

가변인자 배열에 직접 값을 저장하지 않는다고 무조건 안전한 것은 아니다.

다음 코드도 문제가 될 수 있다.

static <T> T[] toArray(
        T... args
) {
    return args;
}

메서드 내부에서는 배열을 수정하지 않는다.

그냥 반환할 뿐이다.

하지만 문제는 가변인자를 위해 만들어진 배열 참조가 메서드 밖으로 빠져나갔다는 것이다.

varargs 배열 생성

↓

메서드 내부

↓

그 배열 자체를 return

↓

외부 코드가 배열 참조 획득

이제 타입 안전성을 메서드 내부에서만 통제할 수 없게 된다.


배열 참조의 탈출이 왜 위험할까?

가변인자 배열은 호출 문맥과 타입 소거가 얽히면서 실제 런타임 배열 타입과 클라이언트가 기대하는 타입이 달라질 수 있다.

대표적인 예가 다음과 같은 메서드다.

static <T> T[] toArray(
        T... args
) {
    return args;
}

이를 이용해 다음과 같은 메서드를 만든다.

static <T> T[] pickTwo(
        T a,
        T b,
        T c
) {
    switch (
            ThreadLocalRandom
                    .current()
                    .nextInt(3)
    ) {
        case 0:
            return toArray(a, b);

        case 1:
            return toArray(a, c);

        case 2:
            return toArray(b, c);
    }

    throw new AssertionError();
}

겉으로 보면 문제가 없어 보인다.

T 세 개를 받고 그중 두 개를 T[]로 반환한다.

하지만 이 코드는 런타임에 실패할 수 있다.


pickTwo의 위험을 단계적으로 살펴보자

클라이언트가 다음과 같이 호출한다고 해보자.

String[] values =
        pickTwo(
                "A",
                "B",
                "C"
        );

클라이언트의 기대는 명확하다.

String[]

반환

그런데 pickTwo() 내부에서 호출되는

toArray(a, b)

를 생각해보자.

toArray()는 가변인자 메서드다.

static <T> T[] toArray(
        T... args
)

컴파일러는 호출 지점에서 가변인자 배열을 만들어야 한다.

하지만 pickTwo() 내부의 T는 타입 소거의 영향을 받는다.

상위 경계가 없다면 T의 소거 타입은 Object다.

따라서 실제 가변인자 배열이 Object[] 형태로 만들어질 수 있다.

그리고 그것을 그대로 반환한다.

Object[]

↓

pickTwo() 밖으로 반환

클라이언트는 String[]을 기대한다

호출 코드는 다음과 같다.

String[] values =
        pickTwo(
                "A",
                "B",
                "C"
        );

컴파일러는 이 결과를 String[]으로 사용해야 한다는 것을 알고 있다.

그래서 필요한 런타임 형변환을 추가할 수 있다.

실제 반환 객체

Object[]

↓

String[]으로 cast 시도

↓

ClassCastException

Object[] 객체는 단순히 형변환한다고 해서 String[] 객체가 되지 않는다.

배열은 런타임 타입을 기억하기 때문이다.


이것이 배열 참조를 외부로 노출하면 위험한 이유다

문제의 핵심은 toArray()가 가변인자 배열을 그대로 반환했다는 것이다.

return args;

가변인자로 만들어진 내부 배열이 API 경계를 넘어갔다.

그 순간 호출자 쪽에서 기대하는 타입과 실제 배열의 런타임 타입 사이에 불일치가 생길 수 있다.

그래서 제네릭 가변인자를 사용할 때는 다음을 강하게 경계해야 한다.

varargs 배열을 return

varargs 배열을 필드에 저장

varargs 배열을 외부 객체에 전달

varargs 배열 참조를
외부 코드가 보관할 수 있게 함

이런 상황을 흔히 배열 참조가 탈출한다(escape) 고 표현할 수 있다.


안전한 예제: flatten

이번에는 안전하게 사용할 수 있는 예제를 살펴보자.

여러 List를 받아 하나의 List로 합치는 메서드다.

@SafeVarargs
static <T> List<T> flatten(
        List<? extends T>... lists
) {

    List<T> result =
            new ArrayList<>();

    for (List<? extends T> list :
            lists) {

        result.addAll(list);
    }

    return result;
}

lists는 제네릭 가변인자이므로 기본적으로 경고의 대상이 될 수 있다.

하지만 내부 구현을 살펴보면 다르다.


flatten은 가변인자 배열을 읽기만 한다

코드를 보면

for (List<? extends T> list :
        lists)

가변인자 배열에서 값을 가져온다.

그리고 가져온 List 안의 원소를 새로운 결과 리스트에 옮긴다.

result.addAll(list);

데이터 흐름은 다음과 같다.

varargs 배열

↓

List 하나씩 읽음

↓

List의 원소 읽음

↓

새로운 ArrayList<T>에 저장

가변인자 배열 자체를 변조하지 않는다.


배열 자체도 외부로 반환하지 않는다

반환하는 것은

return result;

이다.

여기서 result는 새롭게 생성한

ArrayList<T>

이다.

가변인자 배열인

lists

를 반환하는 것이 아니다.

즉

가변인자 배열

→ 메서드 내부에서만 사용

→ 외부로 노출되지 않음

이라는 조건을 만족한다.

따라서 해당 구현이 타입 안전하다는 것을 개발자가 검증했다면 @SafeVarargs를 적용할 수 있다.


@SafeVarargs는 무엇을 의미할까?

다음과 같이 사용한다.

@SafeVarargs
static <T> List<T> flatten(
        List<? extends T>... lists
) {
    // ...
}

이 애너테이션은

이 메서드의 제네릭 가변인자 사용은 타입 안전하다.

라고 개발자가 선언하는 것이다.

중요한 점은 애너테이션이 코드를 안전하게 만들어주는 것이 아니라는 것이다.

코드가 먼저 안전해야 한다.

그다음 컴파일러에게

이 경고는 내가 검토했고
이 구현에서는 문제가 없다.

라고 알려주는 것이다.


@SafeVarargs를 무작정 붙이면 안 된다

다음 메서드를 생각해보자.

@SafeVarargs
static void dangerous(
        List<String>... lists
) {

    Object[] array =
            lists;

    array[0] =
            List.of(42);
}

애너테이션을 붙였다고 타입 오염이 사라지는 것은 아니다.

여전히 Heap Pollution이 발생한다.

@SafeVarargs

↓

경고는 줄어듦

하지만

↓

타입 안전성은 그대로 깨져 있음

즉 @SafeVarargs는 안전성 보장 장치가 아니라 개발자의 안전성 주장이다.

잘못 사용하면 오히려 컴파일러의 중요한 경고를 숨기게 된다.


@SafeVarargs와 @SuppressWarnings의 차이

아이템 27에서는 다음 애너테이션을 살펴봤다.

@SuppressWarnings("unchecked")

이것도 경고를 억제한다.

하지만 의미와 범위가 다르다.

예를 들어 메서드 전체에

@SuppressWarnings("unchecked")

를 붙이면 해당 범위에서 발생하는 여러 unchecked 경고까지 함께 숨길 수 있다.

개발자가 원했던 것은 제네릭 가변인자와 관련된 경고 하나였는데, 나중에 다른 비검사 연산이 추가되더라도 발견하지 못할 수 있다.

반면 @SafeVarargs는 바로 제네릭 가변인자 사용의 안전성을 선언하기 위해 만들어진 애너테이션이다.

따라서 실제로 안전한 제네릭 가변인자 메서드라면 의도가 더 분명하다.


두 애너테이션을 비교하면

구분@SuppressWarnings("unchecked")@SafeVarargs
주된 목적unchecked 경고 억제제네릭 가변인자 사용의 안전성 선언
범위적용 위치의 unchecked 경고varargs 관련 타입 안전성 경고
실제 안전성을 만들어줌XX
개발자의 검증 필요OO
제네릭 varargs에 대한 의도 표현상대적으로 약함명확함

중요한 원칙은 동일하다.

경고를 없애기 위해 애너테이션을 붙이는 것이 아니라, 코드가 안전하다는 것을 증명한 뒤 경고를 억제해야 한다.


@SafeVarargs를 붙여도 되는 기준

제네릭 가변인자 메서드가 있다면 우선 다음 두 가지를 확인한다.

가변인자 배열에 값을 저장하는가?

예를 들어

Object[] array =
        args;

array[0] =
        something;

처럼 타입 안전성을 깨뜨릴 수 있는 값을 저장한다면 안전하지 않다.


가변인자 배열의 참조가 밖으로 빠져나가는가?

다음과 같은 코드도 위험하다.

return args;

또는

this.args = args;

외부 코드가 가변인자 배열 참조를 보관하거나 변경할 수 있다면 메서드 하나만 보고 타입 안전성을 보장하기 어려워진다.

따라서 아주 실용적으로 기억하면 다음과 같다.

제네릭 varargs 배열을

1. 변조하지 않고

2. 외부에 노출하지 않는다.

이 두 조건이 매우 중요하다.


단순히 읽기만 한다면 안전성을 판단하기 쉽다

예를 들어 다음 메서드는 비교적 분석하기 쉽다.

@SafeVarargs
static <T> void printAll(
        T... values
) {

    for (T value : values) {
        System.out.println(value);
    }
}

가변인자 배열의 원소를 읽어서 사용하는 것뿐이다.

values

↓

read

↓

print

배열에 다른 객체를 넣지 않는다.

배열 참조를 반환하지도 않는다.

이런 형태가 @SafeVarargs를 적용하기 좋은 전형적인 예다.


그렇다고 배열을 다른 메서드에 절대 전달하면 안 되는 것은 아니다

엄밀히 말하면 가변인자 배열 참조를 다른 코드에 전달한다고 해서 무조건 타입 안전성이 깨지는 것은 아니다.

전달받은 메서드가 배열을 안전하게 사용한다는 것을 확실히 보장할 수 있다면 안전할 수도 있다.

예를 들어 내부적으로만 사용하는 안전한 메서드에 전달하고, 그 메서드 역시 배열을 변조하거나 외부에 노출하지 않는다면 문제가 없을 수 있다.

하지만 API 설계 관점에서는 이런 안전성 조건이 여러 메서드에 걸쳐 퍼질수록 분석하기 어려워진다.

그래서 일반적인 원칙으로는

제네릭 가변인자 배열의 참조를 불필요하게 외부로 노출하거나 전달하지 않는다.

라고 기억하는 편이 안전하다.


가장 좋은 해결책은 배열 자체를 피하는 것일 수 있다

지금까지는

제네릭 가변인자를 꼭 사용해야 한다.

는 상황을 가정했다.

하지만 더 근본적인 질문이 있다.

정말 제네릭 가변인자를
사용해야 하는가?

아이템 28에서 살펴봤듯 제네릭과 배열은 타입 시스템 특성상 잘 어울리지 않는다.

그래서 가능한 경우 배열 대신 List를 사용하면 문제 자체를 줄일 수 있다.


pickTwo를 List로 바꿔보자

앞에서 위험했던 메서드는 다음과 비슷했다.

static <T> T[] pickTwo(
        T a,
        T b,
        T c
) {
    // ...
}

결과로 제네릭 배열을 반환하는 구조다.

이를 List 기반으로 바꿀 수 있다.

static <T> List<T> pickTwo(
        T a,
        T b,
        T c
) {

    switch (
            ThreadLocalRandom
                    .current()
                    .nextInt(3)
    ) {
        case 0:
            return List.of(a, b);

        case 1:
            return List.of(a, c);

        case 2:
            return List.of(b, c);
    }

    throw new AssertionError();
}

이제 반환 타입은

List<T>

다.


클라이언트도 타입 안전하게 사용할 수 있다

다음처럼 사용한다.

List<String> values =
        pickTwo(
                "A",
                "B",
                "C"
        );

가변인자를 위한 내부 배열을 반환하는 과정도 없다.

Object[] → String[] 같은 런타임 캐스팅 문제도 없다.

T 값들

↓

List<T>

↓

클라이언트

↓

List<String>

타입 관계를 제네릭 컬렉션 안에서 유지할 수 있다.


flatten 역시 List 기반으로 바꿀 수 있다

가변인자 방식은 다음과 같다.

@SafeVarargs
static <T> List<T> flatten(
        List<? extends T>... lists
) {
    // ...
}

안전하게 구현할 수는 있지만 여전히

@SafeVarargs

라는 추가적인 안전성 선언이 필요하다.

이를 처음부터 List 기반으로 만들 수도 있다.

static <T> List<T> flatten(
        List<? extends List<? extends T>> lists
) {

    List<T> result =
            new ArrayList<>();

    for (List<? extends T> list :
            lists) {

        result.addAll(list);
    }

    return result;
}

조금 복잡해 보이지만 타입 구조를 하나씩 보면 의미가 명확하다.


바깥 List도 Producer다

다음 타입을 보자.

List<? extends List<? extends T>>

바깥쪽 List에서 내부 List를 가져온다.

따라서 바깥쪽도 Producer다.

바깥 List

↓

내부 List를 공급

↓

Producer

그래서

? extends

를 사용한다.


안쪽 List 역시 Producer다

내부의

List<? extends T>

역시 T 계열 원소를 공급한다.

예를 들어 T가 Number라면

List<Integer>
List<Double>
List<Long>

등을 받을 수 있다.

따라서 다음 같은 구조도 가능해진다.

List<Integer> ─┐
               │
List<Double> ──┼→ flatten
               │
List<Long> ────┘
               ↓
          List<Number>

아이템 31에서 살펴본 PECS 원칙이 그대로 적용된다.


List 기반 API의 장점

List 기반으로 변경하면 몇 가지 문제가 자연스럽게 사라진다.

첫 번째로 제네릭 배열 자체를 다루지 않는다.

Generic Array

X

두 번째로 Heap Pollution 가능성이 크게 줄어든다.

세 번째로

@SafeVarargs

를 붙이고 그 안전성을 사람이 직접 증명해야 하는 부담도 사라질 수 있다.

그리고 무엇보다 타입 관계를 제네릭 컬렉션으로 컴파일러가 추적할 수 있다.


대신 호출 문법은 조금 달라질 수 있다

가변인자의 장점은 호출이 편하다는 것이다.

flatten(
        list1,
        list2,
        list3
);

List 기반 API라면 다음처럼 작성할 수 있다.

flatten(
        List.of(
                list1,
                list2,
                list3
        )
);

호출하는 코드가 약간 더 길어진다.

즉 선택에는 트레이드오프가 있다.

Varargs

장점
→ 호출이 편함

단점
→ 제네릭과 결합하면 안전성 검토 필요

반면

List

장점
→ 타입 안전성 관리가 상대적으로 쉬움

단점
→ 호출 코드가 조금 장황할 수 있음

이다.


그래서 무조건 varargs를 금지하라는 의미는 아니다

아이템 32의 제목은

제네릭과 가변인수를 함께 쓰지 말라.

가 아니다.

신중하게 사용하라다.

즉 다음과 같은 경우라면 충분한 검토 후 사용할 수 있다.

제네릭 varargs가 API 사용성에
실질적인 장점이 있다.

+

varargs 배열을 변조하지 않는다.

+

배열 참조를 외부에 노출하지 않는다.

+

타입 안전성을 확실하게 증명할 수 있다.

이런 경우라면

@SafeVarargs

를 통해 의도를 표현할 수 있다.


반대로 List가 자연스럽다면 List를 우선 검토한다

다음과 같은 상황이라면 굳이 제네릭 가변인자를 고집할 이유가 없다.

단순히 여러 값을 전달하고 싶다.

↓

이미 Collection으로 표현하기 자연스럽다.

↓

성능이나 호출 편의성 때문에
varargs가 꼭 필요한 것도 아니다.

그렇다면

List<T>

나

Collection<T>

을 사용하는 것이 더 단순하고 안전할 수 있다.

아이템 28과 아이템 32가 결국 같은 방향을 가리키는 이유다.


아이템 28과 아이템 32의 연결

아이템 28에서는

배열보다는 리스트를 사용하라.

고 했다.

주된 이유 중 하나가 배열과 제네릭의 타입 체계가 잘 맞지 않기 때문이다.

아이템 32에서는 그 문제가 가변인자를 통해 다시 나타난다.

Varargs

↓

내부적으로 배열

↓

Generic Varargs

↓

Generic + Array

↓

Heap Pollution 가능

따라서 둘을 연결하면 다음과 같은 결론에 도달한다.

제네릭 데이터를 다룬다.

↓

배열이 꼭 필요한가?

↓

아니라면 List를 먼저 검토한다.

@SafeVarargs는 안전성의 증명서가 아니라 약속이다

이 부분은 꼭 기억할 필요가 있다.

다음 코드에

@SafeVarargs

가 붙어 있다고 해서 컴파일러나 JVM이 메서드 내부를 분석해서

이 메서드는 정말 안전함

이라고 인증해주는 것은 아니다.

오히려 반대다.

개발자가 컴파일러에게

내가 이 코드를 검토했고 안전하다는 것을 책임지겠다.

라고 말하는 것이다.

그래서 @SafeVarargs가 보이면 개발자 입장에서는 오히려 다음을 확인해야 한다.

정말 배열을 변조하지 않는가?

배열 참조가 탈출하지 않는가?

다른 메서드로 넘긴 뒤
위험한 작업이 일어나지 않는가?

unchecked cast로
타입 안전성을 깨뜨리지 않는가?

즉 단순한 경고 제거 애너테이션으로 보면 안 된다.


제네릭 가변인자 코드를 리뷰할 때 확인할 것

실무에서 다음 코드가 있다고 해보자.

@SafeVarargs
static <T> void process(
        List<T>... values
) {
    // ...
}

@SafeVarargs가 있으니 바로 안전하다고 판단하지 않는다.

먼저 구현을 확인한다.

배열 내용을 바꾸는가?

values[0] = ...

있다면 신중하게 검토해야 한다.


Object[]로 우회하는가?

Object[] array =
        values;

특히 그 뒤에 배열을 수정한다면 강한 위험 신호다.


배열 자체를 반환하는가?

return values;

가변인자 배열 참조가 탈출한다.

주의해야 한다.


필드 등에 저장하는가?

this.values =
        values;

메서드 호출 이후에도 배열 참조가 살아남는다.

외부에서 타입 안전성을 추론하기 어려워진다.


단순히 읽기만 하는가?

for (List<T> value : values) {
    // 읽기
}

상대적으로 안전성을 설명하기 쉽다.

이런 식으로 코드를 검토해야 한다.


SafeVarargs 사용 자체를 목표로 하면 안 된다

잘못된 접근은 다음과 같다.

경고 발생

↓

@SafeVarargs 추가

↓

경고 사라짐

↓

완료

올바른 순서는 반대다.

경고 발생

↓

왜 경고가 발생하는지 확인

↓

Heap Pollution 가능성 분석

↓

코드 자체가 안전한지 증명

↓

가능하면 List 기반 구조 검토

↓

제네릭 varargs가 꼭 필요하고
구현이 안전하다면

↓

@SafeVarargs

이 순서가 중요하다.


제네릭과 가변인자를 함께 사용할 때 판단 순서

실무에서는 다음과 같이 생각하면 정리하기 쉽다.

먼저 질문한다.

제네릭 varargs가 정말 필요한가?

필요하지 않다면

List<T>

나

Collection<T>

으로 변경할 수 있는지 검토한다.

그래도 가변인자가 호출 API 측면에서 필요하다면 다음을 본다.

varargs 배열을 수정하는가?

수정한다면 위험 가능성을 분석해야 한다.

다음은

varargs 배열이 외부로 탈출하는가?

를 확인한다.

마지막으로

이 메서드의 타입 안전성을
논리적으로 증명할 수 있는가?

를 확인한다.

모두 만족한다면 @SafeVarargs를 사용할 근거가 생긴다.


아이템 26부터 이어지는 제네릭의 방향

지금까지 제네릭 관련 아이템을 연결하면 하나의 흐름이 보인다.

아이템 26에서는 Raw Type을 피하라고 했다.

타입 정보를 버리지 않는다.

아이템 27에서는 비검사 경고를 제거하라고 했다.

컴파일러가 확인하지 못하는
타입 안전성 문제를 줄인다.

아이템 28에서는 배열보다 리스트를 권장했다.

제네릭과 배열의 충돌을 줄인다.

아이템 29에서는 직접 만드는 타입도 제네릭으로 만들라고 했다.

클라이언트의 cast를 제거한다.

아이템 30에서는 메서드 역시 제네릭으로 만들라고 했다.

입력과 출력의 타입 관계를
컴파일러에게 알려준다.

아이템 31에서는 한정적 와일드카드를 활용했다.

타입 안전성을 유지하면서
API를 더 유연하게 만든다.

그리고 아이템 32에서는 제네릭과 배열이 다시 만나는 가변인자 경계를 조심하라고 한다.

결국 이 모든 아이템의 방향은 같다.

가능한 한 타입에 대한 책임을 개발자의 기억이나 런타임 형변환이 아니라 컴파일러의 타입 시스템에 맡긴다.


핵심 정리

  • 가변인자 T...는 메서드 내부에서 배열 형태로 다뤄진다.
  • 일반적인 실체화 타입의 가변인자는 크게 문제가 없지만 List<String>... 같은 제네릭 가변인자는 배열과 제네릭의 타입 체계가 충돌한다.
  • Java는 new List<String>[10] 같은 제네릭 배열 생성을 막지만 제네릭 가변인자 선언 자체는 허용한다.
  • 제네릭 가변인자를 선언하면 Possible heap pollution from parameterized vararg type과 같은 경고가 발생할 수 있다.
  • Heap Pollution은 제네릭 타입 시스템이 기대하는 타입과 실제 저장된 객체의 타입 관계가 깨진 상태를 의미한다.
  • 제네릭 가변인자 배열을 Object[]로 참조한 뒤 다른 매개변수화 타입의 객체를 저장하면 Heap Pollution이 발생할 수 있다.
  • Heap Pollution 자체가 즉시 오류를 발생시키지 않더라도 나중에 컴파일러가 삽입한 형변환 지점에서 ClassCastException으로 나타날 수 있다.
  • 배열의 런타임 저장 검사는 List 수준의 타입은 확인할 수 있지만 타입 소거 때문에 List<String>과 List<Integer>의 타입 인수 차이까지 완벽하게 검사하지 못한다.
  • 제네릭 가변인자를 안전하게 사용하려면 가변인자 배열을 통해 타입 안전성을 깨뜨리는 값을 저장하지 않아야 한다.
  • 또한 가변인자 배열의 참조가 메서드 외부로 탈출하지 않도록 하는 것이 중요하다.
  • 가변인자 배열 자체를 반환하거나 필드에 보관하거나 외부 코드가 변경할 수 있는 위치로 전달하면 안전성을 보장하기 어려워질 수 있다.
  • toArray(T... args)처럼 가변인자 배열을 그대로 반환하는 메서드는 호출 문맥에서 기대하는 배열 타입과 실제 런타임 배열 타입이 달라져 ClassCastException으로 이어질 수 있다.
  • flatten()처럼 가변인자 배열을 읽기만 하고 새로운 타입 안전한 List에 원소를 옮긴 뒤 해당 List를 반환한다면 안전성을 증명하기 쉽다.
  • @SafeVarargs는 제네릭 가변인자를 사용한 코드가 자동으로 안전해지는 기능이 아니라 개발자가 해당 구현의 안전성을 보장한다는 선언이다.
  • 실제로 Heap Pollution을 만드는 코드에 @SafeVarargs를 붙여도 버그는 사라지지 않는다.
  • 제네릭 가변인자와 관련된 안전성을 표현할 목적이라면 범위가 넓은 @SuppressWarnings("unchecked")보다 의도가 명확한 @SafeVarargs가 적절할 수 있다.
  • 다만 어떤 애너테이션을 사용하든 먼저 코드 자체가 안전하다는 논리적인 근거가 필요하다.
  • 제네릭 가변인자가 반드시 필요한 것이 아니라면 List<T>나 Collection<T> 기반 API로 변경하는 것이 더 안전할 수 있다.
  • pickTwo()처럼 제네릭 배열을 반환하는 코드도 List<T>를 반환하도록 바꾸면 배열 런타임 타입 문제를 피할 수 있다.
  • 여러 제네릭 List를 합치는 API 역시 가변인자 대신 List<? extends List<? extends T>> 같은 Collection 기반 구조로 설계할 수 있다.
  • List 기반 설계에서는 아이템 31의 PECS 원칙을 함께 적용해 Producer에 ? extends T를 사용하면 API의 타입 안전성과 유연성을 동시에 높일 수 있다.
  • 가변인자는 호출 문법이 간결하다는 장점이 있으므로 무조건 금지할 필요는 없으며 타입 안전성을 확실히 증명할 수 있을 때 신중하게 사용하면 된다.
  • 제네릭 가변인자 코드를 리뷰할 때는 배열을 수정하는지, Object[]로 우회하는지, 배열 참조가 밖으로 탈출하는지, @SafeVarargs의 근거가 실제로 존재하는지를 확인해야 한다.
  • 아이템 28과 아이템 32를 함께 보면 결국 제네릭 데이터를 다룰 때 배열이 꼭 필요한 것이 아니라면 List를 우선 검토하는 것이 타입 안전성을 확보하기 쉬운 방법이라는 결론으로 이어진다.

한 줄 요약

제네릭 가변인자는 내부적으로 배열을 사용하기 때문에 Heap Pollution과 런타임 ClassCastException으로 이어질 수 있으므로, 반드시 사용해야 한다면 배열을 변조하거나 외부에 노출하지 않는다는 안전성을 먼저 증명한 뒤 @SafeVarargs를 사용하고, 가능하다면 처음부터 List<T> 같은 컬렉션 기반 API로 설계해 컴파일러의 타입 시스템이 안전성을 보장하도록 만드는 것이 좋다.

아이템 32. 완벽 공략 - ThreadLocal

완벽 공략 45. ThreadLocal은 왜 사용하는가

ThreadLocal이라는 이름을 처음 보면 다소 어렵게 느껴질 수 있다.

Thread라는 단어 자체가 동시성, 락, 동기화, Race Condition 같은 개념을 떠올리게 하기 때문이다.

하지만 ThreadLocal의 핵심 아이디어 자체는 복잡하지 않다.

이름 그대로 생각하면 된다.

하나의 변수를 모든 스레드가 공유하는 것이 아니라, 각 스레드가 자기 전용 값을 가지도록 만드는 기능

이라고 볼 수 있다.

일반적인 지역 변수(Local Variable)가 메서드 실행 범위 안에서 독립적으로 존재한다면, ThreadLocal은 스레드 단위로 독립적인 값을 관리할 수 있게 해주는 저장 공간이라고 이해하면 쉽다.


왜 ThreadLocal이 필요할까?

먼저 ThreadLocal이 없는 상황부터 생각해보자.

어떤 객체가 다음과 같은 필드를 가지고 있다고 하자.

public class FormatterService {

    private final SimpleDateFormat formatter =
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}

그리고 여러 스레드가 하나의 FormatterService 객체를 공유한다.

Thread A ─┐
          │
Thread B ─┼──> FormatterService
          │       │
Thread C ─┘       │
                  ▼
           SimpleDateFormat

이 경우 세 스레드가 동일한 SimpleDateFormat 객체를 사용한다.

문제는 SimpleDateFormat이 스레드 안전한 클래스가 아니라는 점이다.

여러 스레드가 동시에 같은 객체의 상태를 읽거나 변경하면 예상하지 못한 결과가 발생할 수 있다.


공유 상태가 동시성 문제의 출발점이다

예를 들어 다음과 같은 단순한 변수가 있다고 생각해보자.

private int value;

두 스레드가 동시에 값을 변경한다.

Thread A
value = 1

Thread B
value = 2

어느 스레드가 먼저 실행되고 어느 스레드가 나중에 실행되는지에 따라 최종 결과가 달라질 수 있다.

이처럼 실행 순서에 따라 결과가 달라질 수 있는 문제를 일반적으로 Race Condition이라고 한다.

Thread A ─────┐
              ├──> Shared State
Thread B ─────┘

공유 상태가 존재하면서 여러 스레드가 동시에 그 상태를 변경한다면 동시성 문제를 고려해야 한다.


전통적인 해결 방법은 동기화다

이런 문제를 해결하는 대표적인 방법은 synchronized나 Lock을 사용하는 것이다.

예를 들어

public synchronized void change() {
    // 공유 상태 변경
}

처럼 한 번에 하나의 스레드만 해당 코드에 접근할 수 있도록 제한할 수 있다.

개념적으로는 화장실의 잠금장치와 비슷하다.

Thread A
   │
   ▼
Lock 획득
   │
   ▼
Critical Section 실행
   │
   ▼
Lock 해제

그동안 다른 스레드는 기다린다.

Thread B
   │
   ▼
Lock 대기

동기화는 필요한 기능이지만 공유 상태와 락이 많아질수록 코드가 복잡해질 수 있다.

락을 잘못 관리하면 Deadlock 같은 문제도 발생할 수 있다.


Deadlock이란?

두 스레드가 서로 상대방이 가지고 있는 락을 기다리는 상황을 생각해보자.

Thread A

Lock A 획득
↓
Lock B 기다림


Thread B

Lock B 획득
↓
Lock A 기다림

둘 다 상대방이 락을 놓기만 기다린다.

하지만 둘 중 누구도 먼저 진행할 수 없다.

이 상태가 Deadlock이다.


Livelock도 있다

Deadlock에서는 두 스레드가 사실상 멈춰 있다.

반면 Livelock에서는 스레드들이 계속 움직이기는 하지만 실제 작업을 진행하지 못한다.

예를 들어 서로 양보만 반복한다고 생각해볼 수 있다.

Thread A
"네가 먼저 해"

Thread B
"아니 네가 먼저 해"

Thread A
"그럼 다시 네가 먼저 해"

Thread B
"아니 네가..."

상태 변화는 계속 일어나지만 실제 작업은 완료되지 않는다.

이런 문제까지 고려하기 시작하면 공유 상태를 안전하게 관리하는 것이 생각보다 어려워진다.


공유하지 않으면 문제가 훨씬 단순해진다

여기서 관점을 바꿔볼 수 있다.

공유 객체를 안전하게 만들자

가 아니라

애초에 객체를 공유하지 않으면 어떨까?

라고 생각하는 것이다.

예를 들어 스레드마다 별도의 Formatter가 있다면 어떨까?

Thread A
   │
   ▼
Formatter A


Thread B
   │
   ▼
Formatter B


Thread C
   │
   ▼
Formatter C

Thread A가 자신의 Formatter를 변경해도 Formatter B와 Formatter C에는 영향을 주지 않는다.

공유 상태 자체가 없어졌기 때문이다.

이런 아이디어를 구현할 때 사용할 수 있는 것이 ThreadLocal이다.


ThreadLocal이란?

가장 단순하게 선언하면 다음과 같다.

ThreadLocal<String> threadLocal =
        new ThreadLocal<>();

ThreadLocal<String>은 여러 스레드가 접근할 수 있지만, 각 스레드는 서로 다른 String 값을 가지게 된다.

예를 들어

                  ThreadLocal<String>
                         │
          ┌──────────────┼──────────────┐
          │              │              │
       Thread A       Thread B       Thread C
          │              │              │
        "AAA"          "BBB"          "CCC"

하나의 ThreadLocal 객체를 사용하고 있지만 값은 스레드마다 분리된다.

이것이 가장 중요한 특징이다.


값을 저장할 때는 set()

현재 스레드에 값을 저장할 때는 set()을 사용한다.

threadLocal.set("hello");

이 코드는

ThreadLocal 전체에
"hello" 저장

이라는 의미가 아니다.

정확히는

현재 이 코드를 실행하고 있는 스레드에 대응되는 값을 "hello"로 설정한다.

는 의미다.

Thread A에서 실행했다면

Thread A
   │
   └── "hello"

가 된다.

Thread B의 값에는 영향을 주지 않는다.


값을 조회할 때는 get()

현재 스레드에 저장된 값을 조회하려면 get()을 사용한다.

String value =
        threadLocal.get();

Thread A가 호출하면 Thread A의 값이 나온다.

Thread B가 호출하면 Thread B의 값이 나온다.

Thread A
threadLocal.get()
→ "AAA"


Thread B
threadLocal.get()
→ "BBB"

같은 코드인데도 실행하는 스레드에 따라 다른 값을 얻을 수 있다.


기본값을 지정할 수도 있다

매번 처음에 set()을 호출하는 대신 ThreadLocal을 만들 때 초기값 생성 방법을 지정할 수도 있다.

Java 8부터는 ThreadLocal.withInitial()을 사용할 수 있다.

private static final ThreadLocal<String> THREAD_LOCAL =
        ThreadLocal.withInitial(
                () -> "DEFAULT"
        );

처음 get()을 호출하면 해당 스레드를 위한 값이 만들어진다.

String value =
        THREAD_LOCAL.get();

결과는

DEFAULT

다.

하지만 중요한 것은 스레드마다 별도의 값이라는 것이다.


SimpleDateFormat을 ThreadLocal로 관리해보자

대표적인 예제가 SimpleDateFormat이다.

다음과 같이 만들 수 있다.

private static final ThreadLocal<SimpleDateFormat> FORMATTER =
        ThreadLocal.withInitial(
                () -> new SimpleDateFormat(
                        "yyyy-MM-dd HH:mm:ss"
                )
        );

이제 Formatter를 사용할 때 직접 필드를 참조하는 것이 아니라

FORMATTER.get()

을 호출한다.

String result =
        FORMATTER.get()
                .format(new Date());

중요한 차이는 각 스레드가 얻는 SimpleDateFormat 객체가 서로 다르다는 것이다.


실제 구조를 생각해보자

Thread A가 처음 호출한다.

FORMATTER.get();

그러면 Thread A를 위한 Formatter가 만들어진다.

Thread A
   │
   ▼
SimpleDateFormat A

Thread B에서도 호출한다.

FORMATTER.get();

이번에는 별도의 객체가 만들어진다.

Thread B
   │
   ▼
SimpleDateFormat B

결과적으로

                 FORMATTER
                    │
       ┌────────────┼────────────┐
       │            │            │
   Thread A     Thread B     Thread C
       │            │            │
       ▼            ▼            ▼
 Formatter A  Formatter B  Formatter C

와 같은 관계가 된다.


한 스레드가 Formatter를 바꿔도 다른 스레드에는 영향이 없다

Thread A에서 다음과 같이 변경했다고 해보자.

FORMATTER.get()
        .applyPattern("yyyy/MM/dd");

그러면 Thread A가 사용하는 Formatter만 변경된다.

Thread A
Formatter A
yyyy/MM/dd

Thread B는 여전히 자신의 Formatter를 가지고 있다.

Thread B
Formatter B
yyyy-MM-dd HH:mm:ss

즉 상태 변경이 다른 스레드로 전파되지 않는다.


ThreadLocal을 사용하면 synchronized가 필요 없는 걸까?

이 부분은 조심해서 이해해야 한다.

다음과 같이 단정하면 안 된다.

ThreadLocal을 쓰면 모든 멀티스레드 문제가 해결된다.

ThreadLocal이 해결하는 것은 스레드마다 독립된 값을 사용하도록 만들어 공유 상태를 줄이는 것이다.

예를 들어 다음은 좋다.

Thread A → Object A

Thread B → Object B

객체 자체를 공유하지 않기 때문에 Object A와 Object B 사이의 동기화가 필요하지 않다.

하지만 ThreadLocal 안에 동일한 공유 객체를 넣어버리면 이야기가 달라진다.


ThreadLocal에 넣었다고 객체가 자동 복제되는 것은 아니다

예를 들어 다음 객체가 있다고 하자.

SharedObject shared =
        new SharedObject();

그리고 여러 스레드가 같은 객체를 ThreadLocal에 넣었다.

threadLocal.set(shared);

ThreadLocal 자체는 값을 스레드별로 저장하지만 실제 참조 대상이 동일하면

Thread A ── ThreadLocal ──┐
                          ▼
                      SharedObject
                          ▲
Thread B ── ThreadLocal ──┘

결국 같은 객체를 공유하는 것이다.

따라서 그 객체가 mutable하고 thread-safe하지 않다면 여전히 동시성 문제가 발생할 수 있다.

ThreadLocal의 핵심은

스레드마다 독립적인 값을 저장할 수 있게 해준다.

이지,

넣은 객체를 자동으로 Thread Safe하게 만들어준다.

가 아니다.


ThreadLocal의 또 다른 중요한 장점

ThreadLocal이 단순히 동시성 문제를 줄이는 용도로만 사용되는 것은 아니다.

또 하나 중요한 특징이 있다.

같은 스레드 안에서는 호출 계층이 깊어져도 ThreadLocal 값에 접근할 수 있다.

예를 들어 요청 하나가 다음과 같은 흐름으로 처리된다고 하자.

Controller
    ↓
Service
    ↓
Domain Service
    ↓
Repository

각 계층에서 동일한 requestId가 필요하다고 생각해보자.

일반적인 방식이라면 계속 매개변수로 전달할 수 있다.

controller(requestId)

↓

service(requestId)

↓

domainService(requestId)

↓

repository(requestId)

메서드가 깊어질수록 모든 메서드에 해당 매개변수를 전달해야 한다.


ThreadLocal을 사용하면 명시적인 매개변수 전달을 줄일 수 있다

요청을 처리하기 시작할 때 값을 저장한다.

REQUEST_ID.set(requestId);

그리고 같은 스레드에서 실행되는 어느 코드에서든

String requestId =
        REQUEST_ID.get();

으로 조회할 수 있다.

HTTP Request
     │
     ▼
Thread A
     │
     ├── Controller
     │       │
     │       ▼
     │    Service
     │       │
     │       ▼
     │   Repository
     │
     └── ThreadLocal
            │
            ▼
        requestId

즉 같은 Thread 안에서 공유되는 일종의 문맥(Context) 저장소처럼 활용할 수 있다.


그래서 프레임워크에서 많이 사용한다

ThreadLocal은 애플리케이션 코드뿐만 아니라 다양한 프레임워크 내부에서도 활용된다.

대표적인 사례 중 하나가 Spring의 트랜잭션 처리다.

Spring에서는 현재 스레드와 관련된 트랜잭션 리소스와 동기화 정보를 관리할 때 TransactionSynchronizationManager 같은 구조를 활용한다.

개념적으로 생각하면 다음과 같다.

HTTP 요청
   │
   ▼
Thread A
   │
   ├── Service
   │      │
   │      ▼
   │   @Transactional
   │      │
   ▼      ▼
Repository
   │
   ▼
Database

애플리케이션 코드에서 매 메서드마다

service(connection);
repository(connection);
otherRepository(connection);

처럼 Connection이나 트랜잭션 문맥을 직접 전달하지 않는다.

같은 실행 스레드의 트랜잭션 문맥에 연결된 리소스를 프레임워크가 관리하기 때문이다.


Spring 트랜잭션과 ThreadLocal

개념적으로는 다음처럼 생각할 수 있다.

Thread A
   │
   └── Transaction Context
          │
          ├── Connection
          ├── Synchronization 정보
          └── 기타 리소스

Thread B는 별도의 문맥을 가진다.

Thread B
   │
   └── Transaction Context
          │
          └── 별도의 리소스

그래서 여러 요청이 동시에 처리되더라도 각 요청을 처리하는 스레드는 자신과 연결된 트랜잭션 문맥을 사용할 수 있다.

물론 실제 Spring 트랜잭션 구현 전체를 단순한 ThreadLocal<Connection> 하나로 이해해서는 안 된다.

다만 현재 스레드와 트랜잭션 리소스를 연결하는 데 ThreadLocal 계열 메커니즘이 중요한 역할을 한다고 이해하면 된다.


ThreadLocal 내부에서는 실제로 어떻게 관리할까?

ThreadLocal이라는 이름 때문에 다음처럼 생각하기 쉽다.

ThreadLocal 객체 안에

Thread A 값
Thread B 값
Thread C 값

모두 들어 있다.

하지만 실제 구조를 이해할 때는 반대로 생각하는 것이 더 가깝다.

각 Thread 객체가 자신의 ThreadLocal 관련 저장 공간을 가진다.

개념적으로 표현하면 다음과 같다.

Thread A
   │
   └── ThreadLocalMap
          │
          ├── ThreadLocal A → Value A
          └── ThreadLocal B → Value B


Thread B
   │
   └── ThreadLocalMap
          │
          ├── ThreadLocal A → Value C
          └── ThreadLocal B → Value D

즉 동일한 ThreadLocal을 키처럼 사용해 각 Thread가 자기 값을 관리한다고 생각할 수 있다.


ThreadLocal은 일종의 Key처럼 동작한다

예를 들어 다음 두 ThreadLocal이 있다고 하자.

ThreadLocal<String> userId =
        new ThreadLocal<>();

ThreadLocal<String> requestId =
        new ThreadLocal<>();

Thread A가 값을 설정한다.

userId.set("USER-1");
requestId.set("REQ-100");

개념적으로 Thread A 내부에는 다음과 같은 관계가 만들어진다.

Thread A
   │
   └── ThreadLocalMap
          │
          ├── userId ThreadLocal
          │      → "USER-1"
          │
          └── requestId ThreadLocal
                 → "REQ-100"

Thread B가 같은 ThreadLocal에 값을 설정해도 별도의 저장 공간을 사용한다.

Thread B
   │
   └── ThreadLocalMap
          │
          ├── userId ThreadLocal
          │      → "USER-2"
          │
          └── requestId ThreadLocal
                 → "REQ-200"

따라서 서로 간섭하지 않는다.


get()의 의미도 이제 이해할 수 있다

다음 코드를 호출한다고 생각해보자.

userId.get();

개념적으로는

현재 Thread 확인

↓

현재 Thread의 ThreadLocalMap 확인

↓

userId라는 ThreadLocal에 대응하는 값 조회

↓

현재 Thread의 userId 반환

과 같은 흐름이다.

따라서 같은 userId.get() 코드라도 어느 Thread에서 실행했느냐에 따라 결과가 달라진다.


set()도 같은 원리다

userId.set("USER-100");

를 호출하면

현재 Thread

↓

ThreadLocalMap

↓

현재 userId에 대응하는 값 저장

이라는 흐름으로 이해할 수 있다.

다른 Thread의 값은 건드리지 않는다.


remove()가 매우 중요하다

ThreadLocal을 사용할 때 get()과 set()만 알고 끝내면 안 된다.

실무에서는 오히려

remove()

가 굉장히 중요하다.

threadLocal.remove();

현재 스레드에 저장되어 있던 ThreadLocal 값을 제거한다.

왜 굳이 제거해야 할까?

Thread가 작업이 끝나면 사라진다면 큰 문제가 없어 보인다.

하지만 서버 애플리케이션에서는 Thread를 계속 재사용하는 경우가 많다.

대표적인 것이 Thread Pool이다.


Thread Pool에서는 Thread가 재사용된다

웹 서버를 생각해보자.

요청 하나가 들어올 때마다 Thread를 새로 생성하고 바로 버리면 비용이 크다.

그래서 일반적으로 Thread Pool을 사용한다.

Thread Pool

Thread-1
Thread-2
Thread-3
Thread-4

요청 A가 Thread-1에서 실행된다.

Request A
   ↓
Thread-1

처리가 끝난다고 해서 Thread-1이 사라지는 것이 아니다.

다음 요청 B에서 다시 사용할 수 있다.

Request B
   ↓
Thread-1

여기에서 ThreadLocal 값이 남아 있으면 문제가 생길 수 있다.


이전 요청의 값이 다음 요청에 남을 수 있다

Request A에서 다음 값을 저장했다고 해보자.

USER_CONTEXT.set(
        new UserContext("USER-A")
);

요청이 끝났는데 remove()하지 않았다.

그러면 Thread-1에는 여전히 값이 남아 있을 수 있다.

Thread-1

UserContext
→ USER-A

이 Thread가 Request B를 처리하게 됐다.

Request B
   ↓
Thread-1
   ↓
USER-A가 아직 남아 있음

잘못 설계하면 이전 요청의 문맥이 다음 요청에 영향을 주는 심각한 버그가 발생할 수 있다.


따라서 try-finally 패턴이 중요하다

직접 ThreadLocal을 관리한다면 보통 다음과 같은 구조를 고려해야 한다.

try {
    USER_CONTEXT.set(context);

    process();
} finally {
    USER_CONTEXT.remove();
}

핵심은 finally다.

처리 중 예외가 발생해도 반드시 정리해야 한다.

set()

↓

비즈니스 로직

↓

성공 / 예외

↓

finally

↓

remove()

서버 환경에서 ThreadLocal을 직접 사용할 때 가장 중요하게 확인해야 할 부분 중 하나다.


remove()하지 않으면 메모리 문제도 고려해야 한다

ThreadLocal은 Thread와 연결되어 값을 유지한다.

특히 Thread Pool의 Thread처럼 오랫동안 살아 있는 Thread에서는 불필요한 값도 오랫동안 유지될 가능성이 있다.

큰 객체를 ThreadLocal에 저장하고 제대로 정리하지 않는다면 불필요한 메모리 점유가 지속될 수 있다.

따라서 ThreadLocal을 사용할 때는 항상

이 값은 언제 생성되는가?

↓

언제까지 필요할까?

↓

언제 제거할 것인가?

를 같이 생각해야 한다.


ThreadLocal은 전역 변수와 비슷하지만 전역 변수는 아니다

ThreadLocal을 처음 사용하면 전역 변수처럼 느껴질 수 있다.

여러 계층에서 파라미터 없이 접근할 수 있기 때문이다.

Controller

Service

Repository

어디서든

↓

ThreadLocal.get()

하지만 중요한 차이가 있다.

일반적인 static 변수는 모든 Thread가 동일한 값을 공유할 수 있다.

static variable

Thread A ─┐
Thread B ─┼──> 같은 값
Thread C ─┘

ThreadLocal은 각 Thread가 별도의 값을 가진다.

ThreadLocal

Thread A → Value A
Thread B → Value B
Thread C → Value C

그래서 Thread 단위 Context를 표현할 수 있다.


ThreadLocal을 남용하면 안 되는 이유

파라미터를 전달하지 않아도 되기 때문에 ThreadLocal이 편리해 보일 수 있다.

예를 들어

User user =
        USER_CONTEXT.get();

만 호출하면 어디서든 사용자 정보를 얻을 수 있다.

그러나 이것을 지나치게 사용하면 코드의 의존 관계가 숨겨진다.

다음 메서드를 보자.

public void process() {
    User user =
            USER_CONTEXT.get();

    // ...
}

메서드 시그니처만 봐서는 User가 필요하다는 사실이 보이지 않는다.

반면 다음 코드는 의존 관계가 명확하다.

public void process(
        User user
) {
    // ...
}

따라서 ThreadLocal은

파라미터 전달하기 귀찮으니 모두 ThreadLocal에 넣자.

는 용도로 사용하는 것이 아니다.

요청 문맥, 트랜잭션 문맥, 로깅 Context처럼 실행 Thread와 생명주기가 밀접하게 연결된 횡단 관심사에서 신중하게 사용하는 것이 좋다.


대표적으로 잘 어울리는 정보

ThreadLocal을 활용하기 좋은 정보에는 다음과 같은 것들이 있다.

Request Context

Trace ID / Correlation ID

Security Context

Transaction 관련 Context

Thread별 Formatter 같은 객체

Thread별 임시 상태

공통점은 특정 실행 흐름과 밀접하게 관련되어 있다는 것이다.


최신 Java에서는 SimpleDateFormat 대신 다른 선택지도 있다

SimpleDateFormat은 ThreadLocal의 필요성을 설명하기 좋은 전통적인 예제다.

하지만 최신 Java 애플리케이션에서는 날짜 포맷팅을 위해 java.time의 DateTimeFormatter를 사용하는 경우가 많다.

private static final DateTimeFormatter FORMATTER =
        DateTimeFormatter.ofPattern(
                "yyyy-MM-dd HH:mm:ss"
        );

DateTimeFormatter는 불변이며 스레드 안전하게 사용할 수 있도록 설계되어 있다.

따라서 단순한 날짜 포맷팅 문제라면 굳이 다음처럼 만들 필요가 없다.

ThreadLocal<SimpleDateFormat>

ThreadLocal이 유용하지 않다는 뜻이 아니라, ThreadLocal로 문제를 해결하기 전에 애초에 공유 가능한 불변 객체나 Thread Safe한 구현을 사용할 수 있는지도 확인해야 한다는 의미다.


ThreadLocal과 ThreadLocalRandom은 어떻게 연결될까?

ThreadLocal을 이해하면 ThreadLocalRandom이라는 이름도 조금 자연스럽게 보인다.

멀티스레드 환경에서 여러 Thread가 하나의 공유 상태를 두고 경쟁하면 경합 비용이 발생할 수 있다.

ThreadLocal의 기본 아이디어는

하나의 공유 상태

↓

스레드별 상태

로 분리하는 것이다.

ThreadLocalRandom 역시 멀티스레드 환경에서 Random 값을 생성할 때 공유 Random 객체를 둘러싼 경합을 줄이는 방향과 관련된 클래스다.

따라서

ThreadLocalRandom.current()

이라는 API가 왜 등장하는지 이해하려면 먼저

스레드별로 독립적인 상태를 두면 공유 상태로 인한 경쟁을 줄일 수 있다.

는 ThreadLocal의 기본 아이디어를 이해하는 것이 도움이 된다.


ThreadLocal을 한 문장으로 이해하면

처음에는 복잡한 구현보다 다음 그림만 기억해도 충분하다.

일반 공유 변수는

Thread A ─┐
Thread B ─┼──> Value
Thread C ─┘

와 같다.

하나의 값을 모든 스레드가 공유한다.

ThreadLocal은

Thread A ───> Value A

Thread B ───> Value B

Thread C ───> Value C

와 같다.

즉

같은 ThreadLocal을 사용하더라도 각 Thread가 자기만의 값을 사용한다.

이것이 핵심이다.


실무에서는 ThreadLocal의 생명주기를 함께 봐야 한다

ThreadLocal을 코드 한 줄만 놓고 보면 굉장히 편리하다.

CONTEXT.set(context);

그리고 아무 곳에서나

Context context =
        CONTEXT.get();

하면 된다.

하지만 실무에서는 반드시 세 가지를 같이 생각해야 한다.

언제 set 하는가?

언제 get 하는가?

언제 remove 하는가?

특히 웹 서버나 Executor처럼 Thread Pool을 사용하는 환경에서는 remove()까지 포함해서 하나의 생명주기로 봐야 한다.

Request 시작

↓

ThreadLocal.set()

↓

비즈니스 로직 수행

↓

ThreadLocal.get()

↓

Request 종료

↓

ThreadLocal.remove()

이 흐름이 완성되어야 안전하게 사용할 수 있다.


핵심 정리

  • ThreadLocal은 하나의 값을 모든 Thread가 공유하는 대신 각 Thread가 독립적인 값을 가지도록 만들어주는 기능이다.
  • ThreadLocal을 단순히 Thread Safe한 변수를 만들어주는 기능이라고 이해하기보다는 Thread별 저장 공간을 제공하는 기능이라고 이해하는 것이 정확하다.
  • 여러 Thread가 동일한 mutable 객체를 공유하면 Race Condition 등 동시성 문제가 발생할 수 있다.
  • 공유 상태를 안전하게 관리하기 위해 synchronized나 Lock을 사용할 수 있지만 락 관리가 복잡해지면 Deadlock 같은 문제까지 고려해야 한다.
  • 애초에 각 Thread가 독립적인 객체를 사용하도록 만들 수 있다면 공유 상태에서 발생하는 일부 동기화 문제를 줄일 수 있다.
  • ThreadLocal<T>는 현재 Thread와 연결된 T 타입 값을 관리한다.
  • set()은 현재 Thread에 해당하는 값을 저장하고 get()은 현재 Thread에 저장된 값을 조회한다.
  • Java 8부터 ThreadLocal.withInitial()을 사용해 Thread별 초기값 생성 로직을 지정할 수 있다.
  • SimpleDateFormat처럼 Thread Safe하지 않은 객체를 여러 Thread가 공유하는 대신 ThreadLocal을 통해 Thread별 인스턴스를 만들면 서로의 상태 변경이 영향을 주지 않게 할 수 있다.
  • ThreadLocal에 값을 넣었다고 그 객체 자체가 자동으로 Thread Safe해지는 것은 아니다.
  • 여러 ThreadLocal에 같은 mutable 객체 참조를 저장한다면 결국 동일 객체를 공유하므로 동시성 문제가 다시 발생할 수 있다.
  • ThreadLocal은 같은 Thread의 여러 호출 계층에서 파라미터 전달 없이 Context에 접근할 수 있다는 특징이 있다.
  • 이 특징 때문에 요청 Context, 트랜잭션 Context, Security Context, 로깅 Trace 정보 등에서 ThreadLocal 계열 메커니즘이 활용될 수 있다.
  • Spring은 현재 Thread와 연결된 트랜잭션 리소스와 동기화 정보를 관리할 때 TransactionSynchronizationManager 같은 ThreadLocal 기반 메커니즘을 활용한다.
  • 실제 구조를 이해할 때는 ThreadLocal 객체 하나가 모든 Thread의 값을 직접 보관한다고 보기보다 각 Thread가 자신의 ThreadLocal 관련 Map을 가지고 있다고 이해하는 것이 가깝다.
  • 같은 ThreadLocal 객체는 각 Thread의 저장 공간에서 값을 찾기 위한 Key와 비슷한 역할을 한다.
  • 서버 환경에서는 Thread Pool에 의해 Thread가 재사용되므로 ThreadLocal 값을 사용한 후 정리하지 않으면 이전 요청의 값이 다음 요청에 남는 문제가 생길 수 있다.
  • ThreadLocal 값을 직접 관리할 때는 try-finally를 활용해 remove()가 반드시 호출되도록 하는 패턴을 고려해야 한다.
  • 장기간 살아 있는 Thread에 불필요한 ThreadLocal 값이 남아 있으면 메모리 점유 문제까지 이어질 수 있으므로 값의 생명주기를 함께 관리해야 한다.
  • ThreadLocal은 파라미터 전달을 무조건 없애기 위한 도구가 아니며 과도하게 사용하면 메서드의 숨겨진 의존성이 늘어나 코드 흐름을 파악하기 어려워질 수 있다.
  • SimpleDateFormat 예제는 ThreadLocal을 설명하기 좋은 사례지만 최신 Java에서는 Thread Safe한 DateTimeFormatter를 사용할 수 있으므로 먼저 불변 객체나 Thread Safe한 대안을 검토하는 것이 좋다.
  • ThreadLocal의 핵심 아이디어는 공유 상태를 Thread별 상태로 분리하는 것이며, 이를 이해하면 이후 ThreadLocalRandom이 멀티스레드 환경에서 왜 등장하는지도 이해하기 쉬워진다.

한 줄 요약

ThreadLocal은 하나의 공유 값을 동기화해서 사용하는 대신 각 Thread가 자기만의 값을 가지도록 만들어 실행 Thread에 종속된 Context나 Thread Safe하지 않은 상태를 분리할 수 있게 해주는 도구이며, 특히 Thread Pool 환경에서는 set()과 get()뿐 아니라 반드시 값의 생명주기와 remove()까지 함께 설계해야 안전하게 사용할 수 있다.

아이템 32. 완벽 공략 - ThreadLocalRandom

완벽 공략 46. ThreadLocalRandom은 왜 빠른가

앞에서는 ThreadLocal에 대해 살펴봤다.

ThreadLocal의 핵심은 여러 스레드가 하나의 상태를 공유하는 대신 각 스레드가 자신의 상태를 가지도록 만드는 것이다.

Thread A → Value A
Thread B → Value B
Thread C → Value C

이번에는 이름이 비슷한 ThreadLocalRandom을 살펴본다.

ThreadLocalRandom.current()
                 .nextInt(100);

이름만 보면 단순히

ThreadLocal + Random

처럼 보인다.

실제로 핵심 아이디어도 비슷하다.

여러 스레드가 하나의 난수 생성 상태를 계속 경쟁하면서 갱신하는 대신, 각 스레드가 자신의 난수 상태를 이용하도록 만들어 경합을 줄이는 것이 ThreadLocalRandom의 중요한 목적이다.

Oracle의 현재 Java 문서에서도 공유 Random 객체보다 ThreadLocalRandom을 사용하면 멀티스레드 프로그램에서 일반적으로 경합과 오버헤드를 줄일 수 있다고 설명한다.

그런데 이것을 제대로 이해하려면 먼저 Random이 어떻게 다음 난수를 만들어내는지 알아야 한다.


Random은 정말 무작위 값을 만드는 걸까?

컴퓨터가 사용하는 Random은 보통 완전히 무작위인 값을 갑자기 만들어내는 것이 아니다.

내부 상태인 seed를 가지고 다음 상태를 계산하고, 그 결과를 이용해 다음 난수를 만들어낸다.

개념적으로 단순화하면 다음과 같다.

현재 Seed
   │
   ▼
계산
   │
   ▼
새로운 Seed
   │
   ▼
난수 생성

그리고 다시 다음 난수를 요청하면 새롭게 바뀐 seed를 기준으로 계산한다.

Seed 1
  ↓
Random Value 1
  ↓
Seed 2
  ↓
Random Value 2
  ↓
Seed 3
  ↓
Random Value 3

이렇게 내부 상태를 계속 변경해가며 난수처럼 보이는 값을 만들어낸다.

그래서 정확히는 의사 난수(Pseudorandom Number) 라고 부른다.


Random의 여러 메서드는 결국 내부 난수 상태를 사용한다

Random에는 여러 메서드가 있다.

random.nextInt();
random.nextLong();
random.nextDouble();
random.nextBoolean();

겉으로 보기에는 서로 다른 기능처럼 보이지만 결국 내부 난수 생성 상태를 이용해 값을 만들어낸다.

전통적인 java.util.Random 구현에서 중요한 부분은 내부의 seed다.

현재 OpenJDK의 Random 구현도 AtomicLong seed를 사용하며, next(int bits)에서 기존 seed를 가져온 뒤 새로운 seed를 계산하고 compareAndSet()으로 원자적으로 갱신하는 구조를 사용한다.

개념적으로 단순화하면 다음과 같다.

private final AtomicLong seed;

그리고 다음 값을 만들 때 대략 이런 흐름이 발생한다.

do {
    oldSeed = seed.get();

    newSeed =
            calculateNextSeed(oldSeed);

} while (!seed.compareAndSet(
        oldSeed,
        newSeed
));

여기에서 중요한 것이

AtomicLong

과

compareAndSet()

이다.


AtomicLong은 무엇일까?

AtomicLong은 이름 그대로 long 값을 원자적으로 다룰 수 있도록 만들어진 클래스다.

AtomicLong count =
        new AtomicLong();

java.util.concurrent.atomic 패키지에 있으며 멀티스레드 환경에서 하나의 값을 안전하게 갱신할 수 있는 여러 연산을 제공한다.

예를 들어

count.incrementAndGet();

이나

count.compareAndSet(
        expected,
        update
);

같은 연산이다.

여기서 Atomic의 의미를 이해하려면 원자성(Atomicity) 을 이해해야 한다.


원자적이라는 것은 무엇일까?

예를 들어 다음 연산을 생각해보자.

count++;

겉으로 보면 하나의 작업처럼 보인다.

하지만 개념적으로는 여러 단계가 필요하다.

1. 현재 count 읽기

2. count + 1 계산

3. 새로운 값 저장

두 스레드가 동시에 이 작업을 실행하면 문제가 발생할 수 있다.

처음 값이 10이라고 해보자.

count = 10

Thread A가 값을 읽는다.

Thread A

read → 10

그 직후 Thread B도 읽는다.

Thread B

read → 10

두 스레드가 각각 1을 더한다.

Thread A → 11
Thread B → 11

그리고 둘 다 저장한다.

count = 11

두 번 증가했는데 결과는 11이다.

원래 기대했던 것은

12

였다.

이런 문제가 Race Condition의 대표적인 예다.


synchronized를 사용할 수도 있다

전통적인 방법 중 하나는 락을 사용하는 것이다.

synchronized void increment() {
    count++;
}

Thread A가 먼저 들어간다.

Thread A

Lock 획득
   ↓
count++
   ↓
Lock 해제

그동안 Thread B는 기다린다.

Thread B

Lock 기다림

이렇게 하면 한 번에 하나의 스레드만 해당 임계 영역을 실행하기 때문에 안전하다.

하지만 경쟁이 심해지면 락을 획득하고 기다리는 비용이 발생할 수 있다.


Atomic 클래스는 다른 접근 방법을 사용한다

AtomicLong 같은 클래스는 전형적인 synchronized 블록으로 모든 접근을 직렬화하기보다 CAS 같은 원자 연산을 적극적으로 이용한다.

CAS는

Compare And Set

또는 좀 더 일반적으로

Compare And Swap

이라고 부른다.

AtomicLong의 compareAndSet()은 현재 값이 개발자가 기대한 값과 같을 경우에만 새로운 값으로 변경한다.

형태는 다음과 같다.

boolean compareAndSet(
        long expectedValue,
        long newValue
)

뜻을 그대로 해석하면 된다.

현재 값이 expectedValue와 같아?

YES
↓
newValue로 변경


NO
↓
변경하지 않음

CAS를 숫자로 이해해보자

현재 값이 10이라고 해보자.

current = 10

Thread A가 읽는다.

Thread A

expected = 10
newValue = 11

Thread B도 거의 동시에 읽었다.

Thread B

expected = 10
newValue = 11

Thread A가 먼저 CAS를 실행한다.

현재 값 = 10
기대 값 = 10

일치

↓

11로 변경 성공

현재 상태는 이제

11

이다.

Thread B도 CAS를 실행한다.

Thread B가 알고 있던 기대값은 아직

10

이다.

그런데 실제 값은 이미

11

이다.

따라서

현재 값 = 11

기대 값 = 10

불일치

↓

변경 실패

가 된다.

Thread B는 다른 스레드가 먼저 값을 바꿨다는 사실을 알게 된다.


실패하면 다시 시도한다

Atomic 연산에서 흔히 사용하는 패턴은 다음과 같다.

while (true) {

    long oldValue =
            value.get();

    long newValue =
            calculate(oldValue);

    if (value.compareAndSet(
            oldValue,
            newValue
    )) {
        break;
    }
}

CAS가 실패했다는 것은

내가 값을 읽은 이후

↓

다른 스레드가 값을 변경했다.

라는 의미다.

그러면 현재 값을 다시 가져온다.

최신 값 읽기

↓

다시 계산

↓

CAS

↓

성공할 때까지 반복

이런 형태의 알고리즘을 CAS Loop라고 부르기도 한다.


CAS와 낙관적 락은 완전히 같은 개념은 아니다

CAS를 설명할 때 낙관적 락과 비슷하게 설명하기도 한다.

아이디어는 상당히 닮아 있다.

비관적인 접근은 먼저 경쟁이 발생할 것이라고 가정하고 접근 자체를 통제한다.

누군가 사용하고 있을 수 있다.

↓

먼저 Lock 확보

↓

안전하게 실행

반대로 낙관적인 접근은 먼저 작업을 시도한 뒤 상태가 변경됐는지 확인한다.

일단 작업 시도

↓

상태 확인

↓

충돌했으면 실패 또는 재시도

CAS 역시

내가 읽었던 값이
아직 그대로겠지?

↓

비교

↓

그대로면 갱신

↓

달라졌으면 실패

라는 아이디어를 사용한다.

다만 AtomicLong을 설명할 때 CAS를 단순히 “낙관적 락을 사용한다”고 동일시하는 것은 조금 거칠다.

DB의 Optimistic Lock처럼 실제 논리적인 락을 거는 구조와 달리 CAS 기반 Atomic 연산은 보통 lock-free 또는 non-blocking 동시성 알고리즘의 기반으로 이해하는 편이 더 정확하다.

즉 비유로는 비슷하지만 실제 동작 메커니즘은 구분해서 보는 것이 좋다.


Random으로 다시 돌아가보자

이제 Random을 다시 보면 이해하기 쉽다.

난수를 하나 생성하려면 내부 seed를 변경해야 한다.

현재 Seed

↓

새로운 Seed 계산

↓

Seed 업데이트

↓

Random Value 반환

하나의 Random 객체를 한 스레드만 사용한다면 큰 문제가 없다.

하지만 하나의 Random 인스턴스를 여러 스레드가 공유한다고 생각해보자.

                Random
                   │
                   ▼
              AtomicLong seed
              ▲     ▲     ▲
              │     │     │
Thread A ─────┘     │     │
Thread B ───────────┘     │
Thread C ─────────────────┘

세 스레드가 모두 같은 seed를 갱신하려고 한다.


Random 자체는 Thread Safe하다

여기서 중요한 점이 있다.

java.util.Random이 Thread Safe하지 않아서 ThreadLocalRandom이 등장한 것은 아니다.

현재 Java 문서에도 Random 인스턴스는 Thread Safe하다고 명시되어 있다.

즉 다음과 같이 하나의 객체를 여러 스레드에서 사용하더라도 단순히 그것 때문에 seed가 깨지는 구조는 아니다.

Random random =
        new Random();
Thread A → random.nextInt()

Thread B → random.nextInt()

Thread C → random.nextInt()

내부에서 원자적인 seed 갱신을 수행하기 때문이다.

문제는 안전성이 아니라 경합(Contention) 이다.


Thread Safe와 빠르다는 것은 다른 이야기다

이 부분은 동시성 프로그래밍에서 매우 중요하다.

Thread Safe

≠

고성능

하나의 공유 Random에 여러 스레드가 몰리면 모두 같은 AtomicLong seed를 변경하려고 한다.

Thread A와 B가 동시에 접근했다고 해보자.

Thread A
oldSeed = 100

Thread B
oldSeed = 100

Thread A가 먼저 성공한다.

100 → 200

Thread B는 실패한다.

expected = 100

actual = 200

↓

CAS 실패

그리고 다시 읽는다.

200

새로운 seed를 계산한다.

다시 CAS를 시도한다.


경쟁이 심해지면 CAS 재시도가 늘어난다

스레드가 많아질수록 이런 상황이 반복될 수 있다.

Thread A ── 성공

Thread B ── 실패 → Retry

Thread C ── 실패 → Retry

Thread D ── 실패 → Retry

CAS에는 synchronized처럼 다른 스레드가 락을 해제할 때까지 모니터에서 기다리는 방식의 블로킹은 없지만, 충돌하면 계산을 다시 해야 한다.

경쟁이 심하면

CAS 실패

↓

다시 읽기

↓

다시 계산

↓

다시 CAS

↓

또 실패

↓

Retry...

가 반복된다.

그래서 하나의 공유 Random 객체에 수많은 스레드가 동시에 접근하는 상황에서는 성능이 떨어질 수 있다.

Oracle의 Random 문서 역시 같은 Random 인스턴스를 여러 스레드가 동시에 사용할 경우 경합으로 인해 성능이 나빠질 수 있으므로 멀티스레드 설계에서는 ThreadLocalRandom을 고려하라고 설명한다.


여기서 ThreadLocalRandom이 등장한다

문제를 다시 정리하면 다음과 같다.

Random 하나

↓

Seed 하나

↓

여러 Thread가 동시에 변경

↓

CAS 경쟁

↓

실패와 Retry

↓

Contention 증가

그렇다면 해결 방법은 의외로 간단하다.

난수를 만들기 위한 상태를 굳이 모든 스레드가 공유하지 않으면 되지 않을까?

각 스레드가 자신의 난수 상태를 사용하면 된다.

개념적으로 다음과 같다.

Thread A
   │
   ▼
Seed A


Thread B
   │
   ▼
Seed B


Thread C
   │
   ▼
Seed C

이것이 ThreadLocalRandom의 중요한 아이디어다.


ThreadLocalRandom 사용법

사용법은 매우 간단하다.

int value =
        ThreadLocalRandom
                .current()
                .nextInt();

범위를 지정할 수도 있다.

int value =
        ThreadLocalRandom
                .current()
                .nextInt(100);

0 이상 100 미만의 값을 생성한다.

시작 범위도 지정할 수 있다.

int value =
        ThreadLocalRandom
                .current()
                .nextInt(
                        1,
                        101
                );

이 경우 1 이상 101 미만, 즉 1부터 100까지의 값이 나온다.

공식 API 역시 일반적인 사용 형태로 ThreadLocalRandom.current().nextX(...) 방식을 권장한다.


굳이 변수로 저장할 필요도 없다

다음처럼 사용할 수도 있다.

ThreadLocalRandom random =
        ThreadLocalRandom.current();

int value =
        random.nextInt(100);

하지만 간단한 경우라면 보통 바로 호출한다.

int value =
        ThreadLocalRandom
                .current()
                .nextInt(100);

API 자체가 이런 사용법을 염두에 두고 만들어져 있다.


ThreadLocalRandom은 ThreadLocal일까?

이름 때문에 다음 구조를 상상하기 쉽다.

ThreadLocal<Random>

그리고 각 스레드마다 실제 Random 객체 하나가 들어 있다고 생각할 수 있다.

개념을 이해하는 단계에서는

각 Thread마다
자신의 Random 상태를 사용한다.

라고 생각해도 좋다.

하지만 실제 OpenJDK 구현은 더 최적화되어 있다.

현재 OpenJDK의 ThreadLocalRandom 소스를 보면 ThreadLocalRandom 객체를 스레드마다 별도로 생성해 보관하는 방식이 아니라 하나의 static 인스턴스가 있고, 난수 생성에 필요한 seed 상태는 Thread 객체의 필드에 저장하는 구조를 사용한다.

즉 실제 구현을 단순화하면 다음에 가깝다.

             ThreadLocalRandom
              shared instance
                    │
        ┌───────────┼───────────┐
        │           │           │
        ▼           ▼           ▼
    Thread A    Thread B    Thread C
      Seed A      Seed B      Seed C

따라서 이름에 ThreadLocal이 들어 있다고 해서 내부적으로 우리가 앞에서 살펴본 ThreadLocal<T> 클래스를 단순히 사용한 구현이라고 생각하면 안 된다.

아이디어는 스레드 로컬 상태이지만 구현은 성능을 위해 더 낮은 수준으로 최적화되어 있다.


current()는 무엇을 하는가?

사용할 때 다음 메서드를 호출한다.

ThreadLocalRandom.current()

API 관점에서는 현재 스레드가 사용할 ThreadLocalRandom을 얻는 메서드다.

OpenJDK 구현 내부에서는 현재 Thread의 난수 상태가 초기화되어 있는지 확인하고 필요한 초기화를 수행한 뒤 ThreadLocalRandom 인스턴스를 반환한다.

따라서 개발자는 내부 상태 관리 방식을 신경 쓰지 않고

ThreadLocalRandom.current()
                 .nextInt();

만 사용하면 된다.


공유 Random과 ThreadLocalRandom을 비교해보자

공유 Random은 개념적으로 다음과 같다.

Thread A ─┐
Thread B ─┼──> Random
Thread C ─┘       │
                  ▼
             Shared Seed

seed를 여러 스레드가 공유한다.

원자적으로 갱신하기 때문에 안전하지만 경쟁이 발생할 수 있다.

반면 ThreadLocalRandom은 다음과 같다.

Thread A → Seed A

Thread B → Seed B

Thread C → Seed C

각 스레드가 자신의 상태를 기반으로 난수를 생성하기 때문에 공유 seed에 대한 CAS 경쟁을 크게 줄일 수 있다.

그래서 병렬 작업이나 Thread Pool에서 많은 작업이 동시에 난수를 생성하는 상황에 특히 적합하다. Oracle API 문서도 여러 태스크가 병렬로 난수를 사용하는 경우 ThreadLocalRandom이 특히 적합하다고 설명한다.


ThreadLocal에서 봤던 핵심 아이디어가 다시 등장한다

앞에서 ThreadLocal을 공부할 때 핵심은 다음이었다.

공유 상태

↓

Thread별 상태

ThreadLocalRandom에서도 비슷한 아이디어가 등장한다.

공유 Random의 경우

여러 Thread

↓

Shared Seed

↓

Contention

이 생길 수 있다.

반면 스레드별 난수 상태를 이용하면

Thread A → State A

Thread B → State B

Thread C → State C

가 되므로 서로 seed를 차지하려고 경쟁할 필요가 줄어든다.


Random을 쓰면 안 된다는 이야기는 아니다

여기서 Random을 무조건 사용하면 안 된다고 이해할 필요는 없다.

다음처럼 단일 스레드에서 사용하거나

Random random =
        new Random();

int value =
        random.nextInt();

여러 스레드가 하나의 Random에 아주 높은 빈도로 동시에 접근하지 않는 상황이라면 경합 문제가 애플리케이션에서 중요한 병목이 아닐 수도 있다.

Random 자체는 Thread Safe하다.

따라서 문제는 정확성보다는

여러 Thread

+

하나의 Random 공유

+

높은 호출 빈도

가 겹쳤을 때 발생할 수 있는 성능 문제다.


ThreadLocalRandom이 특히 적합한 상황

예를 들어 여러 작업이 Thread Pool에서 동시에 실행된다고 해보자.

executor.submit(() -> {
    int value =
            ThreadLocalRandom
                    .current()
                    .nextInt(100);
});

수많은 작업이 동시에 실행된다.

Pool Thread 1 → Random 생성

Pool Thread 2 → Random 생성

Pool Thread 3 → Random 생성

Pool Thread 4 → Random 생성

이런 환경에서는 하나의 공유 Random보다 ThreadLocalRandom이 경합을 줄이는 데 도움이 될 수 있다.

특히 ForkJoinPool처럼 병렬 태스크가 많은 환경에서도 자연스럽게 사용할 수 있다.


AtomicLong이 있다고 무조건 느린 것은 아니다

CAS 기반 Atomic 연산을 무조건 느리다고 이해해서도 안 된다.

경쟁이 거의 없다면 CAS는 상당히 효율적으로 동작할 수 있다.

예를 들어 Thread A만 값을 갱신한다면

Read

↓

Calculate

↓

CAS 성공

한 번에 끝날 수 있다.

문제가 되는 것은 여러 스레드가 동시에 같은 위치를 자주 갱신하는 높은 경합 상황이다.

Thread A
Thread B
Thread C
Thread D
Thread E

↓

동일한 AtomicLong

↓

CAS Competition

그때 실패와 재시도가 증가한다.


Lock과 CAS의 차이

둘을 단순하게 비교하면 다음과 같다.

구분Lock 기반CAS 기반
대표 예synchronized, LockAtomicLong.compareAndSet()
충돌 시Lock이 풀릴 때까지 대기 가능연산 실패 후 재시도 가능
핵심 아이디어한 번에 하나만 진입상태가 그대로면 갱신
Blocking발생 가능일반적으로 non-blocking 기반
높은 경합대기 증가CAS 실패와 재시도 증가

CAS도 공짜는 아니다.

단지 락을 사용하는 방식과 비용의 형태가 다르다.


Lock-Free라고 모든 Thread가 반드시 진행하는 것은 아니다

CAS 기반 구조를 공부할 때 한 가지 더 알아두면 좋다.

어떤 Thread 하나가 계속 CAS에서 실패할 수도 있다.

Thread A → 성공

Thread B → 실패

Thread B → Retry

Thread C → 성공

Thread B → 또 실패

Thread B → Retry

시스템 전체로 보면 누군가는 계속 진행하지만 특정 Thread 하나가 빠르게 성공한다는 보장은 없을 수 있다.

그래서 lock-free와 wait-free는 같은 개념이 아니다.

lock-free는 전체 시스템 차원의 진행 가능성을 중요하게 보는 개념이고, 모든 개별 Thread가 정해진 단계 안에 반드시 완료한다는 의미는 아니다.

AtomicLong과 CAS를 이해할 때 알아두면 좋은 동시성 개념이다.


ThreadLocalRandom의 핵심은 Thread Safety보다 Contention 감소다

다시 가장 중요한 부분으로 돌아가보자.

Random은 이미 Thread Safe하다.

따라서

Random은 Thread Safe하지 않다.

↓

ThreadLocalRandom이 필요하다.

라고 이해하면 잘못된 방향이다.

정확한 흐름은 다음에 가깝다.

Random은 Thread Safe하다.

↓

공유 Seed를 Atomic하게 변경한다.

↓

여러 Thread가 하나의 Random을
동시에 많이 사용하면

↓

동일한 상태를 갱신하기 위해 경쟁한다.

↓

CAS 실패 / Retry 증가

↓

Contention 발생 가능

↓

Thread별 난수 상태를 사용하면
공유 상태 경쟁을 줄일 수 있다.

↓

ThreadLocalRandom

이 흐름이 이번 내용에서 가장 중요하다.


ThreadLocalRandom은 암호용 난수로 사용하면 안 된다

ThreadLocalRandom을 빠른 난수 생성기로 이해했다면 한 가지 주의할 점이 있다.

ThreadLocalRandom은 암호학적으로 안전한 난수 생성기가 아니다.

공식 Java 문서 역시 보안에 민감한 애플리케이션에서는 SecureRandom 사용을 권장한다.

따라서 다음 같은 용도라면 주의해야 한다.

인증 토큰

비밀번호 초기화 토큰

암호화 키

보안용 OTP

예측이 어려워야 하는 보안 값

이런 곳에서는 단순히

ThreadLocalRandom.current()

를 선택하면 안 된다.

반대로 다음과 같은 일반적인 비보안 목적에서는 사용할 수 있다.

게임 랜덤 값

샘플링

랜덤한 작업 선택

테스트용 임의 값

부하 분산을 위한 비보안 난수

ThreadLocalRandom을 사용하면서 setSeed()하지 않는다

일반적인 Random에서는 seed를 지정할 수 있다.

Random random =
        new Random(1234L);

같은 seed를 사용하면 재현 가능한 난수 시퀀스를 만들 수 있다.

하지만 ThreadLocalRandom은 직접 seed를 설정하는 방식으로 사용하는 클래스가 아니다.

ThreadLocalRandom.current()

을 통해 사용하고 내부 상태 관리는 구현체에게 맡긴다.

실제로 ThreadLocalRandom.setSeed()는 지원되지 않으며 호출하면 UnsupportedOperationException이 발생하도록 정의되어 있다.

테스트에서 동일한 난수 시퀀스를 재현해야 하는 상황이라면 ThreadLocalRandom이 오히려 적절하지 않을 수도 있다.


실무에서는 무엇을 선택해야 할까?

아주 단순하게 정리하면 다음과 같이 판단할 수 있다.

일반적인 단일 실행 흐름에서 간단한 난수가 필요하다면 굳이 모든 내부 구현까지 고민할 필요는 없다.

하지만 여러 Thread가 병렬로 상당한 빈도의 난수를 생성하고 있다면

ThreadLocalRandom.current()
                 .nextInt(...)

를 고려할 수 있다.

그리고 보안이 관련되어 있다면 별개의 문제다.

SecureRandom

을 검토해야 한다.

즉 목적이 다르다.

일반 난수
→ Random 계열

멀티스레드 + 높은 경합 가능성
→ ThreadLocalRandom

보안 난수
→ SecureRandom

Random에서 ThreadLocalRandom까지 전체 흐름

이번 내용을 하나로 연결하면 다음과 같다.

Random은 다음 난수를 만들기 위해 내부 seed 상태를 변경한다.

Seed

↓

Update

↓

Random Value

여러 Thread가 하나의 Random을 공유하면 모두 같은 seed에 접근한다.

Thread A ─┐
Thread B ─┼→ Shared Seed
Thread C ─┘

Random은 AtomicLong과 원자적 갱신을 이용하기 때문에 Thread Safe하다.

AtomicLong

↓

CAS

↓

Thread Safe

하지만 여러 Thread가 동시에 접근하면 CAS 경쟁이 생긴다.

Compare

↓

한 Thread 성공

↓

다른 Thread 실패

↓

Retry

경쟁이 심해지면 성능 비용이 증가할 수 있다.

그래서 상태를 스레드별로 나눈다.

Thread A → Seed A
Thread B → Seed B
Thread C → Seed C

그리고 이것이 ThreadLocalRandom이 높은 동시성 환경에서 공유 Random보다 유리할 수 있는 핵심 이유다.


ThreadLocal과 연결해서 기억하자

앞에서 공부한 ThreadLocal의 핵심은

Shared State를

↓

Thread Scoped State로 분리

하는 것이었다.

ThreadLocalRandom에서도 비슷한 사고방식이 나타난다.

다만 실제 구현에서는 단순히

ThreadLocal<Random>

을 만들어 사용하는 것이 아니라, OpenJDK가 Thread 내부에 난수 상태를 두는 방식으로 강하게 최적화해 놓았다.

따라서 개념은

Thread별 Random 상태

로 이해하고,

실제 구현은

ThreadLocal<T>을 그대로 사용한다고
단정하지 않는다.

정도로 구분하면 된다.


핵심 정리

  • ThreadLocalRandom을 이해하려면 먼저 Random이 내부 상태인 seed를 갱신하면서 의사 난수를 생성한다는 점을 이해해야 한다.
  • java.util.Random은 Thread Safe하지 않은 클래스가 아니라 여러 Thread에서 안전하게 공유할 수 있도록 구현된 클래스다.
  • 전통적인 Random 구현은 AtomicLong으로 seed를 관리하고 compareAndSet()을 이용해 원자적으로 seed를 갱신한다.
  • AtomicLong은 락을 직접 사용하는 대신 CAS 같은 원자 연산을 이용해 멀티스레드 환경에서 안전한 값 갱신을 지원한다.
  • CAS는 현재 값이 내가 예상했던 값과 같은 경우에만 새로운 값으로 변경하는 방식이다.
  • 내가 값을 읽은 이후 다른 Thread가 값을 변경했다면 CAS가 실패하고 최신 값을 기준으로 다시 연산할 수 있다.
  • 이런 반복 구조를 CAS Loop라고 이해할 수 있다.
  • CAS의 사고방식은 낙관적 동시성 제어와 비슷하지만 Atomic 클래스의 CAS를 DB의 낙관적 락과 완전히 동일한 개념으로 보는 것은 피하는 것이 좋다.
  • CAS 기반 Atomic 클래스는 일반적으로 lock-free 또는 non-blocking 알고리즘의 기반으로 이해할 수 있다.
  • Random 하나를 여러 Thread가 공유하면 모두 동일한 seed를 갱신하려 하기 때문에 높은 동시성 환경에서는 CAS 경합이 발생할 수 있다.
  • CAS에서 경쟁에 진 Thread는 최신 seed를 다시 읽고 연산을 재시도해야 하므로 경쟁이 심할수록 추가 비용이 발생할 수 있다.
  • 따라서 Random과 ThreadLocalRandom의 가장 중요한 차이를 단순한 Thread Safety 문제로 보면 안 된다.
  • 둘의 핵심 차이는 여러 Thread가 하나의 Random 상태를 공유할 때 발생하는 Contention을 어떻게 줄이는가에 있다.
  • ThreadLocalRandom은 각 Thread가 독립적인 난수 상태를 사용하도록 만들어 공유 seed를 둘러싼 경합을 줄인다.
  • 일반적인 사용법은 ThreadLocalRandom.current().nextInt(...) 형태다.
  • ThreadLocalRandom이라는 이름과 달리 현재 OpenJDK 구현이 단순히 ThreadLocal<Random> 객체를 Thread마다 하나씩 저장하는 것은 아니다.
  • 현재 OpenJDK 구현에서는 하나의 ThreadLocalRandom 인스턴스를 이용하면서 난수 생성에 필요한 seed 상태를 Thread 객체 쪽에 두는 최적화된 방식을 사용한다.
  • 따라서 ThreadLocalRandom의 핵심 개념은 Thread별 Random 객체보다는 Thread별 난수 상태라고 이해하는 편이 정확하다.
  • CAS 기반 방식은 락을 기다리는 블로킹을 피할 수 있지만 경쟁이 심하면 실패와 Retry가 반복될 수 있으므로 비용이 없는 것은 아니다.
  • Random을 무조건 사용하면 안 되는 것은 아니며 단일 Thread이거나 하나의 Random에 대한 동시 호출 경쟁이 크지 않다면 문제가 되지 않을 수 있다.
  • 여러 Thread 또는 Thread Pool의 많은 작업이 짧은 시간에 동시에 난수를 생성한다면 ThreadLocalRandom을 고려할 수 있다.
  • ThreadLocalRandom은 암호학적으로 안전한 난수 생성기가 아니므로 인증 토큰이나 암호화 키처럼 보안이 중요한 난수에는 SecureRandom을 사용해야 한다.
  • ThreadLocalRandom의 seed는 사용자가 직접 설정하는 용도로 설계되지 않았으며 setSeed()는 지원되지 않는다.
  • ThreadLocal과 ThreadLocalRandom을 함께 이해할 때 가장 중요한 공통 아이디어는 공유 상태로 인한 경쟁을 줄이기 위해 상태를 Thread 단위로 분리한다는 것이다.

한 줄 요약

Random은 AtomicLong과 CAS를 이용해 여러 Thread가 공유해도 안전하지만 하나의 seed를 동시에 갱신하면 CAS 실패와 재시도로 경합이 발생할 수 있고, ThreadLocalRandom은 난수 생성 상태를 Thread별로 분리해 이 공유 상태 경합을 줄임으로써 병렬·멀티스레드 환경에서 더 효율적인 난수 생성을 제공한다.


© 2020. All rights reserved.

SIKSIK