std::atomic_spinlock Klassenreferenz

#include <spinlock.hpp>

Klassendiagramm für std::atomic_spinlock:

Zusammengehörigkeiten von std::atomic_spinlock:

Öffentliche Typen
enum	type { Locked, Unlocked }
using	lock_type = atomic_spinlock::type
using	native_handle_type = atomic_spinlock

Öffentliche Methoden
	atomic_spinlock ()
	~atomic_spinlock ()
void	lock (void)
	abstract function lock the current context Mehr ...
bool	try_lock (void)
	abstract function try to lock the current context Mehr ...
void	unlock (void)
	abstract function unlock the current locked context Mehr ...
native_handle_type &	native_handle ()
	atomic_spinlock (const atomic_spinlock &)=delete
atomic_spinlock &	operator= (const atomic_spinlock &)=delete

Ausführliche Beschreibung

Dokumentation der benutzerdefinierten Datentypen

lock_type

using std::atomic_spinlock::lock_type = atomic_spinlock::type

native_handle_type

using std::atomic_spinlock::native_handle_type = atomic_spinlock

Dokumentation der Aufzählungstypen

type

enum std::atomic_spinlock::type

Aufzählungswerte
Locked
Unlocked

{Locked, Unlocked };

Beschreibung der Konstruktoren und Destruktoren

atomic_spinlock() [1/2]

std::atomic_spinlock::atomic_spinlock ( )

inline

                          : m_locked() {
            
        }

~atomic_spinlock()

std::atomic_spinlock::~atomic_spinlock ( )

inline

                           {
            
        }

atomic_spinlock() [2/2]

std::atomic_spinlock::atomic_spinlock ( const atomic_spinlock &  )

delete

Dokumentation der Elementfunktionen

lock()

void std::atomic_spinlock::lock ( void  )

inlinevirtual

abstract function lock the current context

Implementiert std::lock_base.

                          {
           while( m_locked.exchange(Locked, MemoryOrder::Acquire) == Locked) {
               
           }
        }

native_handle()

native_handle_type& std::atomic_spinlock::native_handle ( )

inline

                                            {
            return *this;
        }

operator=()

atomic_spinlock& std::atomic_spinlock::operator= ( const atomic_spinlock &  )

delete

try_lock()

bool std::atomic_spinlock::try_lock ( void  )

inlinevirtual

abstract function try to lock the current context

Implementiert std::lock_base.

                              {
            if( m_locked.exchange(Locked, MemoryOrder::Acquire) == Locked)
                return false;
            else
                lock();
            return true;
        }

unlock()

void std::atomic_spinlock::unlock ( void  )

inlinevirtual

abstract function unlock the current locked context

Implementiert std::lock_base.

                        {
            m_locked.store(Unlocked, MemoryOrder::Release);
        }

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/spinlock.hpp