C ++拥有多个线程

Question

I'm new to C++ (on Windows) and threading and I'm currently trying to find a solution to my problem using mutexes, semaphores and events. I'm trying to create a Barrier class with a constructor and a method called Enter. The class Barrier with it's only method Enter is supposed to hold off any thread that enters it, until a number of thread have reached that method. The number of thread to wait for it recieved at the contructor. My problem is how do I use the locks to create that effect? what I need is something like a reversed semaphore, that holds threads until a count has been reached and not like the regular semaphore works that lets threads in until a count is reached. Any ideas as to how to go about this would be great. Thanks, Netanel.

Answer 1

Maybe:

In the ctor, store the limit count and create an empty semaphore.

When a thread calls Enter, lock a mutex first so you can twiddle inside safely. Inc a thread count toward the limit count. If the limit has not yet been reached, release the mutex and wait on the semaphore. If the limit is reached, signal the semaphore[limit-1] times in a loop, zero the thread count, (ready for next time), release the mutex and return from Enter(). Any threads that were waiting on the semaphore, and are now ready/running, should just return from their 'Enter' call.

The mutex prevents any released thread that loops around from 'getting in again' until all the threads that called 'Enter' and waited have been set running and the barrier is reset.

Answer 2

You can implement it with condition variable.

Here is an example:

I declare 25 threads and launch them doing the WorkerThread function.

The condition I am checking to block/unblick the threads is whether the number of threads in the section is less than 2. (I have added some asserts to prove what my coode does).

My code is simply sleeping in the critical section and after I decrease the number of threads in the critical section.

I also added a mutex for the cout to have clean messages. #include #include #include #include #include #include #include /* assert */ using namespace std;

std::mutex m;
atomic<int> NumThreadsInCritialSection=0;
int MaxNumberThreadsInSection=2;
std::condition_variable cv;

mutex coutMutex;

 int WorkerThread()
{
    // Wait until main() sends data
    {
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk, []{return NumThreadsInCritialSection<MaxNumberThreadsInSection;});
    }
    assert (NumThreadsInCritialSection<MaxNumberThreadsInSection);
    assert (NumThreadsInCritialSection>=0);
    NumThreadsInCritialSection++;
    {
        std::unique_lock<std::mutex> lk(coutMutex);
        cout<<"NumThreadsInCritialSection= "<<NumThreadsInCritialSection<<endl;
    }

    std::this_thread::sleep_for(std::chrono::seconds(5));
    NumThreadsInCritialSection--;
    {
        std::unique_lock<std::mutex> lk(coutMutex);
        cout<<"NumThreadsInCritialSection= "<<NumThreadsInCritialSection<<endl;
    }

    cv.notify_one();
    return 0;
}

int main()
{
    vector<thread> vWorkers;
    for (int i=0;i<25;++i)
    {
        vWorkers.push_back(thread(WorkerThread));
    }

    for (auto j=vWorkers.begin(); j!=vWorkers.end(); ++j)
    {
        j->join();
    }
    return 0;
}

Hope that helps, tell me if you have any questions, I can comment or change my code.

Answer 3

Pseudocode outline might look like this:

void Enter()
{
    Increment counter (atomically or with mutex)
    if(counter >= desired_count)
    {
        condition_met = true; (protected if bool writes aren't atomic on your architecture)
        cond_broadcast(blocking_cond_var);
    }
    else
    {
        Do a normal cond_wait loop-plus-predicate-check (waiting for the broadcast and checking condition_met each iteration to protect for spurious wakeups).
    }
}