Estoy tratando de familiarizarme con los nuevos conceptos de ordenación de memoria de c ++ 11 y creí que realmente tenía un buen conocimiento de ellos, hasta que me topé con esta implementación de un bloqueo de giro:

#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 por ejemplo equivalente mencionado enhttp://en.cppreference.com/w/cpp/atomic/atomic_flag
y también en el libro "Concurrencia en Acción". También lo encontré en algún lugar aquí en SO.

¡Pero no entiendo por qué funcionaría!
Imagine que el subproceso 1 llama a lock () y test_and_set () devuelve 0 como el valor anterior -> thread 1 ha adquirido el bloqueo.
Pero luego viene el hilo 2 e intenta lo mismo. Ahora, debido a que no se ha producido ninguna "sincronización de tienda" (versión, seq_cst_acq_rel), la tienda 1 del hilo para spin_lock debería ser de tipo relajado.
Pero de esto se deduce que no se puede sincronizar con la lectura del hilo 2 de spin_lock. Esto debería hacer posible que el hilo 2 lea el valor 0 de spin_lock y, por lo tanto, también obtenga el bloqueo.
¿Dónde está mi error?