concurrent-ruby 1.0.5 → 1.1.10

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/ruby_single_thread_executor.rb

@@ -15,7 +15,6 @@ module Concurrent
         max_queue: 0,
         idletime: DEFAULT_THREAD_IDLETIMEOUT,
         fallback_policy: opts.fetch(:fallback_policy, :discard),
-        auto_terminate: opts.fetch(:auto_terminate, true)
       )
     end
   end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/ruby_thread_pool_executor.rb

@@ -23,6 +23,9 @@ module Concurrent
     # @!macro thread_pool_executor_constant_default_thread_timeout
     DEFAULT_THREAD_IDLETIMEOUT = 60
 
+    # @!macro thread_pool_executor_constant_default_synchronous
+    DEFAULT_SYNCHRONOUS = false
+
     # @!macro thread_pool_executor_attr_reader_max_length
     attr_reader :max_length
 
@@ -35,6 +38,9 @@ module Concurrent
     # @!macro thread_pool_executor_attr_reader_max_queue
     attr_reader :max_queue
 
+    # @!macro thread_pool_executor_attr_reader_synchronous
+    attr_reader :synchronous
+
     # @!macro thread_pool_executor_method_initialize
     def initialize(opts = {})
       super(opts)
@@ -87,13 +93,8 @@ module Concurrent
     end
 
     # @!visibility private
-    def ready_worker(worker)
-      synchronize { ns_ready_worker worker }
-    end
-
-    # @!visibility private
-    def worker_not_old_enough(worker)
-      synchronize { ns_worker_not_old_enough worker }
+    def ready_worker(worker, last_message)
+      synchronize { ns_ready_worker worker, last_message }
     end
 
     # @!visibility private
@@ -106,6 +107,11 @@ module Concurrent
       synchronize { @completed_task_count += 1 }
     end
 
+    # @!macro thread_pool_executor_method_prune_pool
+    def prune_pool
+      synchronize { ns_prune_pool }
+    end
+
     private
 
     # @!visibility private
@@ -114,16 +120,16 @@ module Concurrent
       @max_length      = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
       @idletime        = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
       @max_queue       = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i
+      @synchronous     = opts.fetch(:synchronous, DEFAULT_SYNCHRONOUS)
       @fallback_policy = opts.fetch(:fallback_policy, :abort)
-      raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
 
+      raise ArgumentError.new("`synchronous` cannot be set unless `max_queue` is 0") if @synchronous && @max_queue > 0
+      raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
       raise ArgumentError.new("`max_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if @max_length < DEFAULT_MIN_POOL_SIZE
       raise ArgumentError.new("`max_threads` cannot be greater than #{DEFAULT_MAX_POOL_SIZE}") if @max_length > DEFAULT_MAX_POOL_SIZE
       raise ArgumentError.new("`min_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if @min_length < DEFAULT_MIN_POOL_SIZE
       raise ArgumentError.new("`min_threads` cannot be more than `max_threads`") if min_length > max_length
 
-      self.auto_terminate = opts.fetch(:auto_terminate, true)
-
       @pool                 = [] # all workers
       @ready                = [] # used as a stash (most idle worker is at the start)
       @queue                = [] # used as queue
@@ -131,6 +137,7 @@ module Concurrent
       @scheduled_task_count = 0
       @completed_task_count = 0
       @largest_length       = 0
+      @workers_counter      = 0
       @ruby_pid             = $$ # detects if Ruby has forked
 
       @gc_interval  = opts.fetch(:gc_interval, @idletime / 2.0).to_i # undocumented
@@ -149,10 +156,11 @@ module Concurrent
       if ns_assign_worker(*args, &task) || ns_enqueue(*args, &task)
         @scheduled_task_count += 1
       else
-        handle_fallback(*args, &task)
+        return fallback_action(*args, &task)
       end
 
       ns_prune_pool if @next_gc_time < Concurrent.monotonic_time
+      nil
     end
 
     # @!visibility private
@@ -185,7 +193,7 @@ module Concurrent
     # @!visibility private
     def ns_assign_worker(*args, &task)
       # keep growing if the pool is not at the minimum yet
-      worker = (@ready.pop if @pool.size >= @min_length) || ns_add_busy_worker
+      worker, _ = (@ready.pop if @pool.size >= @min_length) || ns_add_busy_worker
       if worker
         worker << [task, args]
         true
@@ -202,6 +210,8 @@ module Concurrent
     #
     # @!visibility private
     def ns_enqueue(*args, &task)
+      return false if @synchronous
+      
       if !ns_limited_queue? || @queue.size < @max_queue
         @queue << [task, args]
         true
@@ -214,7 +224,7 @@ module Concurrent
     def ns_worker_died(worker)
       ns_remove_busy_worker worker
       replacement_worker = ns_add_busy_worker
-      ns_ready_worker replacement_worker, false if replacement_worker
+      ns_ready_worker replacement_worker, Concurrent.monotonic_time, false if replacement_worker
     end
 
     # creates new worker which has to receive work to do after it's added
@@ -224,7 +234,8 @@ module Concurrent
     def ns_add_busy_worker
       return if @pool.size >= @max_length
 
-      @pool << (worker = Worker.new(self))
+      @workers_counter += 1
+      @pool << (worker = Worker.new(self, @workers_counter))
       @largest_length = @pool.length if @pool.length > @largest_length
       worker
     end
@@ -232,29 +243,21 @@ module Concurrent
     # handle ready worker, giving it new job or assigning back to @ready
     #
     # @!visibility private
-    def ns_ready_worker(worker, success = true)
+    def ns_ready_worker(worker, last_message, success = true)
       task_and_args = @queue.shift
       if task_and_args
         worker << task_and_args
       else
         # stop workers when !running?, do not return them to @ready
         if running?
-          @ready.push(worker)
+          raise unless last_message
+          @ready.push([worker, last_message])
         else
           worker.stop
         end
       end
     end
 
-    # returns back worker to @ready which was not idle for enough time
-    #
-    # @!visibility private
-    def ns_worker_not_old_enough(worker)
-      # let's put workers coming from idle_test back to the start (as the oldest worker)
-      @ready.unshift(worker)
-      true
-    end
-
     # removes a worker which is not in not tracked in @ready
     #
     # @!visibility private
@@ -268,10 +271,17 @@ module Concurrent
     #
     # @!visibility private
     def ns_prune_pool
-      return if @pool.size <= @min_length
-
-      last_used = @ready.shift
-      last_used << :idle_test if last_used
+      now = Concurrent.monotonic_time
+      stopped_workers = 0
+      while !@ready.empty? && (@pool.size - stopped_workers > @min_length)
+        worker, last_message = @ready.first
+        if now - last_message > self.idletime
+          stopped_workers += 1
+          @ready.shift
+          worker << :stop
+        else break
+        end
+      end
 
       @next_gc_time = Concurrent.monotonic_time + @gc_interval
     end
@@ -284,6 +294,7 @@ module Concurrent
         @scheduled_task_count = 0
         @completed_task_count = 0
         @largest_length       = 0
+        @workers_counter      = 0
         @ruby_pid             = $$
       end
     end
@@ -292,11 +303,15 @@ module Concurrent
     class Worker
       include Concern::Logging
 
-      def initialize(pool)
+      def initialize(pool, id)
         # instance variables accessed only under pool's lock so no need to sync here again
         @queue  = Queue.new
         @pool   = pool
         @thread = create_worker @queue, pool, pool.idletime
+
+        if @thread.respond_to?(:name=)
+          @thread.name = [pool.name, 'worker', id].compact.join('-')
+        end
       end
 
       def <<(message)
@@ -315,19 +330,10 @@ module Concurrent
 
       def create_worker(queue, pool, idletime)
         Thread.new(queue, pool, idletime) do |my_queue, my_pool, my_idletime|
-          last_message = Concurrent.monotonic_time
           catch(:stop) do
             loop do
 
               case message = my_queue.pop
-              when :idle_test
-                if (Concurrent.monotonic_time - last_message) > my_idletime
-                  my_pool.remove_busy_worker(self)
-                  throw :stop
-                else
-                  my_pool.worker_not_old_enough(self)
-                end
-
               when :stop
                 my_pool.remove_busy_worker(self)
                 throw :stop
@@ -335,9 +341,7 @@ module Concurrent
               else
                 task, args = message
                 run_task my_pool, task, args
-                last_message = Concurrent.monotonic_time
-
-                my_pool.ready_worker(self)
+                my_pool.ready_worker(self, Concurrent.monotonic_time)
               end
             end
           end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/safe_task_executor.rb

@@ -16,10 +16,10 @@ module Concurrent
 
     # @return [Array]
     def execute(*args)
-      synchronize do
-        success = false
-        value   = reason = nil
+      success = true
+      value   = reason = nil
 
+      synchronize do
         begin
           value   = @task.call(*args)
           success = true
@@ -27,9 +27,9 @@ module Concurrent
           reason  = ex
           success = false
         end
-
-        [success, value, reason]
       end
+
+      [success, value, reason]
     end
   end
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/simple_executor_service.rb

@@ -91,7 +91,7 @@ module Concurrent
 
     private
 
-    def ns_initialize
+    def ns_initialize(*args)
       @running = Concurrent::AtomicBoolean.new(true)
       @stopped = Concurrent::Event.new
       @count = Concurrent::AtomicFixnum.new(0)

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/single_thread_executor.rb

@@ -1,3 +1,4 @@
+require 'concurrent/utility/engine'
 require 'concurrent/executor/ruby_single_thread_executor'
 
 module Concurrent
@@ -14,7 +15,7 @@ module Concurrent
                                        end
   private_constant :SingleThreadExecutorImplementation
 
-  # @!macro [attach] single_thread_executor
+  # @!macro single_thread_executor
   #
   #   A thread pool with a single thread an unlimited queue. Should the thread
   #   die for any reason it will be removed and replaced, thus ensuring that
@@ -35,7 +36,7 @@ module Concurrent
   # @!macro abstract_executor_service_public_api
   class SingleThreadExecutor < SingleThreadExecutorImplementation
 
-    # @!macro [new] single_thread_executor_method_initialize
+    # @!macro single_thread_executor_method_initialize
     #
     #   Create a new thread pool.
     #

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/thread_pool_executor.rb

@@ -15,7 +15,7 @@ module Concurrent
                                      end
   private_constant :ThreadPoolExecutorImplementation
 
-  # @!macro [attach] thread_pool_executor
+  # @!macro thread_pool_executor
   #
   #   An abstraction composed of one or more threads and a task queue. Tasks
   #   (blocks or `proc` objects) are submitted to the pool and added to the queue.
@@ -55,12 +55,12 @@ module Concurrent
   # @!macro thread_pool_executor_public_api
   class ThreadPoolExecutor < ThreadPoolExecutorImplementation
 
-    # @!macro [new] thread_pool_executor_method_initialize
+    # @!macro thread_pool_executor_method_initialize
     #
     #   Create a new thread pool.
-    #  
+    #
     #   @param [Hash] opts the options which configure the thread pool.
-    #  
+    #
     #   @option opts [Integer] :max_threads (DEFAULT_MAX_POOL_SIZE) the maximum
     #     number of threads to be created
     #   @option opts [Integer] :min_threads (DEFAULT_MIN_POOL_SIZE) When a new task is submitted
@@ -73,12 +73,13 @@ module Concurrent
     #   @option opts [Symbol] :fallback_policy (:abort) the policy for handling new
     #     tasks that are received when the queue size has reached
     #     `max_queue` or the executor has shut down
-    #  
+    #   @option opts [Boolean] :synchronous (DEFAULT_SYNCHRONOUS) whether or not a value of 0
+    #     for :max_queue means the queue must perform direct hand-off rather than unbounded.
     #   @raise [ArgumentError] if `:max_threads` is less than one
     #   @raise [ArgumentError] if `:min_threads` is less than zero
     #   @raise [ArgumentError] if `:fallback_policy` is not one of the values specified
     #     in `FALLBACK_POLICIES`
-    #  
+    #
     #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html
 
     # @!method initialize(opts = {})

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/timer_set.rb

@@ -20,7 +20,7 @@ module Concurrent
 
     # Create a new set of timed tasks.
     #
-    # @!macro [attach] executor_options
+    # @!macro executor_options
     #
     #   @param [Hash] opts the options used to specify the executor on which to perform actions
     #   @option opts [Executor] :executor when set use the given `Executor` instance.
@@ -48,11 +48,9 @@ module Concurrent
     def post(delay, *args, &task)
       raise ArgumentError.new('no block given') unless block_given?
       return false unless running?
-      opts = {
-        executor: @task_executor,
-        args: args,
-        timer_set: self
-      }
+      opts = { executor:  @task_executor,
+               args:      args,
+               timer_set: self }
       task = ScheduledTask.execute(delay, opts, &task) # may raise exception
       task.unscheduled? ? false : task
     end
@@ -74,12 +72,11 @@ module Concurrent
     # @param [Hash] opts the options to create the object with.
     # @!visibility private
     def ns_initialize(opts)
-      @queue          = Collection::NonConcurrentPriorityQueue.new(order: :min)
-      @task_executor  = Options.executor_from_options(opts) || Concurrent.global_io_executor
-      @timer_executor = SingleThreadExecutor.new
-      @condition      = Event.new
-      @ruby_pid       = $$ # detects if Ruby has forked
-      self.auto_terminate = opts.fetch(:auto_terminate, true)
+      @queue              = Collection::NonConcurrentPriorityQueue.new(order: :min)
+      @task_executor      = Options.executor_from_options(opts) || Concurrent.global_io_executor
+      @timer_executor     = SingleThreadExecutor.new
+      @condition          = Event.new
+      @ruby_pid           = $$ # detects if Ruby has forked
     end
 
     # Post the task to the internal queue.
@@ -90,7 +87,7 @@ module Concurrent
     #
     # @!visibility private
     def post_task(task)
-      synchronize{ ns_post_task(task) }
+      synchronize { ns_post_task(task) }
     end
 
     # @!visibility private
@@ -98,7 +95,7 @@ module Concurrent
       return false unless ns_running?
       ns_reset_if_forked
       if (task.initial_delay) <= 0.01
-        task.executor.post{ task.process_task }
+        task.executor.post { task.process_task }
       else
         @queue.push(task)
         # only post the process method when the queue is empty
@@ -116,7 +113,7 @@ module Concurrent
     #
     # @!visibility private
     def remove_task(task)
-      synchronize{ @queue.delete(task) }
+      synchronize { @queue.delete(task) }
     end
 
     # `ExecutorService` callback called during shutdown.
@@ -148,7 +145,7 @@ module Concurrent
         task = synchronize { @condition.reset; @queue.peek }
         break unless task
 
-        now = Concurrent.monotonic_time
+        now  = Concurrent.monotonic_time
         diff = task.schedule_time - now
 
         if diff <= 0
@@ -165,7 +162,7 @@ module Concurrent
           # queue now must have the same pop time, or a closer one, as
           # when we peeked).
           task = synchronize { @queue.pop }
-          task.executor.post{ task.process_task }
+          task.executor.post { task.process_task }
         else
           @condition.wait([diff, 60].min)
         end

data/lib/{concurrent → concurrent-ruby/concurrent}/future.rb

@@ -6,9 +6,12 @@ require 'concurrent/executor/safe_task_executor'
 
 require 'concurrent/options'
 
+# TODO (pitr-ch 14-Mar-2017): deprecate, Future, Promise, etc.
+
+
 module Concurrent
 
-  # {include:file:doc/future.md}
+  # {include:file:docs-source/future.md}
   #
   # @!macro copy_options
   #

data/lib/concurrent-ruby/concurrent/hash.rb

@@ -0,0 +1,59 @@
+require 'concurrent/utility/engine'
+require 'concurrent/thread_safe/util'
+
+module Concurrent
+
+  # @!macro concurrent_hash
+  #
+  #   A thread-safe subclass of Hash. This version locks against the object
+  #   itself for every method call, ensuring only one thread can be reading
+  #   or writing at a time. This includes iteration methods like `#each`,
+  #   which takes the lock repeatedly when reading an item.
+  #
+  #   @see http://ruby-doc.org/core/Hash.html Ruby standard library `Hash`
+
+  # @!macro internal_implementation_note
+  HashImplementation = case
+                       when Concurrent.on_cruby?
+                         # Hash is thread-safe in practice because CRuby runs
+                         # threads one at a time and does not do context
+                         # switching during the execution of C functions.
+                         ::Hash
+
+                       when Concurrent.on_jruby?
+                         require 'jruby/synchronized'
+
+                         class JRubyHash < ::Hash
+                           include JRuby::Synchronized
+                         end
+                         JRubyHash
+
+                       when Concurrent.on_rbx?
+                         require 'monitor'
+                         require 'concurrent/thread_safe/util/data_structures'
+
+                         class RbxHash < ::Hash
+                         end
+                         ThreadSafe::Util.make_synchronized_on_rbx RbxHash
+                         RbxHash
+
+                       when Concurrent.on_truffleruby?
+                         require 'concurrent/thread_safe/util/data_structures'
+
+                         class TruffleRubyHash < ::Hash
+                         end
+
+                         ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubyHash
+                         TruffleRubyHash
+
+                       else
+                         warn 'Possibly unsupported Ruby implementation'
+                         ::Hash
+                       end
+  private_constant :HashImplementation
+
+  # @!macro concurrent_hash
+  class Hash < HashImplementation
+  end
+
+end

data/lib/{concurrent → concurrent-ruby/concurrent}/immutable_struct.rb

@@ -5,7 +5,7 @@ module Concurrent
 
   # A thread-safe, immutable variation of Ruby's standard `Struct`.
   #
-  # @see http://ruby-doc.org/core-2.2.0/Struct.html Ruby standard library `Struct`
+  # @see http://ruby-doc.org/core/Struct.html Ruby standard library `Struct`
   module ImmutableStruct
     include Synchronization::AbstractStruct
 
@@ -70,6 +70,14 @@ module Concurrent
       ns_select(&block)
     end
 
+    private
+
+    # @!visibility private
+    def initialize_copy(original)
+      super(original)
+      ns_initialize_copy
+    end
+
     # @!macro struct_new
     def self.new(*args, &block)
       clazz_name = nil

data/lib/{concurrent → concurrent-ruby/concurrent}/ivar.rb

@@ -98,10 +98,10 @@ module Concurrent
       observer
     end
 
-    # @!macro [attach] ivar_set_method
+    # @!macro ivar_set_method
     #   Set the `IVar` to a value and wake or notify all threads waiting on it.
     #
-    #   @!macro [attach] ivar_set_parameters_and_exceptions
+    #   @!macro ivar_set_parameters_and_exceptions
     #     @param [Object] value the value to store in the `IVar`
     #     @yield A block operation to use for setting the value
     #     @raise [ArgumentError] if both a value and a block are given
@@ -124,7 +124,7 @@ module Concurrent
       self
     end
 
-    # @!macro [attach] ivar_fail_method
+    # @!macro ivar_fail_method
     #   Set the `IVar` to failed due to some error and wake or notify all threads waiting on it.
     #
     #   @param [Object] reason for the failure
@@ -157,9 +157,8 @@ module Concurrent
       self.observers = Collection::CopyOnWriteObserverSet.new
       set_deref_options(opts)
 
-      if value == NULL
-        @state = :pending
-      else
+      @state = :pending
+      if value != NULL
         ns_complete_without_notification(true, value, nil)
       end
     end