objects/threads 共享障碍

Question

假设我有对象 A 和对象 B。ObjA 创建多个“ObjB”并保留指向每个对象的指针，然后在每个对象 B 上分离一个线程以完成工作。我想在 ObjA 中实现一个屏障，只有当所有“ObjB”在其工作功能中达到某个内部条件时才会解锁。

如何在 ObjA 中创建具有动态计数的障碍，然后让 ObjB 知道该障碍，以便它可以到达障碍？我想使用 std::barrier 但我在尝试这样做时遇到了问题。

到目前为止，我不能在 ObjA 中创建一个 std::barrier 成员变量，因为它需要一个输入大小，我只有在构造 ObjA 后才能知道。如果我在 ObjA 的繁忙函数内部创建屏障，那么 ObjB 调用 A 的任何信号函数都将没有作用域。

在忙等待的情况下做一些朴素的信号量是最好的方法吗？

Answer 1

您可以使用条件变量。

    #include <iostream>
    #include <condition_variable>
    #include <thread>
    #include <vector>
     
    std::condition_variable cv;
    std::mutex cv_m; // This mutex is used for three purposes:
                     // 1) to synchronize accesses to count
                     // 3) for the condition variable cv
    int total_count = 10; // This is count of objBs
    int count = total_count;
     
     
    void obj_b_signals()
    {
        // Do something..
        bool certainCondition = true;
        // We have reached the condition..
        if (certainCondition) {
            {
                std::lock_guard<std::mutex> lk(cv_m);
                count--;
            }
            std::cerr << "Notifying...\n";
            cv.notify_one();
        }
    }
     
    int main()
    {
        // obj A logic
       std::vector<std::thread> threads;
       for (size_t i=0; i<total_count; ++i) {
            threads.emplace_back(std::thread(obj_b_signals));
        }
        {
            std::unique_lock<std::mutex> lk(cv_m);
            std::cerr << "Waiting for ObjBs to reach a certain condition... \n";
            cv.wait(lk, []{return count == 0;});
            std::cerr << "...finished waiting. count == 0\n";            
        }
        // Do something else
        for (std::thread & t: threads) {
            t.join();
        }
    }

objects/threads 共享障碍

Sharing Barriers across objects/threads

c++

multithreading

semaphore

barrier