123456789_123456789_123456789_123456789_123456789_

Class: Concurrent::ImmediateExecutor

Overview

Note:

Intended for use primarily in testing and debugging.

An executor service which runs all operations on the current thread, blocking as necessary. Operations are performed in the order they are received and no two operations can be performed simultaneously.

This executor service exists mainly for testing an debugging. When used it immediately runs every #post operation on the current thread, blocking that thread until the operation is complete. This can be very beneficial during testing because it makes all operations deterministic.

Constant Summary

Concern::Logging - Included

SEV_LABEL

AbstractExecutorService - Inherited

FALLBACK_POLICIES

Class Method Summary

AbstractExecutorService - Inherited

.new

Create a new thread pool.

Instance Attribute Summary

SerialExecutorService - Included

#serialized?

Does this executor guarantee serialization of its operations?

AbstractExecutorService - Inherited

#auto_terminate=

Set the auto-terminate behavior for this executor.
#auto_terminate?

Is the executor auto-terminate when the application exits?
#fallback_policy, #name,
#running?

Is the executor running?
#shutdown

Begin an orderly shutdown.
#shutdown?

Is the executor shutdown?
#shuttingdown?

Is the executor shuttingdown?
#ns_auto_terminate?

ExecutorService - Included

#can_overflow?

Does the task queue have a maximum size?
#serialized?

Does this executor guarantee serialization of its operations?

Instance Method Summary

AbstractExecutorService - Inherited

#<<

Submit a task to the executor for asynchronous processing.
#can_overflow?

Does the task queue have a maximum size?
#kill

Begin an immediate shutdown.
#post

Submit a task to the executor for asynchronous processing.
#serialized?

Does this executor guarantee serialization of its operations?
#to_s,
#wait_for_termination

Block until executor shutdown is complete or until timeout seconds have passed.
#fallback_action

Returns an action which executes the fallback_policy once the queue size reaches max_queue.
#ns_execute,
#ns_kill_execution

Callback method called when the executor has been killed.
#ns_shutdown_execution

Callback method called when an orderly shutdown has completed.

Concern::Deprecation - Included

#deprecated, #deprecated_method

ExecutorService - Included

#<<

Submit a task to the executor for asynchronous processing.
#post

Submit a task to the executor for asynchronous processing.

Concern::Logging - Included

#log

Logs through global_logger, it can be overridden by setting @logger.

Synchronization::LockableObject - Inherited

#new_condition

Constructor Details

.new ⇒ ImmediateExecutor

Creates a new executor

[ GitHub ] 

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 21



def initialize
  @stopped = Concurrent::Event.new
end


  







Instance Attribute Details



  

    #running?  ⇒ Boolean  (readonly)
  



  

    

Is the executor running?


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    true when running, false when shutting down or shutdown
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 40



def running?
  ! shutdown?
end


  








  

    #shutdown?  ⇒ Boolean  (readonly)
  



  

    

Is the executor shutdown?


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    true when shutdown, false when shutting down or running
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 50



def shutdown?
  @stopped.set?
end


  








  

    #shuttingdown?  ⇒ Boolean  (readonly)
  



  

    

Is the executor shuttingdown?


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    true when not running and not shutdown, else false
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 45



def shuttingdown?
  false
end


  







Instance Method Details



  

    #<<(task)  ⇒ self 
  



  

    

Submit a task to the executor for asynchronous processing.


  





  
Parameters:


    
  
  • 
    task
    (Proc)
—    
    

    the asynchronous task to perform
    

    
  
    • 



Returns:


    
  
  • 
    (self)
—    
    

    returns itself
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 34



def <<(task)
  post(&task)
  self
end


  








  

    #kill  
  



  

    

Alias for #shutdown.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 59



alias_method :kill, :shutdown


  








  

    #post(*args) { ... } ⇒ Boolean 
  



  

    

Submit a task to the executor for asynchronous processing.


  





  
Parameters:


    
  
  • 
    args
    (Array)
—    
    

    zero or more arguments to be passed to the task
    

    
  
    • 



Yields:


    
  
  • 
    
    
    

    the asynchronous task to perform
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    true if the task is queued, false if the executor is not running
    

    
  
    • 



Raises:


    
  
  • 
    (ArgumentError)
—    
    

    if no task is given
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 26



def post(*args, &task)
  raise ArgumentError.new('no block given') unless block_given?
  return false unless running?
  task.call(*args)
  true
end


  








  

    #shutdown   (readonly)
    Also known as: #kill
  



  

    

Begin an orderly shutdown. Tasks already in the queue will be executed, but no new tasks will be accepted. Has no additional effect if the thread pool is not running.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 55



def shutdown
  @stopped.set
  true
end


  








  

    #wait_for_termination(timeout = nil)  ⇒ Boolean 
  



  

    
  

    Note:
    


Does not initiate shutdown or termination. Either #shutdown or #kill must be called before this method (or on another thread).



  




Block until executor shutdown is complete or until timeout seconds have passed.


  





  
Parameters:


    
  
  • 
    timeout
    (Integer)
    (defaults to: nil)
—    
    

    the maximum number of seconds to wait for shutdown to complete
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    true if shutdown complete or false on timeout
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/executor/immediate_executor.rb', line 62



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