Method setMaxThreads

src/Common/ThreadPool.cpp:190–219

template <typename Thread>
void ThreadPoolImpl<Thread>::setMaxThreads(size_t value)
{
    value = std::min(value, static_cast<size_t>(MAX_THEORETICAL_THREAD_COUNT));
    std::lock_guard lock(mutex);
    remaining_pool_capacity.fetch_add(value - max_threads, std::memory_order_relaxed);

    bool need_start_threads = (value > max_threads);
    bool need_finish_free_threads = (value < max_free_threads);

    max_threads = value;
    max_free_threads = std::min(max_free_threads, max_threads);

    /// We have to also adjust queue size, because it limits the number of scheduled and already running jobs in total.
    queue_size = queue_size ? std::max(queue_size, max_threads) : 0;
    jobs.reserve(std::min(queue_size, MAX_JOBS_TO_RESERVE));

    if (need_start_threads)
    {
        /// Start new threads while there are more scheduled jobs in the queue and the limit `max_threads` is not reached.
        startNewThreadsNoLock();
    }
    else if (need_finish_free_threads)
    {
        /// Wake exactly the excess idle threads so they can observe the new limit
        /// and exit. We do not call `wakeUpAllIdleThreadsNoLock` here because that
        /// would wipe the LIFO stack on every limit adjustment, defeating the
        /// purpose of LIFO scheduling.
        wakeUpExcessIdleThreadsNoLock();
    }
}

template <typename Thread>
size_t ThreadPoolImpl<Thread>::getMaxThreads() const