Ich versuche, mich mit den neuen Speicherordnungskonzepten von c ++ 11 vertraut zu machen, und bin der Meinung, dass ich sie ziemlich gut verstanden habe, bis ich auf diese Implementierung einer Drehsperre gestoßen bin:

#include <atomic>

namespace JayZ
{
    namespace Tools
    {
        class SpinLock
        {
        private:
            std::atomic_flag spin_lock;
        public:
            inline SpinLock( void ) : atomic_flag( ATOMIC_FLAG_INIT ) {}

            inline void lock( void )
            {
                while( spin_lock.test_and_set( std::memory_order_acquire ) )
                    ;
            }

            inline void unlock( void )
            {
                lock.clear( std::memory_order_release );
            }
        };
    }
}

Es ist z.B. gleichwertig erwähnt beihttp://en.cppreference.com/w/cpp/atomic/atomic_flag
und auch in dem Buch "Concurrency in Action". Ich habe es auch irgendwo hier bei SO gefunden.

Aber ich verstehe einfach nicht, warum es funktionieren würde!
Stellen Sie sich vor, Thread 1 ruft lock () auf und test_and_set () gibt 0 zurück, da der alte Wert -> Thread 1 die Sperre erhalten hat.
Dann kommt aber Thread 2 und versucht es gleich. Da jetzt keine "Speichersynchronisation" (release, seq_cst_acq_rel) stattgefunden hat, sollte der Speicher von Thread 1 für spin_lock vom Typ "relaxiert" sein.
Daraus folgt jedoch, dass es nicht mit dem Lesen von spin_lock durch Thread 2 synchronisiert werden kann. Dies sollte es Thread 2 ermöglichen, den Wert 0 aus spin_lock zu lesen und damit auch die Sperre zu erfassen.
Wo ist mein Fehler?