使用C 中的原始操作员的异步线的相互排除

我一直在尝试使用c 原语操作员和变量，例如 int ， if 和，而em>要开发螺纹安全机制。

我的想法是使用两个整数变量，称为 sync 和 lock ，增加和检查 sync sync and在此之后，逐步检查锁定。如果所有检查都成功了，则可以保证锁，但是如果检查不成功，它会再次尝试。

看来我的想法在最终验证中断言。

#include <assert.h>
#include <iostream>
#include <string>
#include <thread>
#include <vector>
class Resource {
    // Shared resource to be thread safe.
    int resource;
    // Mutual exclusion variables.
    volatile int lock;
    volatile int sync;
    public:
        Resource() : resource( 0 ), lock( 0 ), sync( 0 ) {}
        ~Resource() {}
        int sharedResource() {
            return resource;
        }
        void sharedResourceAction( std::string id ) {
            bool done;
            do {
                int oldSync = sync;
                // ++ should be atomic.
                sync++;
                if ( sync == oldSync + 1 ) {
                    // ++ should be atomic.
                    lock++;
                    if ( lock == 1 ) {
                        // For the sake of the example, the read-modify-write
                        // is not atomic and not thread safe if threre is no
                        // mutex surronding it.
                        int oldResource = resource;
                        resource = oldResource + 1;
                        done = true;
                    }
                    // -- should be atomic.
                    lock--;
                }
                if ( !done ) {
                    // Pseudo randomic sleep to unlock the race condition
                    // between the threads.
                    std::this_thread::sleep_for(
                             std::chrono::microseconds( resource % 5 ) );
                }
            } while( !done );
        }
};
static const int maxThreads = 10;
static const int maxThreadActions = 1000;
void threadAction( Resource& resource, std::string& name ) {
    for ( int i = 0; i < maxThreadActions; i++) {
        resource.sharedResourceAction( name );
    }
}
int main() {
    std::vector< std::thread* > threadVec;
    Resource resource;
    // Create the threads.
    for (int i = 0; i < maxThreads; ++i) {
        std::string name = "t";
        name += std::to_string( i );
        std::thread *thread = new std::thread( threadAction,
                                               std::ref( resource ),
                                               std::ref( name ) );
        threadVec.push_back( thread );
    }
    // Join the threads.
    for ( auto threadVecIter = threadVec.begin();
          threadVecIter != threadVec.end(); threadVecIter++ ) {
        (*threadVecIter)->join();
    }
    std::cout << "Shared resource is " << resource.sharedResource()
              << std::endl;
    assert( resource.sharedResource() == ( maxThreads * maxThreadActions ) );
    return 0;
}

是否存在仅使用原始变量和操作员保护共享资源的线程安全机制？