[스프링 핵심 원리 - 고급편] #02. 스레드 로컬 - ThreadLocal(3)

[Pracrobo]

ThreadLocal 소개

스레드 로컬은 해당 스레드만 접근할 수 있는 특별한 저장소를 말한다. 쉽게 이야기해서 물건 보관 창구를 떠올리면 된다. 여러 사람이 같은 물건 보관 창구를 사용하더라도 창구 직원은 사용자를 인식해서 사용자별로 확실하게 물건을 구분해준다.

사용자 A, 사용자 B 모두 창구 직원을 통해서 물건을 보관하고 꺼내지만 창구 직원이 사용자에 따라 보관한 물건을 구분해주는 것이다.

일반적인 변수 필드

• 여러 스레드가 같은 인스턴스의 필드에 접근하면 처음 스레드가 보관한 데이터가 사라질 수 있다.
  
  thread-A가 userA라는 값을 저장하고
  
  thread-B가 userB라는 값을 저장하면 직전에 thread-A가 저장한 userA값은 사라진다.

이 문제를 해결해주는 것은

스레드 로컬

스레드 로컬을 사용하면 각 스레드마다 별도의 내부 저장소를 제공한다. 따라서 같은 인스턴스의 스레드 로컬 필드에 접근해도 문제가 없다.

threadA가 userA 라는 값을 저장하면 스레드 로컬은 threadA전용보관소에 데이터를 안전하게 보관한다.

threadB가 userB이라는 값을 저장하면 스레드 로컬은 thread-B전용 보관소에 데이터를 안전하게 보관한다.

스레드 로컬을 통해서 데이터를 조회할때도 threadA가 조회하면 스레드 로컬은 threadA 전용보관소에서 userA데이터를 반환해준다. 물론 thread-B가 조회하면 thread B 전용 보관소에서 userB 데이터를 반환해준다.

동시에 들어와도 구분해서 처리해준다.

자바는 언어 차원에서 스레드 로컬을 지원하기 위한 java.lang.ThreadLocal클래스를 제공한다.

ThreadLocal - 예제코드

package hello.advanced.trace.threadlocal.code;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ThreadLocalService {
    private ThreadLocal<String> nameStore = new ThreadLocal<>();

    public String logic(String name) {
        log.info("저장 name= {} -> nameStore = {}", name, nameStore.get());
        nameStore.set(name);
        sleep(1000);
        log.info("조회 nameStore={}", nameStore.get());
        return nameStore.get();
    }

    private void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

• 기존에 있던 FieldService와 거의 같은 코드인데, nameStore 필드가 일반 String 타입에서 ThreadLocal을 사용하도록 변경되었다.

ThreadLocal 사용법

• 값 저장: ThreadLocal.set(xxx)
• 값 조회: ThreadLocal.get()
• 값 제거: ThreadLocal.remove()

주의
해당 스레드가 스레드 로컬을 모두 사용하고 나면 ThreadLocal.remove()를 호출해서 스레드 로컬에 저장된 값을 제거해주어야 한다.

package hello.advanced.trace.threadlocal;

import hello.advanced.trace.threadlocal.code.ThreadLocalService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
public class ThreadLocalServiceTest {

    private ThreadLocalService service = new ThreadLocalService();

    @Test
    void field() {
        log.info("main start");

        Runnable userA = () -> {
            service.logic("userA");
        };

        Runnable userB = () -> {
            service.logic("userB");
        };

        Thread threadA = new Thread(userA);
        threadA.setName("thread-A");
        Thread threadB = new Thread(userB);
        threadB.setName("thread-B");

        threadA.start();
        sleep(2000); // 동시성 문제 발생 X
        threadB.start();
        sleep(3000); // 메인 스레드 종료 대기
        log.info("main exit");

    }

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

    }
}

실행결과

동시성 문제 발생하게끔 실행

• 스레드 로컬 덕분에 스레드마다 각각 별도의 데이터 저장소를 가지게 되었다. 결과적으로 동시성 문제도 해결되었다.

스레드 로컬 동기화 - 개발

FieldLogTrace에서 발생했던 동시성 문제를 ThreadLocal로 해결해보자

TraceId traceIdHolder 필드를 스레드 로컬을 사용하도록 ThreadLocal<TraceId> traceIdHolder로 변경하면 된다.

필드 대신에 스레드 로컬을 사용해서 데이터를 동기화하는 ThreadLocalLogTrace를 새로 만든다.

package hello.advanced.trace.logtrace;

import hello.advanced.trace.TraceId;
import hello.advanced.trace.TraceStatus;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ThreadLocalLogTrace implements LogTrace {

    private static final String START_PREFIX = "-->";
    private static final String COMPLETE_PREFIX = "<--";
    private static final String EX_PREFIX = "<X-";
 
    private ThreadLocal<TraceId> traceIdHolder = new ThreadLocal<>(); //여기 추가
    
    @Override
    public TraceStatus begin(String message) {
        syncTraceId(); // 호출
        TraceId traceId = traceIdHolder.get(); // 여기서 꺼내 쓴다.
        Long startTimeMs = System.currentTimeMillis();
        log.info("[{}] {}{}", traceId.getId(), addSpace(START_PREFIX,
                traceId.getLevel()), message); //addSpace ->
        // 로그 출력
        return new TraceStatus(traceId, startTimeMs, message);
    }

    private void syncTraceId() {
        TraceId traceId = traceIdHolder.get(); //get()해서 가져온다.
        if (traceId == null) { //null일때 새로 만들고
            traceIdHolder.set(new TraceId());
        } else { //아닐때 기존에있던거 가져와
            traceIdHolder.set(traceId.createNextId());
        }
    }

    @Override
    public void end(TraceStatus status) {
        complete(status, null);
    }

    @Override
    public void exception(TraceStatus status, Exception e) {
        complete(status, e);
    }

    private void complete(TraceStatus status, Exception e) {
        Long stopTimeMs = System.currentTimeMillis();
        long resultTimeMs = stopTimeMs - status.getStartTimeMs();
        TraceId traceId = status.getTraceId();
        if (e == null) {
            log.info("[{}] {}{} time={}ms", traceId.getId(),
                    addSpace(COMPLETE_PREFIX, traceId.getLevel()), status.getMessage(),
                    resultTimeMs);
        } else {
            log.info("[{}] {}{} time={}ms ex={}", traceId.getId(),
                    addSpace(EX_PREFIX, traceId.getLevel()), status.getMessage(), resultTimeMs,
                    e.toString());
        }
        releaseTraceId();
    }

    private void releaseTraceId() {
        TraceId traceId = traceIdHolder.get(); //get()으로 생성하고
        if (traceId.isFirstLevel()) { 
            traceIdHolder.remove(); //destroy
        } else {
            traceIdHolder.set(traceId.createPreviousId()); // set으로
        }
    }

    private static String addSpace(String prefix, int level) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < level; i++) {
            sb.append((i == level - 1) ? "|" + prefix : "|   ");
        }
        return sb.toString();

    }

}

traceIdHolder가 필드에서 ThreadLocal로 변경되었다. 따라서 값을 저장할때는 set() 을 사용하고 값을 조회할때는 get()을 사용한다.

ThreadLocal.remove()

추가로 스레드 로컬을 모두 사용하고 나면 꼭 ThreadLocal.remove()를 호출해서 스레드 로컬에 저장된 값을 제거해줘야한다.

쉽게 이야기 해서 다음의 마지막 로그를 출력하고 나면 스레드 로컬의 값을 제거해야한다.

여기서는 releaseTraceId()를 통해 level1이 점점 낮아져서 2→ 1→ 0이 되면 로그를 처음 호출한 부분으로 돌아온 것이다. 따라서 이 경우 연관된 로그 출력이 끝난것이다. 이제 더이상 TraceId 값을 추적하지 않아도 된다.

그래서 traceId.isFirstLevel()(level==0)인 경우 ThreadLocal.remove()를 호출해서 스레드 로컬에 저장된 값을 제거해준다.

package hello.advanced.trace.logtrace;

import hello.advanced.trace.TraceStatus;
import org.junit.jupiter.api.Test;

class ThreadLocalLogTraceTest {
    ThreadLocalLogTrace trace = new ThreadLocalLogTrace();

    @Test
    void begin_end_level2() {
        TraceStatus status1 = trace.begin("hello1");
        TraceStatus status2 = trace.begin("hello2");
        trace.end(status2);
        trace.end(status1);

    }

    @Test
    void begin_exception_level2() {
        TraceStatus status1 = trace.begin("hello1");
        TraceStatus status2 = trace.begin("hello2");
        trace.exception(status2, new IllegalStateException());
        trace.exception(status1, new IllegalStateException());
    }

}

실행결과

스레드 로컬 동기화 - 적용

LogTraceConfig - 수정

package hello.advanced;

import hello.advanced.trace.logtrace.FieldLogTrace;
import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.trace.logtrace.ThreadLocalLogTrace;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration // @Component 가 있어 SpringBean의 대상이 된다.
public class LogTraceConfig {
    @Bean
    public LogTrace logTrace() {
        return new ThreadLocalLogTrace(); // 변경
    }

}

동시요청

• 로그를 직접 분리해서 확인해보면 각각의 스레드 nio-8080-exec-3, nio-8080-exec-4 별로 로그가 정확하게 나누어진 것을 확인할 수 있다.

스레드 로컬 - 주의사항

스레드 로컬의 값을 사용 후 제거하지 않고 그냥 두면 WAS처럼 스레드 풀을 사용하는 경우에 심각한 문제가 발생할 수 있다.

사용자 A 저장 요청

1. 사용자 A가 저장 HTTP를 요청했다.
2. WAS 는 스레드 풀에서 스레드를 하나 조회한다.
3. 스레드 thread-A 가 할당되었다.
4. thread-A 는 사용자 A의 데이터를 스레드 로컬에 저장한다.
5. 스레드 로컬의 thread-A 전용 보관소에 사용자 A 데이터를 보관한다.

사용자 A 저장 요청 종료

1. 사용자 A의 HTTP 응답이 끝난다.
2. WAS는 사용이 끝난 thread-A를 스레드 풀에 반환한다. 스레드를 생성하는 비용은 비싸기 때문에 스레드를 제거하지 않고 보통 스레드 풀을 통해서 스레드를 재사용한다.
3. thread-A는 스레드풀에 아직 살아있다. 다라서 스레드 로컬의 thread-A 전용 보관소에 사용자 A 데이터도 함께 살아있게 된다.

사용자 B 조회 요청

1. 사용자B가 조회를 위한 새로운 HTTP 요청을 한다.
2. WAS는 스레드 풀에서 스레드를 하나 조회한다.
3. 스레드 thread-A 가 할당되었다(물론 다른 스레드가 할당될 수도 있다.)
4. 이번에는 조회하는 요청이다. thread-A는 스레드 로컬에서 데이터를 조회한다.
5. 스레드 로컬을 thread-A 전용 보관소에 있는 사용자 A값을 반환한다.
6. 결과적으로 사용자 A값이 반환된다.
7. 사용자 B는 사용자 A의 정보를 조회하게 된다.

결과적으로 사용자 B는 사용자 A의 데이터를 확인하게 되는 심각한 문제가 발생하게 된다.

이런 문제를 예방하려면 사용자 A의 요청이 끝날때 스레드 로컬의 값을 ThradLoca.remove() 를 통해서 꼭 제거해야 한다.