我知道这个问题已经被问过很多次了。我已经读过和看过很多，但是仍然不能完全理解如何正确地在原子变量上使用内存顺序类型。我想在分离线程上使用原子计数器和条件变量来等待。每个原子操作应该如何编写？

#include <random>
#include <thread>
#include <condition_variable>

int blockAndGet(int a, int b);

int main()
{
    std::jthread producer{[](std::stop_token st)
    {
        std::mutex m;
        std::condition_variable cond;
        std::atomic<std::uint16_t> counter;

        while (!st.stop_requested()) {
            // Get some data to handle(sometimes slower, generally faster than handling it)
            int data = blockAndGet(1, 40);

            // #1 - I'm not interested with the result, are workers too?
            counter.fetch_add(1, std::memory_order::relaxed);

            std::thread{[&](std::stop_token st, int data)
            {
                blockAndGet(30, 100); // Do some work

                if (!st.stop_requested())
                    // #2 - I'm not interested with the result too but do other workers care about?
                    counter.fetch_sub(1, std::memory_order::release);
                else {
                    std::lock_guard l{m};
                    // #3 - If I'm the one who has to signal the producer to wake up I had to get the newest value.
                    if (counter.fetch_sub(1, std::memory_order::acq_rel) == 1)
                        cond.notify_one();
                }    
            }, st, data}
            .detach();
        }

        std::unique_lock lock{m};
        // #4 I must be sure all workers finished their execution
        cond.wait(lock, [&]{ return counter.load(std::memory_order::acquire) == 0; });
    }};

    // Should spawn ~100 worker thread before stop signal
    std::this_thread::sleep_for(std::chrono::seconds{2});
    return 0;
}

int blockAndGet(int a, int b) {
    // You know what this is intended for
    // No need to think about the random_device's surprises within the scope of this question
    thread_local std::mt19937 engine(std::random_device{}());
    std::uniform_int_distribution<int> dist{a, b};
    int val{dist(engine)};
    std::this_thread::sleep_for(std::chrono::milliseconds{val});
    return val;
}

https://godbolt.org/z/f46YMcPTj
我把我的想法写在评论里了。你能看到任何潜在的bug或改进吗？
编辑：
看起来我做的抽象让人们感到困惑和分心。对此我很抱歉。你可以把它当作一个服务器程序。First blockAndGet只是一个接受（）系统调用并返回一个文件描述符。使用该整数创建一个新线程，并在其中处理客户端（第二个blockAndGet）。当它完成时，如果停止没有被请求线程计数器递减。如果停止被请求那么生产者（侦听器）将等待所有工作线程完成，这也意味着最后一个工作线程负责额外唤醒生产者。
我不希望监听线程忙于等待，这就是为什么有condition_variable和mutex的原因。我怀疑atomic：：wait会这样做。
在这个例子中，stop信号来自jthread的析构函数main（）函数的末尾，但它也可能来自另一个线程（就像一个管理器，只为某个端口和自定义协议上的特权管理员服务）。
当然，这可以用更简单的方法来实现，但我认为利用c++的这个特性是一个很好的例子。
我希望这篇文章能帮助你认识到这个问题。谢谢你的时间和回应。