Class: Concurrent::SerializedExecution

Inherits:

Concurrent::Synchronization::LockableObject

• Object
• Concurrent::Synchronization::LockableObject
• Concurrent::SerializedExecution

Defined in:

lib/concurrent-ruby/concurrent/executor/serialized_execution.rb

Overview

Ensures passed jobs in a serialized order never running at the same time.

Defined Under Namespace

Classes: Job

Instance Method Summary

• #initialize ⇒ SerializedExecution constructor

  A new instance of SerializedExecution.

• #post(executor, *args) { ... } ⇒ Boolean

  Submit a task to the executor for asynchronous processing.

• #posts(posts) ⇒ undocumented

  As #post but allows to submit multiple tasks at once, it's guaranteed that they will not be interleaved by other tasks.

Constructor Details

#initialize ⇒ SerializedExecution

Returns a new instance of SerializedExecution.

# File 'lib/concurrent-ruby/concurrent/executor/serialized_execution.rb', line 11

def initialize()
  super()
  synchronize { ns_initialize }
end

Instance Method Details

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

Submit a task to the executor for asynchronous processing.

Parameters:

• executor (Executor) —

  to be used for this job

• 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

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

def post(executor, *args, &task)
  posts [[executor, args, task]]
  true
end

#posts(posts) ⇒ undocumented

As #post but allows to submit multiple tasks at once, it's guaranteed that they will not be interleaved by other tasks.

Parameters:

• posts (Array<Array(ExecutorService, Array<Object>, Proc)>) —

  array of triplets where first is a ExecutorService, second is array of args for task, third is a task (Proc)

# File 'lib/concurrent-ruby/concurrent/executor/serialized_execution.rb', line 44

def posts(posts)
  # if can_overflow?
  #   raise ArgumentError, 'SerializedExecution does not support thread-pools which can overflow'
  # end

  return nil if posts.empty?

  jobs = posts.map { |executor, args, task| Job.new executor, args, task }

  job_to_post = synchronize do
    if @being_executed
      @stash.push(*jobs)
      nil
    else
      @being_executed = true
      @stash.push(*jobs[1..-1])
      jobs.first
    end
  end

  call_job job_to_post if job_to_post
  true
end