线程池的同步

Question

In every time step multiple worker threadss W[1..10] are supposed to idle until they are signaled from the main thread to start working. Do each their work, Signal back to the mainthread that they are done and return to the waiting state they were in before. The mainthread is supposed to be waiting while the workerthreads do their work.

I was trying to do this using std::condition_variable ann std::mutex but failed. What is the right approach to the problem not using boost or other high Level libraries? I would like to avoid spawning and joining threads in every step for performance reasons. Thank you very much.

Edit:

const size_t thread_num = 10;

int busy_count = thread_num;

std::condition_variable cv;
std::mutex cv_m;

std::condition_variable cv_lock1;
std::mutex cv_m_lock1;


bool lock_1;

bool end_all = false;

void wthread()
{   
    do {        
        {
            std::unique_lock<std::mutex> lk(cv_m_lock1);
            cv_lock1.wait(lk, []{return lock_1 == false; });
        }

        if (end_all)
        {
            std::cout << "exit\n";
            return;
        }

        // do work

        {           
            std::lock_guard<std::mutex> lk(cv_m);
            busy_count--;
            std::cout << busy_count << " ";         
        }       
        cv.notify_all();

        {
            std::unique_lock<std::mutex> lk(cv_m_lock1);
            cv_lock1.wait(lk, []{return lock_1 == true; });
        }



    } while (true);
}

int _tmain(int argc, _TCHAR* argv[])
{       
    std::thread *t[thread_num];

    lock_1 = true;

    for (unsigned int i = 0; i < thread_num; i++)
        t[i] = new std::thread(wthread);

    for (int i = 0; i < 10; i++)
    {
        busy_count = 10;            

        lock_1 = false;     
        cv_lock1.notify_all();      

        {
            std::unique_lock<std::mutex> lk(cv_m);
            cv.wait(lk, []{return busy_count == 0; });
        }

        lock_1 = true;      
        cv_lock1.notify_all();
    }

    end_all = true;
    lock_1 = false; 
    cv_lock1.notify_all();  


    for (unsigned int i = 0; i < thread_num; i++)
        t[i]->join();

    return 0;
}

Answer 1

something like

std::thread thread1([](){/*do something*/});
std::thread thread2([](){/*do something*/});
std::thread thread3([](){/*do something*/});
thread1.join();
thread2.join();
thread3.join();

main thread will wait until threads 1..3 finish working; and those threads will be working simultaneously