Function bthread_once_impl

src/bthread/bthread_once.cpp:32–71

namespace bthread {

int bthread_once_impl(bthread_once_t* once_control, void (*init_routine)()) {
    butil::atomic<int>* butex = once_control->_butex;
    // We need acquire memory order for this load because if the value
    // signals that initialization has finished, we need to see any
    // data modifications done during initialization.
    int val = butex->load(butil::memory_order_acquire);
    if (BAIDU_LIKELY(val == bthread_once_t::INITIALIZED)) {
        // The initialization has already been done.
        return 0;
    }
    val = bthread_once_t::UNINITIALIZED;
    if (butex->compare_exchange_strong(val, bthread_once_t::INPROGRESS,
                                       butil::memory_order_relaxed,
                                       butil::memory_order_relaxed)) {
        // This (b)thread is the first and the Only one here. Do the initialization.
        init_routine();
        // Mark *once_control as having finished the initialization. We need
        // release memory order here because we need to synchronize with other
        // (b)threads that want to use the initialized data.
        butex->store(bthread_once_t::INITIALIZED, butil::memory_order_release);
        // Wake up all other (b)threads.
        bthread::butex_wake_all(butex);
        return 0;
    }

    while (true) {
        // Same as above, we need acquire memory order.
        val = butex->load(butil::memory_order_acquire);
        if (BAIDU_LIKELY(val == bthread_once_t::INITIALIZED)) {
            // The initialization has already been done.
            return 0;
        }
        // Unless your constructor can be very time consuming, it is very unlikely o hit
        // this race. When it does, we just wait the thread until the object has been created.
        if (bthread::butex_wait(butex, val, NULL) < 0 &&
            errno != EWOULDBLOCK && errno != EINTR/*note*/) {
            return errno;
        }
    }
}

} // namespace bthread