C++ packaged_task | "패키지 태스크" 가이드
이 글의 핵심
std::packaged_task 는 함수나 호출 가능 객체를 래핑하여 std::future로 결과를 받을 수 있게 하는 C++11 기능입니다. std::async와 달리 수동으로 실행 시점을 제어할 수 있어, 작업 큐나 스레드 풀에서 유용합니다.
packaged_task란?
std::packaged_task 는 함수나 호출 가능 객체를 래핑하여 std::future로 결과를 받을 수 있게 하는 C++11 기능입니다. std::async와 달리 수동으로 실행 시점을 제어할 수 있어, 작업 큐나 스레드 풀에서 유용합니다.
#include <future>
std::packaged_task<int(int)> task([](int x) {
return x * x;
});
std::future<int> future = task.get_future();
task(10); // 실행
int result = future.get(); // 100왜 필요한가?:
- 실행 제어: 언제 실행할지 직접 결정
- 작업 큐: 작업을 큐에 저장 후 나중에 실행
- 스레드 풀: 워커 스레드에 작업 분배
- 예외 전파: 예외를
future로 전달
// std::async: 즉시 실행 (또는 지연)
auto f1 = std::async([] { return 42; });
// packaged_task: 수동 실행
std::packaged_task<int()> task([] { return 42; });
auto f2 = task.get_future();
// 원하는 시점에 실행
task();기본 사용
// 함수 시그니처 지정
std::packaged_task<int(int, int)> task([](int a, int b) {
return a + b;
});
auto future = task.get_future();
task(3, 4); // 실행
int result = future.get(); // 7실전 예시
예시 1: 스레드에서 실행
#include <thread>
#include <future>
int compute(int x) {
std::this_thread::sleep_for(std::chrono::seconds(1));
return x * x;
}
int main() {
std::packaged_task<int(int)> task(compute);
std::future<int> future = task.get_future();
std::thread t(std::move(task), 10);
std::cout << "계산 중..." << std::endl;
int result = future.get();
std::cout << "결과: " << result << std::endl;
t.join();
}예시 2: 작업 큐
#include <queue>
#include <mutex>
class TaskQueue {
std::queue<std::packaged_task<void()>> tasks;
std::mutex mtx;
public:
template<typename F>
auto enqueue(F&& f) -> std::future<decltype(f())> {
using ReturnType = decltype(f());
std::packaged_task<ReturnType()> task(std::forward<F>(f));
auto future = task.get_future();
{
std::lock_guard<std::mutex> lock(mtx);
tasks.push(std::move(task));
}
return future;
}
void process() {
std::packaged_task<void()> task;
{
std::lock_guard<std::mutex> lock(mtx);
if (tasks.empty()) return;
task = std::move(tasks.front());
tasks.pop();
}
task();
}
};예시 3: 예외 처리
std::packaged_task<int()> task([] {
throw std::runtime_error("에러");
return 42;
});
auto future = task.get_future();
task();
try {
int result = future.get(); // 예외 재던지기
} catch (const std::exception& e) {
std::cout << "예외: " << e.what() << std::endl;
}예시 4: 재사용
std::packaged_task<int(int)> task([](int x) {
return x * 2;
});
auto f1 = task.get_future();
task(10);
int r1 = f1.get(); // 20
// ❌ 재사용 불가
// task(20); // 에러
// ✅ 새로 생성
task = std::packaged_task<int(int)>([](int x) {
return x * 2;
});async vs packaged_task
// std::async: 자동 실행
auto f1 = std::async([] { return 42; });
// packaged_task: 수동 실행
std::packaged_task<int()> task([] { return 42; });
auto f2 = task.get_future();
task(); // 명시적 실행비교표:
| 특징 | std::async | std::packaged_task |
|---|---|---|
| 실행 시점 | 자동 (즉시 또는 지연) | 수동 (명시적 호출) |
| 스레드 생성 | 자동 | 수동 |
| 사용 편의성 | 간단 | 복잡 |
| 제어 수준 | 낮음 | 높음 |
| 주 용도 | 간단한 비동기 작업 | 작업 큐, 스레드 풀 |
실무 선택 가이드:
int expensiveComputation(); // 어딘가에 정의되어 있다고 가정
// ✅ std::async 사용
// - 간단한 비동기 작업
// - 스레드 관리 불필요
auto result = std::async([] {
return expensiveComputation();
});
// ✅ packaged_task 사용
// - 작업 큐에 저장
// - 실행 시점 제어
// - 스레드 풀 구현
std::packaged_task<int()> task(expensiveComputation);
taskQueue.push(std::move(task));
// 나중에 워커 스레드가 실행자주 발생하는 문제
문제 1: 실행 누락
std::packaged_task<int()> task([] { return 42; });
auto future = task.get_future();
// ❌ task 실행 안함
// int result = future.get(); // 영원히 대기
// ✅ task 실행
task();
int result = future.get();문제 2: 이동 전용
std::packaged_task<int()> task([] { return 42; });
// ❌ 복사 불가
// auto task2 = task;
// ✅ 이동
auto task2 = std::move(task);문제 3: get_future 여러 번
std::packaged_task<int()> task([] { return 42; });
auto f1 = task.get_future();
// auto f2 = task.get_future(); // 에러
// get_future는 한 번만문제 4: 스레드 이동
std::packaged_task<int()> task([] { return 42; });
auto future = task.get_future();
// ✅ 이동으로 전달
std::thread t(std::move(task));
t.join();
int result = future.get();실무 패턴
패턴 1: 간단한 스레드 풀
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
class ThreadPool {
std::vector<std::thread> workers_;
std::queue<std::packaged_task<void()>> tasks_;
std::mutex mtx_;
std::condition_variable cv_;
bool stop_ = false;
public:
ThreadPool(size_t numThreads) {
for (size_t i = 0; i < numThreads; ++i) {
workers_.emplace_back([this]() {
while (true) {
std::packaged_task<void()> task;
{
std::unique_lock<std::mutex> lock(mtx_);
cv_.wait(lock, [this]() {
return stop_ || !tasks_.empty();
});
if (stop_ && tasks_.empty()) return;
task = std::move(tasks_.front());
tasks_.pop();
}
task();
}
});
}
}
template<typename F>
auto submit(F&& f) -> std::future<decltype(f())> {
using ReturnType = decltype(f());
std::packaged_task<ReturnType()> task(std::forward<F>(f));
auto future = task.get_future();
{
std::lock_guard<std::mutex> lock(mtx_);
tasks_.push(std::move(task));
}
cv_.notify_one();
return future;
}
~ThreadPool() {
{
std::lock_guard<std::mutex> lock(mtx_);
stop_ = true;
}
cv_.notify_all();
for (auto& worker : workers_) {
worker.join();
}
}
};
// 사용
ThreadPool pool(4);
auto f1 = pool.submit([] { return 42; });
auto f2 = pool.submit([] { return 100; });
std::cout << f1.get() + f2.get() << '\n'; // 142패턴 2: 타임아웃 작업
template<typename F>
auto runWithTimeout(F&& f, std::chrono::milliseconds timeout)
-> std::optional<decltype(f())> {
std::packaged_task<decltype(f())()> task(std::forward<F>(f));
auto future = task.get_future();
std::thread t(std::move(task));
t.detach();
if (future.wait_for(timeout) == std::future_status::ready) {
return future.get();
}
return std::nullopt; // 타임아웃
}
// 사용
auto result = runWithTimeout([] {
std::this_thread::sleep_for(std::chrono::seconds(2));
return 42;
}, std::chrono::seconds(1));
if (result) {
std::cout << "결과: " << *result << '\n';
} else {
std::cout << "타임아웃\n";
}패턴 3: 작업 취소
class CancellableTask {
std::packaged_task<int()> task_;
std::atomic<bool> cancelled_{false};
public:
CancellableTask(std::function<int()> f)
: task_([this, f]() {
if (cancelled_) {
throw std::runtime_error("Cancelled");
}
return f();
}) {}
std::future<int> getFuture() {
return task_.get_future();
}
void run() {
task_();
}
void cancel() {
cancelled_ = true;
}
};std::promise / std::future와의 관계
비동기 결과를 연결하는 표준 구성은 크게 세 가지입니다.
| 구성 요소 | 역할 |
|---|---|
std::promise<T> | 수동으로 값/예외를 future 쪽에 설정 (set_value, set_exception) |
std::packaged_task | 호출 가능 객체 한 번 실행의 결과를 자동으로 연결된 future에 기록 |
std::async | 함수 실행과 스레딩 정책을 묶은 편의 API (구현에 따라 스레드 풀 재사용 여부는 비표준) |
packaged_task는 내부적으로 공유 상태를 두고 get_future()로 소비자 쪽 future를 내줍니다. 반면 promise는 생산자가 직접 “아직 계산 중”인 값을 채워 넣을 때 쓰입니다. 작업 큐에서는 “실행 본체”를 packaged_task로 감싸 두면, 워커가 operator()만 호출하면 되므로 연결 코드가 짧아집니다.
비동기 작업 패턴 정리
- fire-and-forget: 결과가 필요 없으면
std::thread+ 조인 정책만 정하고 끝낼 수 있지만, 예외 전파가 어렵습니다. 결과·오류를 상위로 올리려면packaged_task/async/promise중 하나를 씁니다. - 결과 필수:
future.get()한 번으로 값 또는 예외를 받습니다. 여러 번 구독하려면shared_future를 고려합니다. - 백프레셔·큐 길이 제한: 생산자가
submit만 하고 소비가 못 따라가면 메모리가 불어납니다. 큐 상한, 블로킹 큐, 또는 거부 정책을 함께 설계합니다.
실전 예제 보강: 에러 처리 전략
future.get(): 작업 안에서 던진 예외는 저장되었다가get()시점에 재던집니다. 따라서 호출 스레드에서 try/catch를 두는 것이 일반적입니다.- 타임아웃:
wait_for/wait_until로 무한 대기를 피하고, 실패 시 로깅·재시도·취소 플래그를 택합니다. 위runWithTimeout은 데모이며, 실제로는 취소 협력(주기적 플래그 확인)이 없으면 스레드가 계속 돌 수 있어 프로덕션에서는 주의가 필요합니다. std::current_exception: 저수준에서promise에 예외를 넣을 때 유용하지만, 대부분은packaged_task가 자동 처리하면 충분합니다.
std::packaged_task<int()> task([] {
if (!validateInput()) {
throw std::invalid_argument("bad input");
}
return compute();
});
auto fut = task.get_future();
std::thread(std::move(task)).detach();
try {
use(fut.get());
} catch (const std::exception& e) {
log_error(e.what());
}FAQ
Q1: packaged_task는 무엇인가요?
A: 함수나 호출 가능 객체를 래핑하여 std::future로 결과를 받을 수 있게 하는 클래스입니다. 수동으로 실행 시점을 제어할 수 있습니다.
Q2: std::async와 차이는?
A:
- std::async: 자동 실행 (즉시 또는 지연), 스레드 자동 생성
- packaged_task: 수동 실행, 스레드 수동 생성
// async: 간단
auto f = std::async(compute);
// packaged_task: 제어
std::packaged_task<int()> task(compute);
auto f = task.get_future();
std::thread t(std::move(task));
t.join();Q3: packaged_task를 재사용할 수 있나요?
A: 불가능합니다. 한 번 실행하면 새로 생성해야 합니다.
std::packaged_task<int()> task([] { return 42; });
task();
// task(); // 에러
// 새로 생성
task = std::packaged_task<int()>([] { return 42; });Q4: packaged_task는 복사할 수 있나요?
A: 불가능합니다. 이동만 가능합니다.
std::packaged_task<int()> task1([] { return 42; });
// auto task2 = task1; // 에러
auto task2 = std::move(task1); // OKQ5: 언제 사용해야 하나요?
A:
- 작업 큐 구현
- 스레드 풀 구현
- 실행 시점을 직접 제어해야 할 때
- 작업을 저장 후 나중에 실행해야 할 때
Q6: get_future()를 여러 번 호출할 수 있나요?
A: 불가능합니다. get_future()는 한 번만 호출할 수 있습니다.
std::packaged_task<int()> task([] { return 42; });
auto f1 = task.get_future();
// auto f2 = task.get_future(); // 에러Q7: 예외는 어떻게 처리되나요?
A: 작업 실행 중 발생한 예외는 future에 저장되며, future.get() 호출 시 재던져집니다.
std::packaged_task<int()> task([] {
throw std::runtime_error("Error");
return 42;
});
auto f = task.get_future();
task();
try {
f.get(); // 예외 재던지기
} catch (const std::exception& e) {
std::cout << e.what() << '\n';
}Q8: packaged_task 학습 리소스는?
A:
- “C++ Concurrency in Action” by Anthony Williams
- “Effective Modern C++” by Scott Meyers
- cppreference.com - std::packaged_task
관련 글: std::future, std::async, std::promise.
한 줄 요약: packaged_task는 함수를 래핑하여 future로 결과를 받을 수 있게 하며, 수동 실행 제어가 가능합니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ async & launch | “비동기 실행” 가이드
- C++ shared_future | 여러 스레드에서 future 결과 공유
- C++ future와 promise | “비동기” 가이드
관련 글
- C++ async & launch |
- C++ shared_future | 여러 스레드에서 future 결과 공유
- C++ future와 promise |
- C++ Atomic Operations |
- C++ Attributes |