strand.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_STRAND_HPP__
#define NEFORCE_CORE_ASYNC_STRAND_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/async/io_context.hpp"
#include "NeForce/core/async/lock_free_queue.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/shared_ptr.hpp"
NEFORCE_BEGIN_NAMESPACE__


class strand {
public:
    using handler_type = function<void()>;
 
private:
    struct impl {
        io_context* ctx;
        atomic<bool> locked_{false};
        lock_free_queue<function<void()>> queue_;
 
        explicit impl(io_context& c) :
        ctx(&c) {}
 
        void drain_one(const shared_ptr<impl>& self) {
            bool expected = false;
            if (!self->locked_.compare_exchange_strong(expected, true, memory_order_acquire, memory_order_relaxed)) {
                return;
            }
            auto handler = self->queue_.try_pop();
            if (handler) {
                auto shared_handler = make_shared<function<void()>>(move(*handler));
                self->ctx->post([self, shared_handler]() {
                    (*shared_handler)();
                    self->locked_.store(false, memory_order_release);
                    self->drain_one(self);
                });
            } else {
                self->locked_.store(false, memory_order_release);
            }
        }
    };
 
    shared_ptr<impl> impl_;
 
public:
    explicit strand(io_context& ctx) :
    impl_(make_shared<impl>(ctx)) {}

    void post(handler_type handler) {
        impl_->queue_.push(move(handler));
        impl_->drain_one(impl_);
    }

    void dispatch(handler_type handler) {
        bool expected = false;
        if (impl_->locked_.compare_exchange_strong(expected, true, memory_order_acquire, memory_order_relaxed)) {
            handler();
            impl_->locked_.store(false, memory_order_release);
            impl_->drain_one(impl_);
        } else {
            post(move(handler));
        }
    }

    NEFORCE_NODISCARD io_context::executor get_executor() const noexcept { return impl_->ctx->get_executor(); }

    NEFORCE_NODISCARD io_context& context() const noexcept { return *impl_->ctx; }
};
 // Strand
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_STRAND_HPP__