[c++] C++에서의 스레드 풀 사용 예시

07 Dec 2023

C++에서 스레드 풀(thread pool)을 사용하여 병렬 작업을 처리하는 것은 매우 효율적입니다.

헤더 파일 포함

우선, 필요한 헤더 파일을 포함해야 합니다.

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

스레드 풀 클래스 정의

다음으로, 스레드 풀 클래스를 정의합니다.

class ThreadPool {
public:
    ThreadPool(size_t threads);
    
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type>;
    
    ~ThreadPool();
private:
    std::vector< std::thread > workers;
    std::queue< std::function<void()> > tasks;
    
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

ThreadPool 생성자

스레드 풀 생성자에서는 워커 스레드를 생성합니다.

ThreadPool::ThreadPool(size_t threads) : stop(false) {
    for(size_t i = 0; i<threads; ++i)
        workers.emplace_back(
            [this] {
                for(;;) {
                    std::function<void()> task;
                    
                    /*
                     * task 취득
                     */
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock,
                            [this]{ return this->stop || !this->tasks.empty(); });
                        if(this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    
                    task();
                }
            }
        );
}

작업 추가

enqueue 함수를 사용하여 스레드 풀에 작업을 추가할 수 있습니다.

template<class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args)
    -> std::future<typename std::result_of<F(Args...)>::type> {
        
    using return_type = typename std::result_of<F(Args...)>::type;
    
    auto task = std::make_shared<std::packaged_task<return_type()>>(
        std::bind(std::forward<F>(f), std::forward<Args>(args)...)
    );
    
    std::future<return_type> res = task->get_future();
    
    {
        std::unique_lock<std::mutex> lock(queue_mutex);

        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");

        tasks.emplace([task](){ (*task)(); });
    }
    condition.notify_one();
    return res;
}

스레드 풀 소멸자

스레드 풀이 소멸될 때, 모든 작업이 완료될 때까지 기다린 후 스레드를 정리합니다.

ThreadPool::~ThreadPool() {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for(std::thread &worker: workers)
        worker.join();
}

위의 코드 예시는 C++11 이상의 표준에 따라 작성되었습니다. 스레드 풀은 병렬 작업을 효율적으로 처리하기 위한 강력한 도구로, 적절히 사용하면 성능을 극대화할 수 있습니다.

참고 자료

C++ Thread Support in Standard Library: https://en.cppreference.com/w/cpp/thread
C++ Concurrency in Action by Anthony Williams