concurrent-ruby 0.7.0.rc0-x86-solaris-2.11 → 0.7.0.rc1-x86-solaris-2.11

data/lib/concurrent/executor/java_fixed_thread_pool.rb

@@ -17,14 +17,22 @@ if RUBY_PLATFORM == 'java'
       #
       # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
       def initialize(num_threads, opts = {})
-        @overflow_policy = opts.fetch(:overflow_policy, :abort)
-        @max_queue = 0
 
-        raise ArgumentError.new('number of threads must be greater than zero') if num_threads < 1
-        raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
+        opts = {
+            min_threads: num_threads,
+            max_threads: num_threads
+        }.merge(opts)
+        super(opts)
 
-        @executor = java.util.concurrent.Executors.newFixedThreadPool(num_threads)
-        @executor.setRejectedExecutionHandler(OVERFLOW_POLICIES[@overflow_policy].new)
+
+        #@overflow_policy = opts.fetch(:overflow_policy, :abort)
+        #@max_queue = 0
+        #
+        #raise ArgumentError.new('number of threads must be greater than zero') if num_threads < 1
+        #raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
+        #
+        #@executor = java.util.concurrent.Executors.newFixedThreadPool(num_threads)
+        #@executor.setRejectedExecutionHandler(OVERFLOW_POLICIES[@overflow_policy].new)
 
         set_shutdown_hook
       end

data/lib/concurrent/executor/java_single_thread_executor.rb

@@ -6,6 +6,7 @@ if RUBY_PLATFORM == 'java'
     # @!macro single_thread_executor
     class JavaSingleThreadExecutor
       include JavaExecutor
+      include SerialExecutor
 
       # Create a new thread pool.
       #

data/lib/concurrent/executor/java_thread_pool_executor.rb

@@ -71,6 +71,7 @@ if RUBY_PLATFORM == 'java'
 
         raise ArgumentError.new('max_threads must be greater than zero') if max_length <= 0
         raise ArgumentError.new('min_threads cannot be less than zero') if min_length < 0
+        raise ArgumentError.new('min_threads cannot be more than max_threads') if min_length > max_length
         raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
 
         if min_length == 0 && @max_queue == 0
@@ -89,6 +90,7 @@ if RUBY_PLATFORM == 'java'
         set_shutdown_hook
       end
 
+    # @!macro executor_module_method_can_overflow_question
       def can_overflow?
         @max_queue != 0
       end
@@ -171,16 +173,7 @@ if RUBY_PLATFORM == 'java'
       #
       # @return [Boolean] `true` when running, `false` when shutting down or shutdown
       def running?
-        super && ! @executor.isTerminating
-      end
-
-      # 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.
-      def shutdown
-        super
-        @executor.getQueue.clear
-        nil
+        super && !@executor.isTerminating
       end
     end
   end

data/lib/concurrent/executor/per_thread_executor.rb

@@ -1,24 +1,100 @@
+require 'concurrent/atomics'
+require 'concurrent/executor/executor'
+
 module Concurrent
 
+  # An executor service in which every operation spawns a new,
+  # independently operating thread.
+  #
+  # This is perhaps the most inefficient executor service in this
+  # library. It exists mainly for testing an debugging. Thread creation
+  # and management is expensive in Ruby and this executor performs no
+  # resource pooling. This can be very beneficial during testing and
+  # debugging because it decouples the using code from the underlying
+  # executor implementation. In production this executor will likely
+  # lead to suboptimal performance.
+  #
+  # @note Intended for use primarily in testing and debugging.
   class PerThreadExecutor
     include Executor
 
+    # Creates a new executor
+    def initialize
+      @running = Concurrent::AtomicBoolean.new(true)
+      @stopped = Concurrent::Event.new
+      @count = Concurrent::AtomicFixnum.new(0)
+    end
+
+    # @!macro executor_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
-      return true
+      true
     end
 
+    # @!macro executor_method_left_shift
+    def self.<<(task)
+      post(&task)
+      self
+    end
+
+    # @!macro executor_method_post
     def post(*args, &task)
-      return PerThreadExecutor.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
 
+    # @!macro executor_method_left_shift
     def <<(task)
-      PerThreadExecutor.post(&task)
-      return self
+      post(&task)
+      self
+    end
+
+    # @!macro executor_method_running_question
+    def running?
+      @running.true?
+    end
+
+    # @!macro executor_method_shuttingdown_question
+    def shuttingdown?
+      @running.false? && ! @stopped.set?
+    end
+
+    # @!macro executor_method_shutdown_question
+    def shutdown?
+      @stopped.set?
+    end
+
+    # @!macro executor_method_shutdown
+    def shutdown
+      @running.make_false
+      @stopped.set if @count.value == 0
+      true
+    end
+
+    # @!macro executor_method_kill
+    def kill
+      @running.make_false
+      @stopped.set
+      true
+    end
+
+    # @!macro executor_method_wait_for_termination
+    def wait_for_termination(timeout = nil)
+      @stopped.wait(timeout)
     end
   end
 end

data/lib/concurrent/executor/ruby_cached_thread_pool.rb

@@ -19,7 +19,7 @@ module Concurrent
       opts = opts.merge(
         min_threads: 0,
         max_threads: DEFAULT_MAX_POOL_SIZE,
-        num_threads: overflow_policy,
+        overflow_policy: overflow_policy,
         max_queue: DEFAULT_MAX_QUEUE_SIZE,
         idletime: DEFAULT_THREAD_IDLETIMEOUT
       )

data/lib/concurrent/executor/ruby_fixed_thread_pool.rb

@@ -19,13 +19,13 @@ module Concurrent
       raise ArgumentError.new('number of threads must be greater than zero') if num_threads < 1
       raise ArgumentError.new("#{overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.include?(overflow_policy)
 
-      opts = opts.merge(
+      opts = {
         min_threads: num_threads,
         max_threads: num_threads,
-        num_threads: overflow_policy,
+        overflow_policy: overflow_policy,
         max_queue: DEFAULT_MAX_QUEUE_SIZE,
-        idletime: 0
-      )
+        idletime: DEFAULT_THREAD_IDLETIMEOUT,
+      }.merge(opts)
       super(opts)
     end
   end

data/lib/concurrent/executor/ruby_single_thread_executor.rb

@@ -5,6 +5,7 @@ module Concurrent
   # @!macro single_thread_executor
   class RubySingleThreadExecutor
     include RubyExecutor
+    include SerialExecutor
 
     # Create a new thread pool.
     #

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -86,6 +86,7 @@ module Concurrent
       raise ArgumentError.new('max_threads must be greater than zero') if @max_length <= 0
       raise ArgumentError.new('min_threads cannot be less than zero') if @min_length < 0
       raise ArgumentError.new("#{overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.include?(@overflow_policy)
+      raise ArgumentError.new('min_threads cannot be more than max_threads') if min_length > max_length
 
       init_executor
 
@@ -99,6 +100,7 @@ module Concurrent
       @last_gc_time = Time.now.to_f - [1.0, (@gc_interval * 2.0)].max
     end
 
+    # @!macro executor_module_method_can_overflow_question
     def can_overflow?
       @max_queue != 0
     end

data/lib/concurrent/executor/serialized_execution.rb

@@ -1,3 +1,5 @@
+require 'delegate'
+require 'concurrent/executor/executor'
 require 'concurrent/logging'
 
 module Concurrent
@@ -85,6 +87,27 @@ module Concurrent
 
       call_job job if job
     end
+  end
+
+  # A wrapper/delegator for any `Executor` or `ExecutorService` that
+  # guarantees serialized execution of tasks.
+  #
+  # @see [SimpleDelegator](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/delegate/rdoc/SimpleDelegator.html)
+  # @see Concurrent::SerializedExecution
+  class SerializedExecutionDelegator < SimpleDelegator
+    include SerialExecutor
 
+    def initialize(executor)
+      @executor = executor
+      @serializer = SerializedExecution.new
+      super(executor)
+    end
+
+    # @!macro executor_method_post
+    def post(*args, &task)
+      raise ArgumentError.new('no block given') unless block_given?
+      return false unless running?
+      @serializer.post(@executor, *args, &task)
+    end
   end
 end

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.7.0.rc0'
+  VERSION = '0.7.0.rc1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.0.rc0
+  version: 0.7.0.rc1
 platform: x86-solaris-2.11
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-18 00:00:00.000000000 Z
+date: 2014-06-27 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -49,7 +49,6 @@ files:
 - lib/concurrent/atomic/event.rb
 - lib/concurrent/atomic/thread_local_var.rb
 - lib/concurrent/atomic_reference/concurrent_update_error.rb
-- lib/concurrent/atomic_reference/delegated_update.rb
 - lib/concurrent/atomic_reference/direct_update.rb
 - lib/concurrent/atomic_reference/jruby.rb
 - lib/concurrent/atomic_reference/mutex_atomic.rb
@@ -101,7 +100,6 @@ files:
 - lib/concurrent/options_parser.rb
 - lib/concurrent/promise.rb
 - lib/concurrent/scheduled_task.rb
-- lib/concurrent/supervisor.rb
 - lib/concurrent/timer_task.rb
 - lib/concurrent/tvar.rb
 - lib/concurrent/utilities.rb

data/lib/concurrent/atomic_reference/delegated_update.rb

@@ -1,28 +0,0 @@
-require 'concurrent/atomic_reference/concurrent_update_error'
-
-module Concurrent
-
-  # Define update methods that delegate to @ref field
-  class Atomic
-    # Pass the current value to the given block, replacing it
-    # with the block's result. May retry if the value changes
-    # during the block's execution.
-    def update
-      true until @ref.compare_and_set(old_value = @ref.get, new_value = yield(old_value))
-      new_value
-    end
-
-    def try_update
-      old_value = @ref.get
-      new_value = yield old_value
-      unless @ref.compare_and_set(old_value, new_value)
-        if $VERBOSE
-          raise ConcurrentUpdateError, "Update failed"
-        else
-          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
-        end
-      end
-      new_value
-    end
-  end
-end

data/lib/concurrent/supervisor.rb

@@ -1,343 +0,0 @@
-require 'thread'
-
-require 'concurrent/errors'
-
-module Concurrent
-
-  class Supervisor
-
-    DEFAULT_MONITOR_INTERVAL = 1
-    RESTART_STRATEGIES = [:one_for_one, :one_for_all, :rest_for_one]
-    DEFAULT_MAX_RESTART = 5
-    DEFAULT_MAX_TIME = 60
-    WORKER_API = {run: 0, stop: 0, running?: 0}
-
-    CHILD_TYPES = [:worker, :supervisor]
-    CHILD_RESTART_OPTIONS = [:permanent, :transient, :temporary]
-
-    WorkerContext = Struct.new(:worker, :type, :restart) do
-      attr_accessor :thread
-      attr_accessor :terminated
-
-      def alive?() return thread && thread.alive?; end
-
-      def needs_restart?
-        return false if thread && thread.alive?
-        return false if terminated
-        case self.restart
-        when :permanent
-          return true
-        when :transient
-          return thread.nil? || thread.status.nil?
-        else #when :temporary
-          return false
-        end
-      end
-    end
-
-    WorkerCounts = Struct.new(:specs, :supervisors, :workers) do
-      attr_accessor :status
-      def add(context)
-        self.specs += 1
-        self.supervisors += 1 if context.type == :supervisor
-        self.workers += 1 if context.type == :worker
-      end
-      def active() sleeping + running + aborting end
-      def sleeping() @status.reduce(0){|x, s| x += (s == 'sleep' ? 1 : 0) } end
-      def running() @status.reduce(0){|x, s| x += (s == 'run' ? 1 : 0) } end
-      def aborting() @status.reduce(0){|x, s| x += (s == 'aborting' ? 1 : 0) } end
-      def stopped() @status.reduce(0){|x, s| x += (s == false ? 1 : 0) } end
-      def abend() @status.reduce(0){|x, s| x += (s.nil? ? 1 : 0) } end
-    end
-
-    attr_reader :monitor_interval
-    attr_reader :restart_strategy
-    attr_reader :max_restart
-    attr_reader :max_time
-
-    alias_method :strategy, :restart_strategy
-    alias_method :max_r, :max_restart
-    alias_method :max_t, :max_time
-
-    def initialize(opts = {})
-      warn '[EXPERIMENTAL] Supervisor is being completely rewritten and will change soon.'
-      @restart_strategy = opts[:restart_strategy] || opts[:strategy] || :one_for_one
-      @monitor_interval = (opts[:monitor_interval] || DEFAULT_MONITOR_INTERVAL).to_f
-      @max_restart = (opts[:max_restart] || opts[:max_r] || DEFAULT_MAX_RESTART).to_i
-      @max_time = (opts[:max_time] || opts[:max_t] || DEFAULT_MAX_TIME).to_i
-
-      raise ArgumentError.new(":#{@restart_strategy} is not a valid restart strategy") unless RESTART_STRATEGIES.include?(@restart_strategy)
-      raise ArgumentError.new(':monitor_interval must be greater than zero') unless @monitor_interval > 0.0
-      raise ArgumentError.new(':max_restart must be greater than zero') unless @max_restart > 0
-      raise ArgumentError.new(':max_time must be greater than zero') unless @max_time > 0
-
-      @running = false
-      @mutex = Mutex.new
-      @workers = []
-      @monitor = nil
-
-      @count = WorkerCounts.new(0, 0, 0)
-      @restart_times = []
-
-      add_worker(opts[:worker]) unless opts[:worker].nil?
-      add_workers(opts[:workers]) unless opts[:workers].nil?
-    end
-
-    def run!
-      @mutex.synchronize do
-        raise StandardError.new('already running') if @running
-        @running = true
-        @monitor = Thread.new do
-          Thread.current.abort_on_exception = false
-          monitor
-        end
-      end
-      Thread.pass
-    end
-
-    def run
-      @mutex.synchronize do
-        raise StandardError.new('already running') if @running
-        @running = true
-      end
-      monitor
-      true
-    end
-
-    def stop
-      @mutex.synchronize do
-        return true unless @running
-
-        @running = false
-        unless @monitor.nil?
-          @monitor.run if @monitor.status == 'sleep'
-          if @monitor.join(0.1).nil?
-            @monitor.kill
-          end
-          @monitor = nil
-        end
-        @restart_times.clear
-
-        @workers.length.times do |i|
-          context = @workers[-1-i]
-          terminate_worker(context)
-        end
-        prune_workers
-      end
-
-      true
-    end
-
-    def running?
-      @mutex.synchronize { @running }
-    end
-
-    def length
-      @mutex.synchronize { @workers.length }
-    end
-    alias_method :size, :length
-
-    def current_restart_count
-      @restart_times.length
-    end
-
-    def count
-      @mutex.synchronize do
-        @count.status = @workers.collect{|w| w.thread ? w.thread.status : false }
-        @count.dup.freeze
-      end
-    end
-
-    def add_worker(worker, opts = {})
-      return nil if worker.nil? || ! behaves_as_worker?(worker)
-      @mutex.synchronize {
-        restart = opts[:restart] || :permanent
-        type = opts[:type] || (worker.is_a?(Supervisor) ? :supervisor : nil) || :worker
-        raise ArgumentError.new(":#{restart} is not a valid restart option") unless CHILD_RESTART_OPTIONS.include?(restart)
-        raise ArgumentError.new(":#{type} is not a valid child type") unless CHILD_TYPES.include?(type)
-        context = WorkerContext.new(worker, type, restart)
-        @workers << context
-        @count.add(context)
-        worker.run if @running
-        context.object_id
-      }
-    end
-    alias_method :add_child, :add_worker
-
-    def add_workers(workers, opts = {})
-      workers.collect do |worker|
-        add_worker(worker, opts)
-      end
-    end
-    alias_method :add_children, :add_workers
-
-    def remove_worker(worker_id)
-      @mutex.synchronize do
-        index, context = find_worker(worker_id)
-        break(nil) if context.nil?
-        break(false) if context.alive?
-        @workers.delete_at(index)
-        context.worker
-      end
-    end
-    alias_method :remove_child, :remove_worker
-
-    def stop_worker(worker_id)
-      @mutex.synchronize do
-        return true unless @running
-
-        index, context = find_worker(worker_id)
-        break(nil) if index.nil?
-        context.terminated = true
-        terminate_worker(context)
-        @workers.delete_at(index) if @workers[index].restart == :temporary
-        true
-      end
-    end
-    alias_method :stop_child, :stop_worker
-
-    def start_worker(worker_id)
-      @mutex.synchronize do
-        return false unless @running
-
-        index, context = find_worker(worker_id)
-        break(nil) if context.nil?
-        context.terminated = false
-        run_worker(context) unless context.alive?
-        true
-      end
-    end
-    alias_method :start_child, :start_worker
-
-    def restart_worker(worker_id)
-      @mutex.synchronize do
-        return false unless @running
-
-        index, context = find_worker(worker_id)
-        break(nil) if context.nil?
-        break(false) if context.restart == :temporary
-        context.terminated = false
-        terminate_worker(context)
-        run_worker(context)
-        true
-      end
-    end
-    alias_method :restart_child, :restart_worker
-
-    private
-
-    def behaves_as_worker?(obj)
-      WORKER_API.each do |method, arity|
-        break(false) unless obj.respond_to?(method) && obj.method(method).arity == arity
-        true
-      end
-    end
-
-    def monitor
-      @workers.each{|context| run_worker(context)}
-      loop do
-        sleep(@monitor_interval)
-        break unless running?
-        @mutex.synchronize do
-          prune_workers
-          self.send(@restart_strategy)
-        end
-        break unless running?
-      end
-    rescue MaxRestartFrequencyError => ex
-      stop
-    end
-
-    def run_worker(context)
-      context.thread = Thread.new do
-        Thread.current.abort_on_exception = false
-        context.worker.run
-      end
-      context
-    end
-
-    def terminate_worker(context)
-      if context.alive?
-        context.worker.stop
-        Thread.pass
-      end
-    rescue Exception => ex
-      begin
-        Thread.kill(context.thread)
-      rescue
-        # suppress
-      end
-    ensure
-      context.thread = nil
-    end
-
-    def prune_workers
-      @workers.delete_if{|w| w.restart == :temporary && ! w.alive? }
-    end
-
-    def find_worker(worker_id)
-      index = @workers.find_index{|worker| worker.object_id == worker_id}
-      if index.nil?
-        [nil, nil]
-      else
-        [index, @workers[index]]
-      end
-    end
-
-    def exceeded_max_restart_frequency?
-      @restart_times.unshift(Time.now.to_i)
-      diff = (@restart_times.first - @restart_times.last).abs
-      if @restart_times.length >= @max_restart && diff <= @max_time
-        return true
-      elsif diff >= @max_time
-        @restart_times.pop
-      end
-      false
-    end
-
-    #----------------------------------------------------------------
-    # restart strategies
-
-    def one_for_one
-      @workers.each do |context|
-        if context.needs_restart?
-          raise MaxRestartFrequencyError if exceeded_max_restart_frequency?
-          run_worker(context)
-        end
-      end
-    end
-
-    def one_for_all
-      restart = false
-
-      restart = @workers.each do |context|
-        if context.needs_restart?
-          raise MaxRestartFrequencyError if exceeded_max_restart_frequency?
-          break(true)
-        end
-      end
-
-      if restart
-        @workers.each do |context|
-          terminate_worker(context)
-        end
-        @workers.each{|context| run_worker(context)}
-      end
-    end
-
-    def rest_for_one
-      restart = false
-
-      @workers.each do |context|
-        if restart
-          terminate_worker(context)
-        elsif context.needs_restart?
-          raise MaxRestartFrequencyError if exceeded_max_restart_frequency?
-          restart = true
-        end
-      end
-
-      one_for_one if restart
-    end
-  end
-end