Method wait_for_task

source/executors/thread_pool_executor.cpp:265–315

}

bool thread_pool_worker::wait_for_task(std::unique_lock<std::mutex>& lock) {
    assert(lock.owns_lock());

    if (!m_public_queue.empty() || m_abort) {
        return true;
    }

    lock.unlock();

    m_parent_pool.mark_worker_idle(m_index);

    auto event_found = false;
    const auto deadline = std::chrono::steady_clock::now() + m_max_idle_time;

    while (true) {
        if (!m_semaphore.try_acquire_until(deadline)) {
            if (std::chrono::steady_clock::now() <= deadline) {
                continue;  // handle spurious wake-ups
            } else {
                break;
            }
        }

        if (!m_task_found_or_abort.load(std::memory_order_relaxed)) {
            continue;
        }

        lock.lock();
        if (m_public_queue.empty() && !m_abort) {
            lock.unlock();
            continue;
        }

        event_found = true;
        break;
    }

    if (!lock.owns_lock()) {
        lock.lock();
    }

    if (!event_found || m_abort) {
        m_idle = true;
        lock.unlock();
        return false;
    }

    assert(!m_public_queue.empty());
    m_parent_pool.mark_worker_active(m_index);
    return true;
}

bool thread_pool_worker::drain_queue_impl() {
    auto aborted = false;