Win32 CRITICAL_SECTION for C ++的轻量级，跨平台替代品？

Question

Are there lightweight, cross-platform alternatives to Win32 CRITICAL_SECTION for C++? I am trying to make my Windows application platform agnostic, but std::recursive_mutex is way slower than CRITICAL_SECTION. I am currently using Visual Studio 2013 Community.

Answer 1

You should have a look at the Boost.Thread library and boost::recursive_mutex in particular.

(also see How do I make a critical section with Boost? )

Answer 2

http://en.cppreference.com/w/cpp/atomic/atomic_flag "A spinlock mutex can be implemented in userspace using an atomic_flag"

I adapted their userspace spinlock mutex to allow recursive locks.

Warning: speedcoded synchronization logic should be assumed faulty until tested in a thousand battles, and also carefully coded synchronization logic

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

std::atomic_flag lock = ATOMIC_FLAG_INIT;
std::thread::id current_thread;
volatile int counter;

void lockme()
{
    for(;;)
    {
        //protect access to current_thread and counter
        while (lock.test_and_set(std::memory_order_acquire))
        {}

        //use current_thread and counter

        //the thread with the conceptual lock is in current_thread
        //if that's this thread, or no such thread, make sure this thread has the lock and increment counter
        auto myid = std::this_thread::get_id();
        if(current_thread == myid || current_thread == std::thread::id())
        {
            counter++;
            current_thread = myid;
            lock.clear(std::memory_order_release);
            return;
        }

        lock.clear(std::memory_order_release);
    }
}

void unlockme()
{
    for(;;)
    {
        //protect access to current_thread and counter
        while (lock.test_and_set(std::memory_order_acquire))
        {}

        //use current_thread and counter

        //if this thread has the conceptual lock, perform the unlock
        //otherwise try again
        auto myid = std::this_thread::get_id();
        if(current_thread == myid)
        {
            counter--;
            if(counter==0)
                current_thread = std::thread::id();
            lock.clear(std::memory_order_release);
            return;
        }

        lock.clear(std::memory_order_release);
    }

}

void f(int n)
{
    for (int cnt = 0; cnt < 100; ++cnt) {
        for (int j = 0; j < 10; j++) lockme();
        std::cout << "Output from thread " << n << '\n';
        for (int j = 0; j < 10; j++) unlockme();
    }
}

int main()
{
    std::vector<std::thread> v;
    for (int n = 0; n < 10; ++n) {
        v.emplace_back(f, n);
    }
    for (auto& t : v) {
        t.join();
    }
}