class Puma::ThreadPool

Internal Docs for A simple thread pool management object.

Each Puma “worker” has a thread pool to process requests.

First a connection to a client is made in `Puma::Server`. It is wrapped in a `Puma::Client` instance and then passed to the `Puma::Reactor` to ensure the whole request is buffered into memory. Once the request is ready, it is passed into a thread pool via the `Puma::ThreadPool#<<` operator where it is stored in a `@todo` array.

Each thread in the pool has an internal loop where it pulls a request from the `@todo` array and processes it.

Constants

SHUTDOWN_GRACE_TIME

How long, after raising the ForceShutdown of a thread during forced shutdown mode, to wait for the thread to try and finish up its work before leaving the thread to die on the vine.

Attributes

spawned[R]
trim_requested[R]
waiting[R]

Public Class Methods

clean_thread_locals() click to toggle source
# File lib/puma/thread_pool.rb, line 82
def self.clean_thread_locals
  Thread.current.keys.each do |key| # rubocop: disable Style/HashEachMethods
    Thread.current[key] = nil unless key == :__recursive_key__
  end
end
new(name, options = {}, &block) click to toggle source

Maintain a minimum of min and maximum of max threads in the pool.

The block passed is the work that will be performed in each thread.

# File lib/puma/thread_pool.rb, line 34
def initialize(name, options = {}, &block)
  @not_empty = ConditionVariable.new
  @not_full = ConditionVariable.new
  @mutex = Mutex.new

  @todo = []

  @spawned = 0
  @waiting = 0

  @name = name
  @min = Integer(options[:min_threads])
  @max = Integer(options[:max_threads])
  # Not an 'exposed' option, options[:pool_shutdown_grace_time] is used in CI
  # to shorten @shutdown_grace_time from SHUTDOWN_GRACE_TIME. Parallel CI
  # makes stubbing constants difficult.
  @shutdown_grace_time = Float(options[:pool_shutdown_grace_time] || SHUTDOWN_GRACE_TIME)
  @block = block
  @out_of_band = options[:out_of_band]
  @clean_thread_locals = options[:clean_thread_locals]
  @before_thread_start = options[:before_thread_start]
  @before_thread_exit = options[:before_thread_exit]
  @reaping_time = options[:reaping_time]
  @auto_trim_time = options[:auto_trim_time]

  @shutdown = false

  @trim_requested = 0
  @out_of_band_pending = false

  @workers = []

  @auto_trim = nil
  @reaper = nil

  @mutex.synchronize do
    @min.times do
      spawn_thread
      @not_full.wait(@mutex)
    end
  end

  @force_shutdown = false
  @shutdown_mutex = Mutex.new
end

Public Instance Methods

backlog() click to toggle source

How many objects have yet to be processed by the pool?

# File lib/puma/thread_pool.rb, line 90
def backlog
  with_mutex { @todo.size }
end
busy_threads() click to toggle source

@!attribute [r] busy_threads @version 5.0.0

# File lib/puma/thread_pool.rb, line 101
def busy_threads
  with_mutex { @spawned - @waiting + @todo.size }
end
pool_capacity() click to toggle source

@!attribute [r] pool_capacity

# File lib/puma/thread_pool.rb, line 95
def pool_capacity
  waiting + (@max - spawned)
end