[스프링 핵심원리 - 고급편] #2. 쓰레드 로컬 - ThreadLocal

[YONGHYNG]

ThreadLocal

• 쓰레드 로컬은 해당 쓰레드만 접근할 수 있는 특별한 저장소
• ex) 물건 보관 창구, 여러 사람이 물건 보관 창구를 사용하더라도 창구 직원은 사용자를 인식, 사용자별로 확실하게 물건을 구분해서 줌
• 사용자A, 사용자B 모두 창구 직원을 통해서 물건을 보관, 꺼내지만 창구 지원이 사용자에 따라 보관한 물건을 구분해 주는 것

일반적인 변수 필드

• 여러 쓰레드가 같은 인스턴스에 접근하면 처음 쓰레드가 보관한 데이터가 사라질 수 있음

쓰레드 로컬

• 쓰레드 로컬을 사용하면 각 쓰레드마다 별도의 내부 저장소 제공, 같은 인스턴스의 쓰레드 로컬 필드에 접근해도 문제 없음

• 쓰레드 로컬을 통해서 데이터를 조회할 떄도 thread-A가 조회하면 쓰레드 로컬은 thread-A 전용 보관소에서 userA 데이터를 반환
• thread-B가 조회하면 thread-B 전용 보관소에서 userB 데이터 반환
• 쓰레드 로컬을 지원하ㅣ 위해 java.lang.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 threadLocal() {
        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(100);
        threadB.start();
        
        sleep(2000);
        log.info("main exit");
    }
    
    private void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
}

쓰레드 로컬 동기화 - 개발

• 동시성 문제를 ThreadLocal로 해결해 보자
• TraceId traceIdHolder 필드를 쓰레드 로컬을 사용하도록 ThreadLocal traceIdHolder 변경

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
    //begin() -> syncTraceId() 호출 level 증가 & 로그 시작
    public TraceStatus begin(String message) {
        syncTraceId();
        TraceId traceId = traceIdHolder.get();
        Long startTimeMs = System.currentTimeMillis();
        log.info("[{}] {}{}", traceId.getId(), addSpace(START_PREFIX,
                traceId.getLevel()), message);

        return new TraceStatus(traceId, startTimeMs, message);
    }

    @Override
    //complete() 호출, 실행시간 출력, releaseTraceId() 호출
    public void end(TraceStatus status){
        complete(status, null);
    }

    @Override
    예외 로그 출력, releaseTraceId() 호출
    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();
    }
   //새로운 요청이면 level = 0, 중첩되면 level 증가
    private void syncTraceId() {
        TraceId traceId = traceIdHolder.get();
        if(traceId == null) {
            traceIdHolder.set(new TraceId());
        } else {
            traceIdHolder.set(traceId.createNextId());
        }
    }
    //level 감소, level = 0 이면 ThreadLocal.remove() 로 삭제
    private void releaseTraceId() {
        TraceId traceId = traceIdHolder.get();
        if (traceId.isFirstLevel()) {
            traceIdHolder.remove();//destroy
        } else {
            traceIdHolder.set(traceId.createPreviousId());
        }
    }

    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()를 통해 level이 낮아져 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;

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


}

쓰레드 로컬 동기화 - 적용

package hello.advanced;

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
public class LogTraceConfig {
         @Bean
         public LogTrace logTrace() {
             //return new FieldLogTrace();
             return new ThreadLocalLogTrace();
          }
}

• 로그를 직접 분리해서 확인하면 각각의 쓰레드 별로 로그가 분리 됨

쓰레드 로컬 - 주의사항

• 쓰레드 로컬의 값을 사용 후 제거하지 않고 그냥 두면 WAS(톰캣)처럼 쓰레드 풀을 사용하는 경우, 심각한 문제 발생 함

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 데이
   터도 함께 살아있게 됨

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

결론 : ThreadLocal.remove()를 사용 꼭 제거해야 함, 아니면 A를 조회하고 삭제하지 않으면 B를 조회 하려고 했지만 A가 출력되게 됨!