class ActionCable::Server::Base

Also, this is the server instance used for broadcasting. See Broadcasting for more information.
is also used by the user to reach the RemoteConnections object, which is used for finding and disconnecting connections across all servers.
A singleton ActionCable::Server instance is available via ActionCable.server. It’s used by the Rack process that starts the Action Cable server, but

def self.logger; config.logger; end 

def self.logger; config.logger; end

def call(env)

Called by Rack to setup the server. 
def call(env)
  setup_heartbeat_timer
  config.connection_class.call.new(self, env).process
end

def connection_identifiers

All of the identifiers applied to the connection class associated with this server. 
def connection_identifiers
  config.connection_class.call.identifiers
end

def disconnect(identifiers)

Disconnect all the connections identified by `identifiers` on this server or any others via RemoteConnections. 
def disconnect(identifiers)
  remote_connections.where(identifiers).disconnect
end

def event_loop 

def event_loop
  @event_loop || @mutex.synchronize { @event_loop ||= ActionCable::Connection::StreamEventLoop.new }
end

def initialize 

def initialize
  @mutex = Monitor.new
  @remote_connections = @event_loop = @worker_pool = @pubsub = nil
end

def pubsub

Adapter used for all streams/broadcasting. 
def pubsub
  @pubsub || @mutex.synchronize { @pubsub ||= config.pubsub_adapter.new(self) }
end

def remote_connections

Gateway to RemoteConnections. See that class for details. 
def remote_connections
  @remote_connections || @mutex.synchronize { @remote_connections ||= RemoteConnections.new(self) }
end

def restart 

def restart
  connections.each(&:close)
  @mutex.synchronize do
    # Shutdown the worker pool
    @worker_pool.halt if @worker_pool
    @worker_pool = nil
    # Shutdown the pub/sub adapter
    @pubsub.shutdown if @pubsub
    @pubsub = nil
  end
end

def worker_pool

database connection pool instead.
the database connection pool and block while they wait for other workers to release their connections. Use a smaller worker pool or a larger
Also, ensure that your database connection pool size is as least as large as your worker pool size. Otherwise, workers may oversubscribe

connections.
Plan your deployment accordingly: 5 servers each running 5 Puma workers each running an 8-thread worker pool means at least 200 database
Using Active Record, Redis, etc within your channel actions means you'll get a separate connection from each thread in the worker pool.

at 4 worker threads by default. Tune the size yourself with config.action_cable.worker_pool_size.
The worker pool is an executor service that's backed by a pool of threads working from a task queue. The thread pool size maxes out
The worker pool is where we run connection callbacks and channel actions. We do as little as possible on the server's main thread. 
def worker_pool
  @worker_pool || @mutex.synchronize { @worker_pool ||= ActionCable::Server::Worker.new(max_size: config.worker_pool_size) }
end