C++ 使用单独的线程执行c++；

我有一个

DataClass

类，它有一些数据需要

生成

和

清理

。 我不知道在程序执行的什么时候会有新的数据，我试图使用多个线程来允许主线程在处理数据时继续运行

这是

数据类

：

class DataClass
{
public:
    unsigned int state{0};

    
    void Generate()
    {
        using namespace std::chrono_literals;
        std::this_thread::sleep_for(3s);
        state = 1;
    }

    void Clean()
    {
        using namespace std::chrono_literals;
        std::this_thread::sleep_for(1s);
        state = 2;
    }
};

我将每个DataClass对象分成两个

std:：deque

，一个包含需要生成的对象，另一个包含需要清理的对象

std::deque<DataClass*> dataToGenerate;
std::deque<DataClass*> dataToClean;

（比较干净的一个类似）

在main函数中，我为这两个函数启动了两个线程。 但是线程会立即停止，因为两个列表都是空的，所以每次我都需要创建一个新的列表。我已经研究了条件变量，但我无法让它们正常工作，因为我在网上找到的所有示例都与此场景不同。 据我所知，如果我使用while（！dataToGenerate.empty（）），我将在没有任何实际原因的情况下执行始终填充线程的那一行，因此我不想使用此方法

是否有一种方法可以暂停每个线程，直到列表不再为空，然后启动线程？

这个问题的难度似乎相当高。我已经阅读了关于任务队列和锁定的内容，并根据这些内容重新表述了您的解决方案

特别是，您会发现这与生产者/消费者模式非常接近

队列 让我们从一个最小的通用锁定队列开始：

template <typename T>
struct Queue {
    Queue(size_t max = 50) : _max(max) {}

    size_t enqueue(T v) {
        std::unique_lock lk(_mx);
        _cond.wait(lk, [this] { return (_max == 0) || (_storage.size() < _max); });

        _storage.push_back(std::move(v));
        _cond.notify_one();
        return _storage.size(); // NOTE: very racy load indicator
    }

    template <typename Duration>
    std::optional<T> dequeue(Duration d) {
        std::unique_lock lk(_mx);

        if (_cond.wait_for(lk, d, [this] { return !_storage.empty(); })) {
            auto top = std::move(_storage.front());

            _storage.pop_front();
            _cond.notify_one();

            return top;
        }

        return std::nullopt;
    }

  private:
    size_t _max;
    mutable std::mutex _mx;
    mutable std::condition_variable _cond;
    std::deque<T> _storage;
};

现在让我们制作一个包含4个生成器线程和2个清理线程的程序，监视2个queus（gentask和cleanstasks）

印刷品

Worker #2 Generate: 1
Worker #1 Generate: 2
Worker #3 Generate: 3
Worker #4 Generate: 4
Worker #2 Generate: 5
Worker #5 Clean: 1
Load at createWork(42) is ~6
Worker #1 Generate: 6
Worker #6 Clean: 2
Worker #3 Generate: 7
Worker #4 Generate: 8
Worker #5 Done: 1
Worker #5 Clean: 3
Worker #6 Done: 2
Worker #6 Clean: 4
Worker #5 Done: 3
Worker #6 Done: 4
Load at createWork(43) is ~4
Worker #2 Generate: 9
Worker #5 Clean: 5
Worker #1 Generate: 10
Worker #6 Clean: 6
Worker #3 Generate: 42
Worker #4 Generate: 43
Worker #5 Done: 5
Worker #5 Clean: 7
Worker #6 Done: 6
Worker #6 Clean: 8
Worker #5 Done: 7
Worker #6 Done: 8
Worker #5 Clean: 9
Worker #6 Clean: 10
Initiating shutdown
Worker #2 Exit generate_worker
Worker #5 Done: 9
Worker #5 Clean: 42
Worker #1 Exit generate_worker
Worker #6 Done: 10
Worker #6 Clean: 43
Worker #3 Exit generate_worker
Worker #4 Exit generate_worker
Worker #5 Done: 42
Worker #6 Done: 43
Worker #5 Exit clean_worker
Worker #6 Exit clean_worker
Unfinished generate/clean tasks: 0/0

#include <mutex>
#include <condition_variable>
#include <deque>
#include <optional>

template <typename T>
struct Queue {
    Queue(size_t max = 50) : _max(max) {}

    size_t enqueue(T v) {
        std::unique_lock lk(_mx);
        _cond.wait(lk, [this] { return (_max == 0) || (_storage.size() < _max); });

        _storage.push_back(std::move(v));
        _cond.notify_one();
        return _storage.size(); // NOTE: very racy load indicator
    }

    template <typename Duration>
    std::optional<T> dequeue(Duration d) {
        std::unique_lock lk(_mx);

        if (_cond.wait_for(lk, d, [this] { return !_storage.empty(); })) {
            auto top = std::move(_storage.front());

            _storage.pop_front();
            _cond.notify_one();

            return top;
        }

        return std::nullopt;
    }

    size_t size() const { // racy in multi-thread situations
        std::unique_lock lk(_mx);
        return _storage.size();
    }

  private:
    size_t _max;
    mutable std::mutex _mx;
    mutable std::condition_variable _cond;
    std::deque<T> _storage;
};

#include <chrono>
#include <thread>
#include <iostream>
#include <list>
#include <atomic>
using namespace std::chrono_literals;
static inline auto sleep_for = [](auto d) { std::this_thread::sleep_for(d); };

struct DataClass {
    int id;
    unsigned int state{ 0 };

    DataClass(int id) : id(id) {}
    //DataClass(DataClass&&) = default;
    //DataClass& operator=(DataClass&&) = default;
    //DataClass(DataClass const&) = delete;

    void Generate() { sleep_for(3s); state = 1; }
    void Clean()    { sleep_for(1s); state = 2; }
};

struct Program {
    Program() {
        auto worker_id = 1;
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { clean_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { clean_worker(id); });
    }

    size_t createWork(DataClass task) {
        return genTasks.enqueue(std::move(task));
    }

    ~Program() {
        _shutdown = true;
        for (auto& th: _workers) 
            if (th.joinable()) th.join();
        std::cout << "Unfinished generate/clean tasks: " << genTasks.size() << "/" << cleanTasks.size() << "\n";
    }

  private:
    Queue<DataClass> genTasks, cleanTasks;
    std::atomic_bool _shutdown { false };
    std::list<std::thread> _workers;

    void generate_worker(int worker_id) {
        while (!_shutdown) {
            while (auto task = genTasks.dequeue(1s)) {
                std::cout << "Worker #" << worker_id << " Generate: " << task->id << std::endl;
                task->Generate();
                cleanTasks.enqueue(std::move(*task));
            }
        }
        std::cout << "Worker #" << worker_id << " Exit generate_worker" << std::endl;
    }

    void clean_worker(int worker_id) {
        while (!_shutdown) {
            while (auto task = cleanTasks.dequeue(1s)) {
                std::cout << "Worker #" << worker_id << " Clean: " << task->id << std::endl;
                task->Clean();
                std::cout << "Worker #" << worker_id << " Done: " << task->id << std::endl;
            }
        }
        std::cout << "Worker #" << worker_id << " Exit clean_worker" << std::endl;
    }
};

int main() {
    Program p; 

    for (auto i : {1,2,3,4,5,6,7,8,9,10}) {
        sleep_for((rand()%100) * 1ms);
        p.createWork(i);
    }

    sleep_for(2.5s);
    std::cout << "Load at createWork(42) is ~" << p.createWork(42) << std::endl;
    sleep_for(2.5s);
    std::cout << "Load at createWork(43) is ~" << p.createWork(43) << std::endl;

    sleep_for(4s);
    std::cout << "Initiating shutdown\n";
    // Program destructor performs shutdown
}

完整列表

Worker #2 Generate: 1
Worker #1 Generate: 2
Worker #3 Generate: 3
Worker #4 Generate: 4
Worker #2 Generate: 5
Worker #5 Clean: 1
Load at createWork(42) is ~6
Worker #1 Generate: 6
Worker #6 Clean: 2
Worker #3 Generate: 7
Worker #4 Generate: 8
Worker #5 Done: 1
Worker #5 Clean: 3
Worker #6 Done: 2
Worker #6 Clean: 4
Worker #5 Done: 3
Worker #6 Done: 4
Load at createWork(43) is ~4
Worker #2 Generate: 9
Worker #5 Clean: 5
Worker #1 Generate: 10
Worker #6 Clean: 6
Worker #3 Generate: 42
Worker #4 Generate: 43
Worker #5 Done: 5
Worker #5 Clean: 7
Worker #6 Done: 6
Worker #6 Clean: 8
Worker #5 Done: 7
Worker #6 Done: 8
Worker #5 Clean: 9
Worker #6 Clean: 10
Initiating shutdown
Worker #2 Exit generate_worker
Worker #5 Done: 9
Worker #5 Clean: 42
Worker #1 Exit generate_worker
Worker #6 Done: 10
Worker #6 Clean: 43
Worker #3 Exit generate_worker
Worker #4 Exit generate_worker
Worker #5 Done: 42
Worker #6 Done: 43
Worker #5 Exit clean_worker
Worker #6 Exit clean_worker
Unfinished generate/clean tasks: 0/0

#include <mutex>
#include <condition_variable>
#include <deque>
#include <optional>

template <typename T>
struct Queue {
    Queue(size_t max = 50) : _max(max) {}

    size_t enqueue(T v) {
        std::unique_lock lk(_mx);
        _cond.wait(lk, [this] { return (_max == 0) || (_storage.size() < _max); });

        _storage.push_back(std::move(v));
        _cond.notify_one();
        return _storage.size(); // NOTE: very racy load indicator
    }

    template <typename Duration>
    std::optional<T> dequeue(Duration d) {
        std::unique_lock lk(_mx);

        if (_cond.wait_for(lk, d, [this] { return !_storage.empty(); })) {
            auto top = std::move(_storage.front());

            _storage.pop_front();
            _cond.notify_one();

            return top;
        }

        return std::nullopt;
    }

    size_t size() const { // racy in multi-thread situations
        std::unique_lock lk(_mx);
        return _storage.size();
    }

  private:
    size_t _max;
    mutable std::mutex _mx;
    mutable std::condition_variable _cond;
    std::deque<T> _storage;
};

#include <chrono>
#include <thread>
#include <iostream>
#include <list>
#include <atomic>
using namespace std::chrono_literals;
static inline auto sleep_for = [](auto d) { std::this_thread::sleep_for(d); };

struct DataClass {
    int id;
    unsigned int state{ 0 };

    DataClass(int id) : id(id) {}
    //DataClass(DataClass&&) = default;
    //DataClass& operator=(DataClass&&) = default;
    //DataClass(DataClass const&) = delete;

    void Generate() { sleep_for(3s); state = 1; }
    void Clean()    { sleep_for(1s); state = 2; }
};

struct Program {
    Program() {
        auto worker_id = 1;
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { clean_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { clean_worker(id); });
    }

    size_t createWork(DataClass task) {
        return genTasks.enqueue(std::move(task));
    }

    ~Program() {
        _shutdown = true;
        for (auto& th: _workers) 
            if (th.joinable()) th.join();
        std::cout << "Unfinished generate/clean tasks: " << genTasks.size() << "/" << cleanTasks.size() << "\n";
    }

  private:
    Queue<DataClass> genTasks, cleanTasks;
    std::atomic_bool _shutdown { false };
    std::list<std::thread> _workers;

    void generate_worker(int worker_id) {
        while (!_shutdown) {
            while (auto task = genTasks.dequeue(1s)) {
                std::cout << "Worker #" << worker_id << " Generate: " << task->id << std::endl;
                task->Generate();
                cleanTasks.enqueue(std::move(*task));
            }
        }
        std::cout << "Worker #" << worker_id << " Exit generate_worker" << std::endl;
    }

    void clean_worker(int worker_id) {
        while (!_shutdown) {
            while (auto task = cleanTasks.dequeue(1s)) {
                std::cout << "Worker #" << worker_id << " Clean: " << task->id << std::endl;
                task->Clean();
                std::cout << "Worker #" << worker_id << " Done: " << task->id << std::endl;
            }
        }
        std::cout << "Worker #" << worker_id << " Exit clean_worker" << std::endl;
    }
};

int main() {
    Program p; 

    for (auto i : {1,2,3,4,5,6,7,8,9,10}) {
        sleep_for((rand()%100) * 1ms);
        p.createWork(i);
    }

    sleep_for(2.5s);
    std::cout << "Load at createWork(42) is ~" << p.createWork(42) << std::endl;
    sleep_for(2.5s);
    std::cout << "Load at createWork(43) is ~" << p.createWork(43) << std::endl;

    sleep_for(4s);
    std::cout << "Initiating shutdown\n";
    // Program destructor performs shutdown
}

#包括
#包括
#包括
#包括
模板
结构队列{
队列（大小\u t max=50）：\u max（max）{
排队人数（t v）{
std：：唯一锁lk（_mx）；
_cond.wait（lk，[this]{return（_max==0）| |（_storage.size（）<_max）；}）；
_存储。推回（标准：：移动（v））；
_第二，通知某人；
return _storage.size（）；//注意：非常快速的负载指示器
}
模板
std：：可选出列（持续时间d）{
std：：唯一锁lk（_mx）；
if（_cond.wait_for（lk，d，[this]{return！_storage.empty（）；}））{
auto-top=std:：move（_storage.front（））；
_存储。pop_front（）；
_第二，通知某人；
返回顶部；
}
返回std：：nullopt；
}
多线程情况下的size\u t size（）常量{//racy
std：：唯一锁lk（_mx）；
返回_storage.size（）；
}
私人：
最大尺寸；
可变std:：mutex mx；
可变标准：：条件变量条件；
std：：deque_存储；
};
#包括
#包括
#包括
#包括
#包括
使用名称空间std:：chrono_文本；
静态内联自动休眠_for=[]（自动d）{std:：this_thread:：sleep_for（d）；}；
结构数据类{
int-id；
无符号整数状态{0}；
数据类（int-id）：id（id）{}
//DataClass（DataClass&&）=默认值；
//DataClass&operator=（DataClass&&）=默认值；
//数据类（数据类常量&）=删除；
void Generate（）{sleep_for（3s）；state=1；}
void Clean（）{sleep_for（1s）；state=2；}
};
结构程序{
程序（）{
自动工作者id=1；
_emplace_back（[this，id=worker_id++]{generate_worker（id）；}）；
_emplace_back（[this，id=worker_id++]{generate_worker（id）；}）；
_emplace_back（[this，id=worker_id++]{generate_worker（id）；}）；
_emplace_back（[this，id=worker_id++]{generate_worker（id）；}）；
_workers.emplace_back（[this，id=worker_id++]{clean_worker（id）；}）；
_workers.emplace_back（[this，id=worker_id++]{clean_worker（id）；}）；
}
大小\u t createWork（数据类任务）{
返回genTasks.enqueue（std:：move（task））；
}
~Program（）{
_关机=真；
适用于（汽车和th:_工人）
如果（th.joinable（））th.join（）；
std：：cout这个问题的难度似乎很高。我已经阅读了关于任务队列和锁定的内容，并根据这些内容重新表述了您的解决方案

特别是，您会发现这与生产者/消费者模式非常接近

队列
让我们从一个最小的通用锁定队列开始：

template <typename T>
struct Queue {
    Queue(size_t max = 50) : _max(max) {}

    size_t enqueue(T v) {
        std::unique_lock lk(_mx);
        _cond.wait(lk, [this] { return (_max == 0) || (_storage.size() < _max); });

        _storage.push_back(std::move(v));
        _cond.notify_one();
        return _storage.size(); // NOTE: very racy load indicator
    }

    template <typename Duration>
    std::optional<T> dequeue(Duration d) {
        std::unique_lock lk(_mx);

        if (_cond.wait_for(lk, d, [this] { return !_storage.empty(); })) {
            auto top = std::move(_storage.front());

            _storage.pop_front();
            _cond.notify_one();

            return top;
        }

        return std::nullopt;
    }

  private:
    size_t _max;
    mutable std::mutex _mx;
    mutable std::condition_variable _cond;
    std::deque<T> _storage;
};

现在让我们制作一个包含4个生成器线程和2个清理线程的程序，监视2个queus（gentask和cleanstasks）

印刷品


Worker #2 Generate: 1
Worker #1 Generate: 2
Worker #3 Generate: 3
Worker #4 Generate: 4
Worker #2 Generate: 5
Worker #5 Clean: 1
Load at createWork(42) is ~6
Worker #1 Generate: 6
Worker #6 Clean: 2
Worker #3 Generate: 7
Worker #4 Generate: 8
Worker #5 Done: 1
Worker #5 Clean: 3
Worker #6 Done: 2
Worker #6 Clean: 4
Worker #5 Done: 3
Worker #6 Done: 4
Load at createWork(43) is ~4
Worker #2 Generate: 9
Worker #5 Clean: 5
Worker #1 Generate: 10
Worker #6 Clean: 6
Worker #3 Generate: 42
Worker #4 Generate: 43
Worker #5 Done: 5
Worker #5 Clean: 7
Worker #6 Done: 6
Worker #6 Clean: 8
Worker #5 Done: 7
Worker #6 Done: 8
Worker #5 Clean: 9
Worker #6 Clean: 10
Initiating shutdown
Worker #2 Exit generate_worker
Worker #5 Done: 9
Worker #5 Clean: 42
Worker #1 Exit generate_worker
Worker #6 Done: 10
Worker #6 Clean: 43
Worker #3 Exit generate_worker
Worker #4 Exit generate_worker
Worker #5 Done: 42
Worker #6 Done: 43
Worker #5 Exit clean_worker
Worker #6 Exit clean_worker
Unfinished generate/clean tasks: 0/0

#include <mutex>
#include <condition_variable>
#include <deque>
#include <optional>

template <typename T>
struct Queue {
    Queue(size_t max = 50) : _max(max) {}

    size_t enqueue(T v) {
        std::unique_lock lk(_mx);
        _cond.wait(lk, [this] { return (_max == 0) || (_storage.size() < _max); });

        _storage.push_back(std::move(v));
        _cond.notify_one();
        return _storage.size(); // NOTE: very racy load indicator
    }

    template <typename Duration>
    std::optional<T> dequeue(Duration d) {
        std::unique_lock lk(_mx);

        if (_cond.wait_for(lk, d, [this] { return !_storage.empty(); })) {
            auto top = std::move(_storage.front());

            _storage.pop_front();
            _cond.notify_one();

            return top;
        }

        return std::nullopt;
    }

    size_t size() const { // racy in multi-thread situations
        std::unique_lock lk(_mx);
        return _storage.size();
    }

  private:
    size_t _max;
    mutable std::mutex _mx;
    mutable std::condition_variable _cond;
    std::deque<T> _storage;
};

#include <chrono>
#include <thread>
#include <iostream>
#include <list>
#include <atomic>
using namespace std::chrono_literals;
static inline auto sleep_for = [](auto d) { std::this_thread::sleep_for(d); };

struct DataClass {
    int id;
    unsigned int state{ 0 };

    DataClass(int id) : id(id) {}
    //DataClass(DataClass&&) = default;
    //DataClass& operator=(DataClass&&) = default;
    //DataClass(DataClass const&) = delete;

    void Generate() { sleep_for(3s); state = 1; }
    void Clean()    { sleep_for(1s); state = 2; }
};

struct Program {
    Program() {
        auto worker_id = 1;
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { clean_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { clean_worker(id); });
    }

    size_t createWork(DataClass task) {
        return genTasks.enqueue(std::move(task));
    }

    ~Program() {
        _shutdown = true;
        for (auto& th: _workers) 
            if (th.joinable()) th.join();
        std::cout << "Unfinished generate/clean tasks: " << genTasks.size() << "/" << cleanTasks.size() << "\n";
    }

  private:
    Queue<DataClass> genTasks, cleanTasks;
    std::atomic_bool _shutdown { false };
    std::list<std::thread> _workers;

    void generate_worker(int worker_id) {
        while (!_shutdown) {
            while (auto task = genTasks.dequeue(1s)) {
                std::cout << "Worker #" << worker_id << " Generate: " << task->id << std::endl;
                task->Generate();
                cleanTasks.enqueue(std::move(*task));
            }
        }
        std::cout << "Worker #" << worker_id << " Exit generate_worker" << std::endl;
    }

    void clean_worker(int worker_id) {
        while (!_shutdown) {
            while (auto task = cleanTasks.dequeue(1s)) {
                std::cout << "Worker #" << worker_id << " Clean: " << task->id << std::endl;
                task->Clean();
                std::cout << "Worker #" << worker_id << " Done: " << task->id << std::endl;
            }
        }
        std::cout << "Worker #" << worker_id << " Exit clean_worker" << std::endl;
    }
};

int main() {
    Program p; 

    for (auto i : {1,2,3,4,5,6,7,8,9,10}) {
        sleep_for((rand()%100) * 1ms);
        p.createWork(i);
    }

    sleep_for(2.5s);
    std::cout << "Load at createWork(42) is ~" << p.createWork(42) << std::endl;
    sleep_for(2.5s);
    std::cout << "Load at createWork(43) is ~" << p.createWork(43) << std::endl;

    sleep_for(4s);
    std::cout << "Initiating shutdown\n";
    // Program destructor performs shutdown
}

完整列表

Worker #2 Generate: 1
Worker #1 Generate: 2
Worker #3 Generate: 3
Worker #4 Generate: 4
Worker #2 Generate: 5
Worker #5 Clean: 1
Load at createWork(42) is ~6
Worker #1 Generate: 6
Worker #6 Clean: 2
Worker #3 Generate: 7
Worker #4 Generate: 8
Worker #5 Done: 1
Worker #5 Clean: 3
Worker #6 Done: 2
Worker #6 Clean: 4
Worker #5 Done: 3
Worker #6 Done: 4
Load at createWork(43) is ~4
Worker #2 Generate: 9
Worker #5 Clean: 5
Worker #1 Generate: 10
Worker #6 Clean: 6
Worker #3 Generate: 42
Worker #4 Generate: 43
Worker #5 Done: 5
Worker #5 Clean: 7
Worker #6 Done: 6
Worker #6 Clean: 8
Worker #5 Done: 7
Worker #6 Done: 8
Worker #5 Clean: 9
Worker #6 Clean: 10
Initiating shutdown
Worker #2 Exit generate_worker
Worker #5 Done: 9
Worker #5 Clean: 42
Worker #1 Exit generate_worker
Worker #6 Done: 10
Worker #6 Clean: 43
Worker #3 Exit generate_worker
Worker #4 Exit generate_worker
Worker #5 Done: 42
Worker #6 Done: 43
Worker #5 Exit clean_worker
Worker #6 Exit clean_worker
Unfinished generate/clean tasks: 0/0

#include <mutex>
#include <condition_variable>
#include <deque>
#include <optional>

template <typename T>
struct Queue {
    Queue(size_t max = 50) : _max(max) {}

    size_t enqueue(T v) {
        std::unique_lock lk(_mx);
        _cond.wait(lk, [this] { return (_max == 0) || (_storage.size() < _max); });

        _storage.push_back(std::move(v));
        _cond.notify_one();
        return _storage.size(); // NOTE: very racy load indicator
    }

    template <typename Duration>
    std::optional<T> dequeue(Duration d) {
        std::unique_lock lk(_mx);

        if (_cond.wait_for(lk, d, [this] { return !_storage.empty(); })) {
            auto top = std::move(_storage.front());

            _storage.pop_front();
            _cond.notify_one();

            return top;
        }

        return std::nullopt;
    }

    size_t size() const { // racy in multi-thread situations
        std::unique_lock lk(_mx);
        return _storage.size();
    }

  private:
    size_t _max;
    mutable std::mutex _mx;
    mutable std::condition_variable _cond;
    std::deque<T> _storage;
};

#include <chrono>
#include <thread>
#include <iostream>
#include <list>
#include <atomic>
using namespace std::chrono_literals;
static inline auto sleep_for = [](auto d) { std::this_thread::sleep_for(d); };

struct DataClass {
    int id;
    unsigned int state{ 0 };

    DataClass(int id) : id(id) {}
    //DataClass(DataClass&&) = default;
    //DataClass& operator=(DataClass&&) = default;
    //DataClass(DataClass const&) = delete;

    void Generate() { sleep_for(3s); state = 1; }
    void Clean()    { sleep_for(1s); state = 2; }
};

struct Program {
    Program() {
        auto worker_id = 1;
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { generate_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { clean_worker(id); });
        _workers.emplace_back([this, id=worker_id++] { clean_worker(id); });
    }

    size_t createWork(DataClass task) {
        return genTasks.enqueue(std::move(task));
    }

    ~Program() {
        _shutdown = true;
        for (auto& th: _workers) 
            if (th.joinable()) th.join();
        std::cout << "Unfinished generate/clean tasks: " << genTasks.size() << "/" << cleanTasks.size() << "\n";
    }

  private:
    Queue<DataClass> genTasks, cleanTasks;
    std::atomic_bool _shutdown { false };
    std::list<std::thread> _workers;

    void generate_worker(int worker_id) {
        while (!_shutdown) {
            while (auto task = genTasks.dequeue(1s)) {
                std::cout << "Worker #" << worker_id << " Generate: " << task->id << std::endl;
                task->Generate();
                cleanTasks.enqueue(std::move(*task));
            }
        }
        std::cout << "Worker #" << worker_id << " Exit generate_worker" << std::endl;
    }

    void clean_worker(int worker_id) {
        while (!_shutdown) {
            while (auto task = cleanTasks.dequeue(1s)) {
                std::cout << "Worker #" << worker_id << " Clean: " << task->id << std::endl;
                task->Clean();
                std::cout << "Worker #" << worker_id << " Done: " << task->id << std::endl;
            }
        }
        std::cout << "Worker #" << worker_id << " Exit clean_worker" << std::endl;
    }
};

int main() {
    Program p; 

    for (auto i : {1,2,3,4,5,6,7,8,9,10}) {
        sleep_for((rand()%100) * 1ms);
        p.createWork(i);
    }

    sleep_for(2.5s);
    std::cout << "Load at createWork(42) is ~" << p.createWork(42) << std::endl;
    sleep_for(2.5s);
    std::cout << "Load at createWork(43) is ~" << p.createWork(43) << std::endl;

    sleep_for(4s);
    std::cout << "Initiating shutdown\n";
    // Program destructor performs shutdown
}

#包括
#包括
#包括
#包括
模板
结构队列{
队列（大小\u t max=50）：\u max（max）{
排队人数（t v）{
std：：唯一锁lk（_mx）；
_cond.wait（lk，[this]{return（_max==0）| |（_storage.size（）<_max）；}）；
_存储。推回（标准：：移动（v））；
_第二，通知某人；
return _storage.size（）；//注意：非常快速的负载指示器
}
模板
std：：可选出列（持续时间d）{
std：：唯一锁lk（_mx）；
if（_cond.wait_for（lk，d，[this]{return！_storage.empty（）；}））{
auto-top=std:：move（_storage.front（））；
_存储。pop_front（）；
_第二，通知某人；
返回顶部；
}
返回std：：nullopt；
}
多线程情况下的size\u t size（）常量{//racy
std：：唯一锁lk（_mx）；
返回_storage.size（）；
}
私人：
最大尺寸；
可变std:：mutex mx；
可变标准：：条件变量条件；
std：：deque_存储；
};
#包括
#包括
#包括
#包括
#包括
使用名称空间std:：chrono_文本；
静态内联自动休眠_for=[]（自动d）{std:：this_thread:：sleep_for（d）；}；
结构数据类{
int-id；
无符号整数状态{0}；
数据类（int-id）：id（id）{}
//DataClass（DataClass&&）=默认值；
//DataClass&operator=（DataClass&&）=默认值；
//数据类（数据类常量&）=删除；
void Generate（）{sleep_for（3s）；state=1；}
void Clean（）{sleep_for（1s）