call_once.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_ASYNC_CALL_ONCE_HPP__
#define MSTL_CORE_ASYNC_CALL_ONCE_HPP__

 
#include "MSTL/core/functional/invoke.hpp"
#include "MSTL/core/async/atomic.hpp"
MSTL_BEGIN_NAMESPACE__


class once_flag {
private:
    atomic<uint32_t> state_;  
 
    template <typename Callable, typename... Args>
    friend void call_once(once_flag& flag, Callable&& func, Args&&... args);
 
public:
    once_flag() noexcept : state_(0) {}
    once_flag(const once_flag&) = delete;
    once_flag& operator =(const once_flag&) = delete;
    once_flag(once_flag&&) = delete;
    once_flag& operator =(once_flag&&) = delete;
};

template <typename Callable, typename... Args>
void call_once(once_flag& flag, Callable&& func, Args&&... args) {
    if (flag.state_.load(memory_order_acquire) == 2) {
        return;
    }
 
    uint32_t spin_count = 0;
    while (true) {
        const uint32_t state = flag.state_.load(memory_order_acquire);
        if (state == 2) return;
 
        if (state == 0) {
            uint32_t expected = 0;
            if (flag.state_.compare_exchange_strong(
                    expected, 1,
                    memory_order_acq_rel,
                    memory_order_relaxed)) {
                try {
                    _MSTL invoke<Callable, Args...>(
                        _MSTL forward<Callable>(func),
                        _MSTL forward<Args>(args)...
                    );
                    flag.state_.store(2, memory_order_release);
                    return;
                } catch (...) {
                    flag.state_.store(0, memory_order_release);
                    throw;
                }
            }
            spin_count = 0;
            continue;
        }
 
        if (spin_count < 10) {
            for (uint32_t i = 0; i < (1u << spin_count); ++i) {
                this_thread::relax();
            }
            ++spin_count;
        } else {
            this_thread::yield();
        }
    }
}
 // CallOnce
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_ASYNC_CALL_ONCE_HPP__