class Concurrent::SimpleExecutorService

@note Intended for use primarily in testing and debugging.
lead to suboptimal performance.
executor implementation. In production this executor will likely
debugging because it decouples the using code from the underlying
resource pooling. This can be very beneficial during testing and
and management is expensive in Ruby and this executor performs no
library. It exists mainly for testing an debugging. Thread creation
This is perhaps the most inefficient executor service in this
independently operating thread.
An executor service in which every operation spawns a new,

def self.<<(task)

@!macro executor_service_method_left_shift 
def self.<<(task)
  post(&task)
  self
end

def self.post(*args)

@!macro executor_service_method_post 
def self.post(*args)
  raise ArgumentError.new('no block given') unless block_given?
  Thread.new(*args) do
    Thread.current.abort_on_exception = false
    yield(*args)
  end
  true
end

def <<(task)

@!macro executor_service_method_left_shift 
def <<(task)
  post(&task)
  self
end

def kill

@!macro executor_service_method_kill 
def kill
  @running.make_false
  @stopped.set
  true
end

def ns_initialize 

def ns_initialize
  @running = Concurrent::AtomicBoolean.new(true)
  @stopped = Concurrent::Event.new
  @count = Concurrent::AtomicFixnum.new(0)
end

def post(*args, &task)

@!macro executor_service_method_post 
def post(*args, &task)
  raise ArgumentError.new('no block given') unless block_given?
  return false unless running?
  @count.increment
  Thread.new(*args) do
    Thread.current.abort_on_exception = false
    begin
      yield(*args)
    ensure
      @count.decrement
      @stopped.set if @running.false? && @count.value == 0
    end
  end
end

def running?

@!macro executor_service_method_running_question 
def running?
  @running.true?
end

def shutdown

@!macro executor_service_method_shutdown 
def shutdown
  @running.make_false
  @stopped.set if @count.value == 0
  true
end

def shutdown?

@!macro executor_service_method_shutdown_question 
def shutdown?
  @stopped.set?
end

def shuttingdown?

@!macro executor_service_method_shuttingdown_question 
def shuttingdown?
  @running.false? && ! @stopped.set?
end

def wait_for_termination(timeout = nil)

@!macro executor_service_method_wait_for_termination 
def wait_for_termination(timeout = nil)
  @stopped.wait(timeout)
end