安全的多线程计数器增量

Question

For example, I've got a some work that is computed simultaneously by multiple threads.

For demonstration purposes the work is performed inside a while loop. In a single iteration each thread performs its own portion of the work, before the next iteration begins a counter should be incremented once.

My problem is that the counter is updated by each thread.

As this seems like a relatively simple thing to want to do, I presume there is a 'best practice' or common way to go about it?

Here is some sample code to illustrate the issue and help the discussion along. (Im using boost threads)

class someTask {
public:
    int mCounter; //initialized to 0
    int mTotal; //initialized to i.e. 100000
    boost::mutex cntmutex;                
    int getCount()
    {
            boost::mutex::scoped_lock lock( cntmutex );
            return mCount;
    }
    void process( int thread_id, int numThreads )
    {
        while ( getCount() < mTotal )
        {
            // The main task is performed here and is divided 
            // into sub-tasks based on the thread_id and numThreads

                            // Wait for all thread to get to this point

            cntmutex.lock();
            mCounter++;  // < ---- how to ensure this is only updated once?
            cntmutex.unlock();
        }
    }
};

Answer 1

The main problem I see here is that you reason at a too-low level. Therefore, I am going to present an alternative solution based on the new C++11 thread API.

The main idea is that you essentially have a schedule -> dispatch -> do -> collect -> loop routine. In your example you try to reason about all this within the do phase which is quite hard. Your pattern can be much more easily expressed using the opposite approach.

First we isolate the work to be done in its own routine:

void process_thread(size_t id, size_t numThreads) {
    // do something
}

Now, we can easily invoke this routine:

#include <future>
#include <thread>
#include <vector>

void process(size_t const total, size_t const numThreads) {
    for (size_t count = 0; count != total; ++count) {
         std::vector< std::future<void> > results;

         // Create all threads, launch the work!
         for (size_t id = 0; id != numThreads; ++id) {
             results.push_back(std::async(process_thread, id, numThreads));
         }

         // The destruction of `std::future`
         // requires waiting for the task to complete (*)
    }
}

(*) See this question .

You can read more about std::async here , and a short introduction is offered here (they appear to be somewhat contradictory on the effect of the launch policy, oh well). It is simpler here to let the implementation decides whether or not to create OS threads: it can adapt depending on the number of available cores.

Note how the code is simplified by removing shared state. Because the threads share nothing, we no longer have to worry about synchronization explicitly!

Answer 2

You protected the counter with a mutex, ensuring that no two threads can access the counter at the same time. Your other option would be using Boost::atomic , c++11 atomic operations or platform-specific atomic operations.

However, your code seems to access mCounter without holding the mutex:

    while ( mCounter < mTotal )

That's a problem. You need to hold the mutex to access the shared state.

You may prefer to use this idiom:

1. Acquire lock.

2. Do tests and other things to decide whether we need to do work or not.

3. Adjust accounting to reflect the work we've decided to do.

4. Release lock. Do work. Acquire lock.

5. Adjust accounting to reflect the work we've done.

6. Loop back to step 2 unless we're totally done.

7. Release lock.

Answer 3

You need to use a message-passing solution. This is more easily enabled by libraries like TBB or PPL. PPL is included for free in Visual Studio 2010 and above, and TBB can be downloaded for free under a FOSS licence from Intel.

concurrent_queue<unsigned int> done;
std::vector<Work> work; 
// fill work here
parallel_for(0, work.size(), [&](unsigned int i) {
    processWorkItem(work[i]);
    done.push(i);
});

It's lockless and you can have an external thread monitor the done variable to see how much, and what, has been completed.

Answer 4

I would like to disagree with David on doing multiple lock acquisitions to do the work.

Mutexes are expensive and with more threads contending for a mutex , it basically falls back to a system call , which results in user space to kernel space context switch along with the with the caller Thread(/s) forced to sleep :Thus a lot of overheads.

So If you are using a multiprocessor system , I would strongly recommend using spin locks instead [1].

So what i would do is :

=> Get rid of the scoped lock acquisition to check the condition.

=> Make your counter volatile to support above

=> In the while loop do the condition check again after acquiring the lock.

class someTask {
 public:
 volatile int mCounter; //initialized to 0       : Make your counter Volatile
 int mTotal; //initialized to i.e. 100000
 boost::mutex cntmutex;                

 void process( int thread_id, int numThreads )
 {
    while ( mCounter < mTotal ) //compare without acquiring lock
    {
        // The main task is performed here and is divided 
        // into sub-tasks based on the thread_id and numThreads

        cntmutex.lock();
        //Now compare again to make sure that the condition still holds
        //This would save all those acquisitions and lock release we did just to 
        //check whther the condition was true.
        if(mCounter < mTotal)
        {
             mCounter++;  
        }

        cntmutex.unlock();
    }
 }
};

[1]http://www.alexonlinux.com/pthread-mutex-vs-pthread-spinlock