concurrent-ruby 1.1.8 → 1.1.10

data/lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb

@@ -75,28 +75,31 @@ module Concurrent
 
     private
 
-    # Handler which executes the `fallback_policy` once the queue size
-    # reaches `max_queue`.
+    # Returns an action which executes the `fallback_policy` once the queue
+    # size reaches `max_queue`. The reason for the indirection of an action
+    # is so that the work can be deferred outside of synchronization.
     #
     # @param [Array] args the arguments to the task which is being handled.
     #
     # @!visibility private
-    def handle_fallback(*args)
+    def fallback_action(*args)
       case fallback_policy
       when :abort
-        raise RejectedExecutionError
+        lambda { raise RejectedExecutionError }
       when :discard
-        false
+        lambda { false }
       when :caller_runs
-        begin
-          yield(*args)
-        rescue => ex
-          # let it fail
-          log DEBUG, ex
-        end
-        true
+        lambda {
+          begin
+            yield(*args)
+          rescue => ex
+            # let it fail
+            log DEBUG, ex
+          end
+          true
+        }
       else
-        fail "Unknown fallback policy #{fallback_policy}"
+        lambda { fail "Unknown fallback policy #{fallback_policy}" }
       end
     end
 

data/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb

@@ -71,9 +71,16 @@ module Concurrent
   #   @return [Integer] Number of tasks that may be enqueued before reaching `max_queue` and rejecting
   #     new tasks. A value of -1 indicates that the queue may grow without bound.
 
-
-
-
+  # @!macro thread_pool_executor_method_prune_pool
+  #   Prune the thread pool of unneeded threads
+  #
+  #   What is being pruned is controlled by the min_threads and idletime
+  #   parameters passed at pool creation time
+  #
+  #   This is a no-op on some pool implementation (e.g. the Java one).  The Ruby
+  #   pool will auto-prune each time a new job is posted. You will need to call
+  #   this method explicitely in case your application post jobs in bursts (a
+  #   lot of jobs and then nothing for long periods)
 
   # @!macro thread_pool_executor_public_api
   #
@@ -111,6 +118,9 @@ module Concurrent
   #
   #   @!method can_overflow?
   #     @!macro executor_service_method_can_overflow_question
+  #
+  #   @!method prune_pool
+  #     @!macro thread_pool_executor_method_prune_pool
 
 
 

data/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb

@@ -20,7 +20,7 @@ if Concurrent.on_jruby?
 
       def post(*args, &task)
         raise ArgumentError.new('no block given') unless block_given?
-        return handle_fallback(*args, &task) unless running?
+        return fallback_action(*args, &task).call unless running?
         @executor.submit Job.new(args, task)
         true
       rescue Java::JavaUtilConcurrent::RejectedExecutionException

data/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb

@@ -93,6 +93,10 @@ if Concurrent.on_jruby?
         super && !@executor.isTerminating
       end
 
+      # @!macro thread_pool_executor_method_prune_pool
+      def prune_pool
+      end
+
       private
 
       def ns_initialize(opts)

data/lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb

@@ -16,10 +16,16 @@ module Concurrent
 
     def post(*args, &task)
       raise ArgumentError.new('no block given') unless block_given?
-      synchronize do
-        # If the executor is shut down, reject this task
-        return handle_fallback(*args, &task) unless running?
-        ns_execute(*args, &task)
+      deferred_action = synchronize {
+        if running?
+          ns_execute(*args, &task)
+        else
+          fallback_action(*args, &task)
+        end
+      }
+      if deferred_action
+        deferred_action.call
+      else
         true
       end
     end

data/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb

@@ -93,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
@@ -112,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
@@ -156,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
@@ -192,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
@@ -223,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
@@ -242,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
@@ -278,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
@@ -330,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
@@ -350,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-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-ruby/concurrent/map.rb

@@ -15,7 +15,10 @@ module Concurrent
                         when Concurrent.on_cruby?
                           require 'concurrent/collection/map/mri_map_backend'
                           MriMapBackend
-                        when Concurrent.on_rbx? || Concurrent.on_truffleruby?
+                        when Concurrent.on_truffleruby? && defined?(::TruffleRuby::ConcurrentMap)
+                          require 'concurrent/collection/map/truffleruby_map_backend'
+                          TruffleRubyMapBackend
+                        when Concurrent.on_truffleruby? || Concurrent.on_rbx?
                           require 'concurrent/collection/map/atomic_reference_map_backend'
                           AtomicReferenceMapBackend
                         else
@@ -114,7 +117,7 @@ module Concurrent
     #   @return [true, false] true if deleted
     #   @!macro map.atomic_method
 
-
+    #
     def initialize(options = nil, &block)
       if options.kind_of?(::Hash)
         validate_options_hash!(options)
@@ -143,8 +146,15 @@ module Concurrent
       end
     end
 
+    # Set a value with key
+    # @param [Object] key
+    # @param [Object] value
+    # @return [Object] the new value
+    def []=(key, value)
+      super
+    end
+
     alias_method :get, :[]
-    # TODO (pitr-ch 30-Oct-2018): doc
     alias_method :put, :[]=
 
     # Get a value with key, or default_value when key is absent,
@@ -271,7 +281,6 @@ module Concurrent
       each_pair { |k, v| return k if v == value }
       nil
     end unless method_defined?(:key)
-    alias_method :index, :key if RUBY_VERSION < '1.9'
 
     # Is map empty?
     # @return [true, false]

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

@@ -250,6 +250,7 @@ module Concurrent
           realize(@promise_body)
         end
       else
+        compare_and_set_state(:pending, :unscheduled)
         @parent.execute
       end
       self

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

@@ -58,29 +58,42 @@ module Concurrent
   # @example Basic usage
   #
   #   require 'concurrent'
-  #   require 'thread'   # for Queue
-  #   require 'open-uri' # for open(uri)
+  #   require 'csv'
+  #   require 'open-uri'
   #
   #   class Ticker
-  #     def get_year_end_closing(symbol, year)
-  #       uri = "http://ichart.finance.yahoo.com/table.csv?s=#{symbol}&a=11&b=01&c=#{year}&d=11&e=31&f=#{year}&g=m"
-  #       data = open(uri) {|f| f.collect{|line| line.strip } }
-  #       data[1].split(',')[4].to_f
-  #     end
+  #     def get_year_end_closing(symbol, year, api_key)
+  #      uri = "https://www.alphavantage.co/query?function=TIME_SERIES_MONTHLY&symbol=#{symbol}&apikey=#{api_key}&datatype=csv"
+  #      data = []
+  #      csv = URI.parse(uri).read
+  #      if csv.include?('call frequency')
+  #        return :rate_limit_exceeded
+  #      end
+  #      CSV.parse(csv, headers: true) do |row|
+  #        data << row['close'].to_f if row['timestamp'].include?(year.to_s)
+  #      end
+  #      year_end = data.first
+  #      year_end
+  #    rescue => e
+  #      p e
+  #    end
   #   end
   #
+  #   api_key = ENV['ALPHAVANTAGE_KEY']
+  #   abort(error_message) unless api_key
+  #
   #   # Future
-  #   price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013) }
+  #   price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013, api_key) }
   #   price.state #=> :pending
-  #   sleep(1)    # do other stuff
-  #   price.value #=> 63.65
-  #   price.state #=> :fulfilled
+  #   price.pending? #=> true
+  #   price.value(0) #=> nil (does not block)
   #
-  #   # ScheduledTask
-  #   task = Concurrent::ScheduledTask.execute(2){ Ticker.new.get_year_end_closing('INTC', 2013) }
-  #   task.state #=> :pending
-  #   sleep(3)   # do other stuff
-  #   task.value #=> 25.96
+  #    sleep(1)    # do other stuff
+  #
+  #   price.value #=> 63.65 (after blocking if necessary)
+  #   price.state #=> :fulfilled
+  #   price.fulfilled? #=> true
+  #   price.value #=> 63.65
   #
   # @example Successful task execution
   #

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

@@ -19,13 +19,19 @@ module Concurrent
   #
   #   @see http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html Ruby standard library `Set`
 
-
   # @!macro internal_implementation_note
   SetImplementation = case
                       when Concurrent.on_cruby?
-                        # Because MRI never runs code in parallel, the existing
-                        # non-thread-safe structures should usually work fine.
-                        ::Set
+                        # The CRuby implementation of Set is written in Ruby itself and is
+                        # not thread safe for certain methods.
+                        require 'monitor'
+                        require 'concurrent/thread_safe/util/data_structures'
+
+                        class CRubySet < ::Set
+                        end
+
+                        ThreadSafe::Util.make_synchronized_on_cruby CRubySet
+                        CRubySet
 
                       when Concurrent.on_jruby?
                         require 'jruby/synchronized'
@@ -33,6 +39,7 @@ module Concurrent
                         class JRubySet < ::Set
                           include JRuby::Synchronized
                         end
+
                         JRubySet
 
                       when Concurrent.on_rbx?
@@ -41,7 +48,8 @@ module Concurrent
 
                         class RbxSet < ::Set
                         end
-                        ThreadSafe::Util.make_synchronized_on_rbx Concurrent::RbxSet
+
+                        ThreadSafe::Util.make_synchronized_on_rbx RbxSet
                         RbxSet
 
                       when Concurrent.on_truffleruby?
@@ -50,7 +58,7 @@ module Concurrent
                         class TruffleRubySet < ::Set
                         end
 
-                        ThreadSafe::Util.make_synchronized_on_truffleruby Concurrent::TruffleRubySet
+                        ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubySet
                         TruffleRubySet
 
                       else

data/lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb

@@ -4,9 +4,7 @@ module Concurrent
     # @!visibility private
     # @!macro internal_implementation_note
     LockableObjectImplementation = case
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
-                                     MonitorLockableObject
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
+                                   when Concurrent.on_cruby?
                                      MutexLockableObject
                                    when Concurrent.on_jruby?
                                      JRubyLockableObject

data/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb

@@ -32,6 +32,12 @@ module Concurrent
         @__Condition__ = ::ConditionVariable.new
       end
 
+      def initialize_copy(other)
+        super
+        @__Lock__      = ::Mutex.new
+        @__Condition__ = ::ConditionVariable.new
+      end
+
       protected
 
       def synchronize
@@ -61,6 +67,12 @@ module Concurrent
         @__Condition__ = @__Lock__.new_cond
       end
 
+      def initialize_copy(other)
+        super
+        @__Lock__      = ::Monitor.new
+        @__Condition__ = @__Lock__.new_cond
+      end
+
       protected
 
       def synchronize # TODO may be a problem with lock.synchronize { lock.wait }

data/lib/concurrent-ruby/concurrent/synchronization/rbx_lockable_object.rb

@@ -12,6 +12,12 @@ module Concurrent
         @__owner__   = nil
       end
 
+      def initialize_copy(other)
+        super
+        @__Waiters__ = []
+        @__owner__   = nil
+      end
+
       protected
 
       def synchronize(&block)

data/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb

@@ -12,12 +12,37 @@ end
 module Concurrent
   module ThreadSafe
     module Util
+      def self.make_synchronized_on_cruby(klass)
+        klass.class_eval do
+          def initialize(*args, &block)
+            @_monitor = Monitor.new
+            super
+          end
+
+          def initialize_copy(other)
+            # make sure a copy is not sharing a monitor with the original object!
+            @_monitor = Monitor.new
+            super
+          end
+        end
+
+        klass.superclass.instance_methods(false).each do |method|
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args)
+              monitor = @_monitor
+              monitor or raise("BUG: Internal monitor was not properly initialized. Please report this to the concurrent-ruby developers.")
+              monitor.synchronize { super }
+            end
+          RUBY
+        end
+      end
+
       def self.make_synchronized_on_rbx(klass)
         klass.class_eval do
           private
 
           def _mon_initialize
-            @_monitor = Monitor.new unless @_monitor # avoid double initialisation
+            @_monitor ||= Monitor.new # avoid double initialisation
           end
 
           def self.new(*args)

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

@@ -25,9 +25,7 @@ module Concurrent
   # Should the task experience an unrecoverable crash only the task thread will
   # crash. This makes the `TimerTask` very fault tolerant. Additionally, the
   # `TimerTask` thread can respond to the success or failure of the task,
-  # performing logging or ancillary operations. `TimerTask` can also be
-  # configured with a timeout value allowing it to kill a task that runs too
-  # long.
+  # performing logging or ancillary operations.
   #
   # One other advantage of `TimerTask` is that it forces the business logic to
   # be completely decoupled from the concurrency logic. The business logic can
@@ -48,9 +46,7 @@ module Concurrent
   # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
   # Observable} module. On execution the `TimerTask` will notify the observers
   # with three arguments: time of execution, the result of the block (or nil on
-  # failure), and any raised exceptions (or nil on success). If the timeout
-  # interval is exceeded the observer will receive a `Concurrent::TimeoutError`
-  # object as the third argument.
+  # failure), and any raised exceptions (or nil on success).
   #
   # @!macro copy_options
   #
@@ -59,20 +55,18 @@ module Concurrent
   #   task.execute
   #
   #   task.execution_interval #=> 60 (default)
-  #   task.timeout_interval   #=> 30 (default)
   #
   #   # wait 60 seconds...
   #   #=> 'Boom!'
   #
   #   task.shutdown #=> true
   #
-  # @example Configuring `:execution_interval` and `:timeout_interval`
-  #   task = Concurrent::TimerTask.new(execution_interval: 5, timeout_interval: 5) do
+  # @example Configuring `:execution_interval`
+  #   task = Concurrent::TimerTask.new(execution_interval: 5) do
   #          puts 'Boom!'
   #        end
   #
   #   task.execution_interval #=> 5
-  #   task.timeout_interval   #=> 5
   #
   # @example Immediate execution with `:run_now`
   #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
@@ -115,15 +109,13 @@ module Concurrent
   #     def update(time, result, ex)
   #       if result
   #         print "(#{time}) Execution successfully returned #{result}\n"
-  #       elsif ex.is_a?(Concurrent::TimeoutError)
-  #         print "(#{time}) Execution timed out\n"
   #       else
   #         print "(#{time}) Execution failed with error #{ex}\n"
   #       end
   #     end
   #   end
   #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ 42 }
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ 42 }
   #   task.add_observer(TaskObserver.new)
   #   task.execute
   #   sleep 4
@@ -133,7 +125,7 @@ module Concurrent
   #   #=> (2013-10-13 19:09:00 -0400) Execution successfully returned 42
   #   task.shutdown
   #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ sleep }
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ sleep }
   #   task.add_observer(TaskObserver.new)
   #   task.execute
   #
@@ -169,8 +161,6 @@ module Concurrent
     #   @param [Hash] opts the options defining task execution.
     #   @option opts [Integer] :execution_interval number of seconds between
     #     task executions (default: EXECUTION_INTERVAL)
-    #   @option opts [Integer] :timeout_interval number of seconds a task can
-    #     run before it is considered to have failed (default: TIMEOUT_INTERVAL)
     #   @option opts [Boolean] :run_now Whether to run the task immediately
     #     upon instantiation or to wait until the first #  execution_interval
     #     has passed (default: false)
@@ -256,18 +246,14 @@ module Concurrent
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
     def timeout_interval
-      synchronize { @timeout_interval }
+      warn 'TimerTask timeouts are now ignored as these were not able to be implemented correctly'
     end
 
     # @!attribute [rw] timeout_interval
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
     def timeout_interval=(value)
-      if (value = value.to_f) <= 0.0
-        raise ArgumentError.new('must be greater than zero')
-      else
-        synchronize { @timeout_interval = value }
-      end
+      warn 'TimerTask timeouts are now ignored as these were not able to be implemented correctly'
     end
 
     private :post, :<<
@@ -278,7 +264,9 @@ module Concurrent
       set_deref_options(opts)
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
-      self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
+      if opts[:timeout] || opts[:timeout_interval]
+        warn 'TimeTask timeouts are now ignored as these were not able to be implemented correctly'
+      end
       @run_now = opts[:now] || opts[:run_now]
       @executor = Concurrent::SafeTaskExecutor.new(task)
       @running = Concurrent::AtomicBoolean.new(false)
@@ -308,7 +296,6 @@ module Concurrent
     # @!visibility private
     def execute_task(completion)
       return nil unless @running.true?
-      ScheduledTask.execute(timeout_interval, args: [completion], &method(:timeout_task))
       _success, value, reason = @executor.execute(self)
       if completion.try?
         self.value = value
@@ -320,14 +307,5 @@ module Concurrent
       end
       nil
     end
-
-    # @!visibility private
-    def timeout_task(completion)
-      return unless @running.true?
-      if completion.try?
-        schedule_next_task
-        observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
-      end
-    end
   end
 end