Method resize

src/thread_pool.rs:287–361

(&'static self, get_size: F)

impl ThreadPool {
    /// Resizes the thread pool to fill (almost) all available cores. After this
    /// returns, the pool will have between 1 and 32 workers. Returns the new
    /// size of the pool.
    ///
    /// This always leaves one core free, so that the main program loop can
    /// continue executing on it. If you have 8 cores, calling this function
    /// will add 7 workers to the pool (and then the main thread will become the
    /// 8th worker if it makes a blocking call like `join`).
    ///
    /// See [`ThreadPool::resize`] for more information about resizing.
    pub fn resize_to_available(&'static self) -> usize {
        let mut available =
            available_parallelism().map(NonZero::get).unwrap_or(1);
        available = available.saturating_sub(1).max(1);
        self.resize_to(available)
    }

    /// Resizes the pool to the specified number of threads. Returns the new
    /// size of the thread pool. The new size may be smaller than requested if
    /// all the seats in the thread pool are occupied.
    ///
    /// See [`ThreadPool::resize`] for more information about resizing.
    pub fn resize_to(&'static self, new_size: usize) -> usize {
        self.resize(|_| new_size)
    }

    /// Adds the given number of threads to the thread pool. Returns the new
    /// size of the pool. The new size may be smaller than requested if all the
    /// seats in the thread pool are occupied.
    ///
    /// See [`ThreadPool::resize`] for more information about resizing.
    pub fn grow(&'static self, added_threads: usize) -> usize {
        self.resize(|current_size| current_size.saturating_add(added_threads))
    }

    /// Removes the given number of threads from the thread pool. Returns the new
    /// size of the pool.
    ///
    /// See [`ThreadPool::resize`] for more information about resizing.
    pub fn shrink(&'static self, terminated_threads: usize) -> usize {
        self.resize(|current_size| {
            current_size.saturating_sub(terminated_threads)
        })
    }

    /// Ensures that there is at least one worker thread attached to the thread
    /// pool. This is mostly used to avoid deadlocks. This should be called
    /// before blocking on a thread pool to ensure the block will eventually be
    /// released. Returns the new size of the pool, which will be either the old
    /// size or one.
    ///
    /// See [`ThreadPool::resize_to`] for more information about resizing.
    pub fn populate(&'static self) -> usize {
        self.resize(
            |current_size| {
                if current_size == 0 { 1 } else { current_size }
            },
        )
    }