call_once.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_CALL_ONCE_HPP__
#define NEFORCE_CORE_ASYNC_CALL_ONCE_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/functional/invoke.hpp"
NEFORCE_BEGIN_NAMESPACE__



class once_flag {
private:
    atomic<uint32_t> state_{0};
 
    template <typename Callable, typename... Args>
    friend void call_once(once_flag& flag, Callable&& func, Args&&... args);
 
public:
    once_flag() noexcept = default;
    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 {
                    _NEFORCE invoke<Callable, Args...>(_NEFORCE forward<Callable>(func),
                                                       _NEFORCE 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
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_CALL_ONCE_HPP__