暂停其他线程中的线程，然后等待所有线程暂停

debugcn 发表于 Dev

Dkui2200

我想暂停创建者线程中的许多工作线程。如代码所示，这可以通过条件变量来完成。

#include <iostream>
#include <vector>
#include <thread>
#include <condition_variable>
#include <atomic>

#define NR_ITERATIONS 3
#define NR_THREADS 5

class c_threads {
private:
    bool m_worker_threads_pause;

    //std::atomic<int> m_worker_threads_paused;
    std::mutex m_worker_thread_mutex;
    std::condition_variable m_worker_thread_conditional_variable;


    void worker_thread() {
        std::unique_lock<std::mutex> worker_thread_lock(m_worker_thread_mutex);
        m_worker_thread_conditional_variable.wait(worker_thread_lock,
            [this]{return !this->m_worker_threads_pause;}
        );

        std::cout << "worker thread function" << std::endl;

        //...
    }

    void creator_thread() {
        std::cout << "creator thread function" << std::endl;

        {
            std::lock_guard<std::mutex> lock_guard(m_worker_thread_mutex);
            m_worker_threads_pause = true;
        }
//        wait_until( worker_threads_waiting == NR_THREADS);


        //...


        {
            std::lock_guard<std::mutex> lock_guard(m_worker_thread_mutex);
            m_worker_threads_pause = false;
        }
        m_worker_thread_conditional_variable.notify_all();
    }

public:
    c_threads() :   m_worker_threads_pause(true)
                    /*m_worker_threads_paused(0)*/ {}

    void start_job() {
        std::vector<std::thread> worker_threads;
        worker_threads.reserve(NR_THREADS);

        for (int i=0;i<NR_THREADS;i++) {
            worker_threads.emplace_back(&c_threads::worker_thread,this);
        }

        std::thread o_creator_thread(&c_threads::creator_thread,this);
        o_creator_thread.join();

        for (auto& thread : worker_threads) {
            thread.join();
        }
    }
};


int main(int argc, char** argv) {
    c_threads o_threads;
    o_threads.start_job();
}

问题在于，creator_thread函数应等待，直到所有worker_functions都在条件变量处等待，然后才能继续。

每次调用creator_thread函数时，都应

暂停工作线程
等待，直到它们都在条件变量处暂停
继续

如何实现呢？

约瑟夫·拉森

也许有更好的方法，但是我认为您将不得不做一些更复杂的事情，例如创建Gatekeeper对象。工作线程通常按以下方式工作：

while(iShouldKeepRunning()) {
    ... lock the mutex
    ... look for something to do
    ... if nothing to do, then wait on the condition
}

我认为相反，您将需要某种“给我更多工作”的对象，或者是创建者线程可以阻止的“继续工作是否安全”的对象。

while(iShouldKeepRunning()) {
    ... no mutex at all
    ... ask the gatekeeper for something to do / if it's safe to do something
    ... and the gatekeeper blocks as necessary
    ... do the work
}

关守锁定互斥锁，检查是否可以安全分发工作，如果不安全，则在阻止condvar之前增加“我正在让这个家伙等待”计数器。

这样的事情。

阻止程序可能类似于：

class BlockMyThreads {
public:
     int runningCount = 0;
     int blockedCount = 0;
     bool mayWork = true;
     std::mutex myMutex;
     std::condition_variable condVar;

     void iAmWorking() {
         std::unique_lock<std::mutex> lock(myMutex);
         ++runningCount;
     }

     void letMeWork() {
         std::unique_lock<std::mutex> lock(myMutex);
         while (!mayWork) {
             ++blockedCount;
             condVar.wait(lock);
             --blockedCount;
         }
     }

     void block() {
         std::unique_lock<std::mutex> lock(myMutex);
         mayWork = false;
     }

     void release() {
         std::unique_lock<std::mutex> lock(myMutex);
         mayWork = true;
         condVar.notifyAll(lock);
     }
};

我没有测试过，所以可能有错误。我想，您的工作线程将需要在开始时调用iAmWorking（）（为您提供线程计数），并且您希望在完成时增加他们调用的减量。

主线程可以根据需要调用block（）和release（）。

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。