ThreadPool.h

浏览该文件的文档.

// Copyright 2024 libsese
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include "sese/Config.h"
#include "sese/util/Noncopyable.h"
#include "sese/thread/Thread.h"
 
#include <atomic>
#include <condition_variable>
#include <future>
#include <memory>
#include <queue>
#include <string>
#include <vector>
 
namespace sese {
 
class  ThreadPool : public Noncopyable {
public:
    using Ptr = std::unique_ptr<ThreadPool>;
 
    explicit ThreadPool(std::string thread_pool_name = THREAD_DEFAULT_NAME, size_t threads = 4);
    ~ThreadPool() override;
 
public:
    void postTask(const std::function<void()> &task);
 
    void postTask(const std::vector<std::function<void()>> &tasks);
 
    template<typename FUNCTION, typename... ARGS>
    void postTaskEx(FUNCTION &&f, ARGS &&...args) {
        auto bound_function = [func = std::forward<FUNCTION>(f), args = std::make_tuple(std::forward<ARGS>(args)...)]() mutable {
            std::apply(std::move(func), std::move(args));
        };
        this->postTask(std::move(bound_function));
    }
 
    template<class RETURN_TYPE>
    std::shared_future<RETURN_TYPE> postTask(const std::function<RETURN_TYPE()> &tasks);
 
    void shutdown();
 
    [[nodiscard]] size_t size() noexcept;
    [[nodiscard]] bool empty() noexcept;
    [[nodiscard]] const std::string &getName() const { return name; }
    [[nodiscard]] size_t getThreads() const { return threads; }
 
private:
    std::string name;
    size_t threads = 0;
    std::vector<Thread *> threadGroup;
 
    struct RuntimeData {
        std::mutex mutex;
        std::condition_variable conditionVariable;
        std::queue<std::function<void()>> tasks;
        std::atomic<bool> isShutdown{false};
    };
    std::shared_ptr<RuntimeData> data;
};
 
} // namespace sese
 
// GCOVR_EXCL_START
 
template<class RETURN_TYPE>
std::shared_future<RETURN_TYPE> sese::ThreadPool::postTask(const std::function<RETURN_TYPE()> &task) {
    using TaskPtr = std::shared_ptr<std::packaged_task<RETURN_TYPE()>>;
    TaskPtr packaged_task = std::make_shared<std::packaged_task<RETURN_TYPE()>>(task);
    std::shared_future<RETURN_TYPE> future(packaged_task->get_future());
 
    this->postTask([task = std::move(packaged_task)]() mutable {
        (*task)();
    });
 
    return future;
}
 
// GCOVR_EXCL_STOP