std::jthread 없이 std::thread만으로도 stop_token을 쓸 수 있나요?

가능합니다. std::stop_source를 만들고 get_token()으로 std::stop_token을 얻은 뒤, 워커 스레드에 전달·폴링하면 됩니다. jthread는 request_stop()과 stop_token을 자동으로 연결해 주는 편의일 뿐, 핵심 API는 stop_source/stop_token입니다.

stop_requested()는 여러 스레드에서 동시에 읽어도 안전한가요?

네. stop_token의 stop_requested()는 const 연산이며 복수 스레드에서 동시에 호출해도 정의된 동작입니다. 협력적 취소 플래그를 공유하는 데 쓰기에 적합합니다.

std::stop_callback을 쓸 때 흔한 실수는 무엇인가요?

콜백이 request_stop() 경로에서 실행될 수 있으므로, 같은 뮤텍스를 잡은 채로 중첩·재진입하면 데드락이 날 수 있습니다. 또한 stop_callback 수명(스택 객체)이 끊기지 않게 해야 콜백 실행이 보장됩니다.

std::condition_variable에 stop_token을 직접 넘길 수 있나요?

기본 std::condition_variable::wait()는 stop_token을 받지 않습니다. C++20의 std::condition_variable_any와 std::stop_token을 함께 쓰거나, wait_for/주기적 깨움 루프로 stop_requested()를 함께 확인하는 방식이 일반적입니다.

C++ stop_token | '중단 토큰' 가이드 | 핵심 개념과 실전 활용

2026년 3월 12일 · 13분 읽기 · 수정 2026년 3월 30일 중급 튜토리얼

이 글의 핵심

C++20 std::stop_token·stop_source·stop_callback과 std::jthread로 협력적 취소를 구현하는 방법입니다. 워커 루프, condition_variable_any 연동, 콜백 수명 주의점을 실전 코드와 함께 설명합니다.

stop_token이란?

std::stop_token 은 C++20에서 도입된 스레드 중단 요청 메커니즘입니다. 스레드에게 중단을 요청하고, 스레드는 주기적으로 중단 요청을 확인하여 안전하게 종료할 수 있습니다. std::jthread와 함께 사용하면 자동으로 통합됩니다.

#include <thread>

// 실행 예제
void worker(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        // 작업
    }
}

std::jthread t(worker);
t.request_stop();  // 중단 요청

왜 필요한가?:

협력적 중단: 스레드가 안전하게 종료할 수 있도록 협력
타입 안전: 전역 플래그 대신 타입 안전한 메커니즘
콜백 지원: 중단 시 자동으로 콜백 실행
표준화: 일관된 중단 패턴

// ❌ 전역 플래그: 타입 불안전, 경쟁 조건
std::atomic<bool> g_stop = false;

void worker() {
    while (!g_stop) {
        // 작업
    }
}

// ✅ stop_token: 타입 안전, 표준화
void worker(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        // 작업
    }
}

stop_token 구성 요소:

std::stop_source: 중단 요청을 발행하는 객체
std::stop_token: 중단 요청을 확인하는 객체 (복사 가능)
std::stop_callback: 중단 시 실행될 콜백 등록

std::stop_source source;
std::stop_token token = source.get_token();

// 중단 요청
source.request_stop();

// 중단 확인
if (token.stop_requested()) {
    // 중단 처리
}

기본 사용

void worker(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        std::cout << "작업 중..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    std::cout << "중단됨" << std::endl;
}

int main() {
    std::jthread t(worker);
    
    std::this_thread::sleep_for(std::chrono::seconds(1));
    t.request_stop();
}

실전 예시

예시 1: 조건 변수

void worker(std::stop_token stoken) {
    std::mutex mtx;
    std::condition_variable_any cv;
    
    while (true) {
        std::unique_lock lock(mtx);
        
        if (cv.wait(lock, stoken, []{ return hasWork(); })) {
            processWork();
        }
        
        if (stoken.stop_requested()) {
            break;
        }
    }
}

예시 2: stop_source

#include <stop_token>

std::stop_source ssource;
std::stop_token stoken = ssource.get_token();

void worker(std::stop_token st) {
    while (!st.stop_requested()) {
        // 작업
    }
}

int main() {
    std::thread t(worker, stoken);
    
    std::this_thread::sleep_for(std::chrono::seconds(1));
    ssource.request_stop();
    
    t.join();
}

예시 3: stop_callback

worker 함수의 구현 예제입니다.

void worker(std::stop_token stoken) {
    std::stop_callback callback(stoken,  {
        std::cout << "중단 콜백" << std::endl;
    });
    
    while (!stoken.stop_requested()) {
        // 작업
    }
}

예시 4: 여러 스레드

int main() {
    std::stop_source ssource;
    std::vector<std::jthread> threads;
    
    for (int i = 0; i < 5; i++) {
        threads.emplace_back([stoken = ssource.get_token(), i]() {
            while (!stoken.stop_requested()) {
                std::cout << "스레드 " << i << std::endl;
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }
        });
    }
    
    std::this_thread::sleep_for(std::chrono::seconds(1));
    ssource.request_stop();  // 모든 스레드 중단
}

stop_callback

C/C++ 예제 코드입니다.

std::stop_token stoken;

std::stop_callback callback(stoken,  {
    std::cout << "중단 요청됨" << std::endl;
});

// request_stop 호출 시 콜백 실행

자주 발생하는 문제

문제 1: 체크 누락

// ❌ 중단 체크 안함
void worker(std::stop_token stoken) {
    while (true) {
        // 중단 불가
    }
}

// ✅ 주기적 체크
void worker(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        // 작업
    }
}

문제 2: 블로킹 연산

// ❌ 블로킹 연산
void worker(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        blockingOperation();  // 중단 불가
    }
}

// ✅ 타임아웃
void worker(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        if (tryOperation(100ms)) {
            // 처리
        }
    }
}

문제 3: 콜백 수명

worker 함수의 구현 예제입니다.

void worker(std::stop_token stoken) {
    int value = 10;
    
    // ❌ 댕글링 레퍼런스
    std::stop_callback callback(stoken, [&value]() {
        std::cout << value;  // 위험
    });
}

// ✅ 값 캡처
std::stop_callback callback(stoken, [value]() {
    std::cout << value;
});

문제 4: 여러 토큰

worker 함수의 구현 예제입니다.

std::stop_source source1, source2;

void worker(std::stop_token st1, std::stop_token st2) {
    while (!st1.stop_requested() && !st2.stop_requested()) {
        // 작업
    }
}

jthread와 통합

C/C++ 예제 코드입니다.

// jthread는 자동으로 stop_token 전달
std::jthread t( {
    while (!stoken.stop_requested()) {
        // 작업
    }
});

t.request_stop();
// 자동 조인

jthread vs thread + stop_token:

특징	std::thread	std::jthread
자동 조인	❌ 수동	✅ 자동
stop_token	❌ 수동 생성	✅ 자동 전달
중단 요청	❌ 수동 구현	✅ `request_stop()`
사용 편의성	복잡	간단

실무 비교:

// ❌ std::thread: 복잡
std::stop_source source;
std::stop_token token = source.get_token();

std::thread t([token]() {
    while (!token.stop_requested()) {
        // 작업
    }
});

source.request_stop();
t.join();  // 수동 조인

// ✅ std::jthread: 간단
std::jthread t( {
    while (!stoken.stop_requested()) {
        // 작업
    }
});

t.request_stop();
// 소멸자에서 자동 조인

jthread 동작 원리:

// jthread의 개념적 구현
class jthread {
    std::stop_source ssource_;
    std::thread thread_;
    
public:
    template<typename F>
    jthread(F&& f) {
        thread_ = std::thread(std::forward<F>(f), ssource_.get_token());
    }
    
    void request_stop() {
        ssource_.request_stop();
    }
    
    ~jthread() {
        if (thread_.joinable()) {
            request_stop();
            thread_.join();
        }
    }
};

실무 패턴

패턴 1: 워커 스레드 풀

class WorkerPool {
    std::vector<std::jthread> workers_;
    
public:
    WorkerPool(size_t numWorkers) {
        for (size_t i = 0; i < numWorkers; ++i) {
            workers_.emplace_back([i](std::stop_token stoken) {
                while (!stoken.stop_requested()) {
                    if (auto task = getTask()) {
                        processTask(*task);
                    } else {
                        std::this_thread::sleep_for(std::chrono::milliseconds(10));
                    }
                }
                std::cout << "워커 " << i << " 종료\n";
            });
        }
    }
    
    // 소멸자에서 자동으로 모든 워커 중단
};

패턴 2: 타임아웃과 중단

template<typename F>
bool runWithTimeout(F&& f, std::chrono::milliseconds timeout) {
    std::stop_source source;
    std::jthread t([&f, stoken = source.get_token()]() {
        f(stoken);
    });
    
    std::this_thread::sleep_for(timeout);
    
    if (t.joinable()) {
        source.request_stop();
        return false;  // 타임아웃
    }
    
    return true;  // 완료
}

// 사용
bool success = runWithTimeout( {
    while (!stoken.stop_requested()) {
        // 작업
    }
}, std::chrono::seconds(5));

패턴 3: 리소스 정리

class ResourceManager {
    std::jthread cleanupThread_;
    
public:
    ResourceManager() {
        cleanupThread_ = std::jthread([this](std::stop_token stoken) {
            std::stop_callback cleanup(stoken, [this]() {
                std::cout << "리소스 정리 중...\n";
                releaseResources();
            });
            
            while (!stoken.stop_requested()) {
                performMaintenance();
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
        });
    }
    
    void releaseResources() {
        // 리소스 정리
    }
    
    void performMaintenance() {
        // 유지보수 작업
    }
};

jthread와 stop_token의 관계 (C++20)

std::jthread는 스레드를 생성할 때 내부 std::stop_source를 하나 두고, 실행 함수가 다음 형태면 std::stop_token을 자동으로 넘깁니다.

void f(std::stop_token)
void f(std::stop_token, Args...) (추가 인자는 그 뒤)

호출 측에서는 request_stop() 으로 협력적 취소를 요청하고, jthread가 소멸될 때 조인을 시도합니다(구현은 자동 조인·중단 요청 정책을 따릅니다). 반면 std::thread는 stop_token과 무관이며, 직접 stop_source를 만들어 람다에 넘겨야 같은 패턴을 흉내 낼 수 있습니다.

stop_source, stop_token, stop_callback 역할 정리

타입	역할
`stop_source`	취소를 발행한다. `request_stop()` 호출 시 연결된 모든 토큰이 “중단됨”으로 바뀐다. 복사 시 같은 상태를 공유하는 소스가 늘어난다.
`stop_token`	읽기 전용 뷰. `stop_requested()`, `stop_possible()` 등으로 확인한다. 가볍게 복사해 여러 스레드·알고리즘에 넘기기 좋다.
`stop_callback`	토큰에 콜백을 등록한다. 등록 시점에 이미 `request_stop()`이 됐다면 즉시 콜백이 실행될 수 있다. RAII: 소멸 시 등록 해제(구현 정의 세부는 표준 참고).

std::stop_source src;
std::stop_token tok = src.get_token();

std::stop_callback cb(tok, [] { std::cout << "stop requested\n"; });

src.request_stop();  // 콜백 실행, 이후 tok.stop_requested() == true

협력적 취소 패턴 (왜 “강제 종료”가 아닌가)

표준 stop_token은 스레드를 즉시 죽이지 않습니다. 워커가 루프마다 stop_requested()를 확인하거나, 블로킹 연산을 중단 가능한 버전(타임아웃, condition_variable_any::wait의 stop_token 오버로드 등)으로 바꿔야 합니다.

권장 패턴:

짧은 단위 작업으로 나누고 매 단위 끝에 취소 확인.
대기는 wait_for / wait_until 또는 condition_variable_any + stop_token 조합.
정리가 필요하면 stop_callback으로 “락 해제·로그 flush” 등을 등록(콜백 안에서는 데드락 나기 쉬운 락을 조심).

실전 워커 스레드

일상 비유로 이해하기: 동시성은 주방에서 여러 요리를 동시에 하는 것과 비슷합니다. 한 명의 요리사(싱글 스레드)가 국을 끓이다가 불을 줄이고, 그 사이에 야채를 썰고, 다시 국을 확인하는 식이죠. 반면 병렬성은 요리사 여러 명(멀티 스레드)이 각자 다른 요리를 동시에 만드는 겁니다.

템플릿

// TaskQueue는 예시 이름입니다. pop_timeout이 없다면 아래 루프 패턴만 참고하세요.
// 실행 예제
void worker_loop(std::stop_token st, TaskQueue& q) {
    using namespace std::chrono_literals;
    while (!st.stop_requested()) {
        std::optional<Task> t = q.pop_timeout(50ms, st);
        if (!t) {
            if (st.stop_requested()) break;
            continue;
        }
        process(*t);
    }
    drain_remaining_work_optional(q);  // 정책에 따라
}

pop_timeout이 없다면 조건 변수 대기에 stop_token을 연동하거나, 짧은 sleep 뒤 stop_requested()를 폴링하는 방식이 현실적인 타협입니다.

C++20에서 함께 쓰는 기능

std::jthread: 자동 stop_token 전달·조인 관례.
std::condition_variable_any: wait 계열에 stop_token을 받는 오버로드가 있어, 깨우기 없이도 취소에 반응하기 쉽습니다.
std::stop_callback: 취소 시 리소스 회수·메트릭 기록.

이들은 “프로세스 kill”이 아니라 애플리케이션 레벨 취소를 표준 형태로 맞추기 위한 도구입니다.

FAQ

Q1: stop_token은 무엇인가요?

A: C++20에서 도입된 스레드 중단 요청 메커니즘입니다. 스레드가 중단 요청을 확인하고 안전하게 종료할 수 있게 합니다.

Q2: 언제 사용해야 하나요?

스레드를 안전하게 중단해야 할 때
취소 가능한 비동기 작업
워커 스레드 풀 구현

Q3: jthread와 어떤 관계인가요?

A: std::jthread는 자동으로 stop_token을 생성하고 전달합니다. 람다의 첫 번째 인자가 stop_token이면 자동으로 전달됩니다.

Q4: 성능 영향은?

A: 매우 가볍고 빠릅니다. stop_requested() 호출은 원자적 플래그 확인만 수행합니다.

Q5: stop_callback은 언제 실행되나요?

A: request_stop() 호출 시 즉시 실행됩니다. 이미 중단 요청이 있었다면 콜백 등록 시 즉시 실행됩니다.

std::stop_source source;
source.request_stop();

std::stop_callback cb(source.get_token(),  {
    std::cout << "즉시 실행\n";
});
// 출력: "즉시 실행"

Q6: 여러 스레드가 같은 stop_token을 공유할 수 있나요?

A: 가능합니다. stop_token은 복사 가능하며, 모든 복사본이 같은 중단 상태를 공유합니다.

C/C++ 예제 코드입니다.

std::stop_source source;
auto token = source.get_token();

std::jthread t1([token]() { /* ....*/ });
std::jthread t2([token]() { /* ....*/ });

source.request_stop();  // 모든 스레드에 중단 요청

Q7: stop_token 학습 리소스는?

“C++20 The Complete Guide” by Nicolai Josuttis
“C++ Concurrency in Action” (2nd Edition) by Anthony Williams
cppreference.com - std::stop_token

관련 글: std::jthread, std::thread, Condition Variable.

한 줄 요약: stop_token은 스레드에게 중단을 요청하고 안전하게 종료할 수 있게 하는 C++20 메커니즘입니다.

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++ stop_token | ‘중단 토큰’ 가이드」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++ stop_token | ‘중단 토큰’ 가이드」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

이 글에서 다루는 키워드 (관련 검색어)

C++, stop_token, jthread, C++20, cancellation 등으로 검색하시면 이 글이 도움이 됩니다.

이 글이 도움이 되셨나요?

여러분의 피드백은 더 나은 콘텐츠를 만드는 데 도움이 됩니다

문제가 있거나 개선 제안이 있으시면 연락처로 알려주세요.

Keyboard Shortcuts

이 글의 핵심

stop_token이란?

기본 사용

실전 예시

예시 1: 조건 변수

예시 2: stop_source

예시 3: stop_callback

예시 4: 여러 스레드

stop_callback

자주 발생하는 문제

문제 1: 체크 누락

문제 2: 블로킹 연산

문제 3: 콜백 수명

문제 4: 여러 토큰

jthread와 통합

실무 패턴

패턴 1: 워커 스레드 풀

패턴 2: 타임아웃과 중단

패턴 3: 리소스 정리

jthread와 stop_token의 관계 (C++20)

stop_source, stop_token, stop_callback 역할 정리

협력적 취소 패턴 (왜 “강제 종료”가 아닌가)

실전 워커 스레드

C++20에서 함께 쓰는 기능

FAQ

Q1: stop_token은 무엇인가요?

Q2: 언제 사용해야 하나요?

Q3: jthread와 어떤 관계인가요?

Q4: 성능 영향은?

Q5: stop_callback은 언제 실행되나요?

Q6: 여러 스레드가 같은 stop_token을 공유할 수 있나요?

Q7: stop_token 학습 리소스는?

같이 보면 좋은 글 (내부 링크)

관련 글

심화 부록: 구현·운영 관점

내부 동작과 핵심 메커니즘

프로덕션 운영 패턴

확장 예시: 엔드투엔드 미니 시나리오

문제 해결(Troubleshooting)

이 글에서 다루는 키워드 (관련 검색어)

이 글이 도움이 되셨나요?