concurrent-ruby 1.2.1 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 366b0c4f0d3184143a58a6b30538fe9997e7dfad19c8ea38a468168d680f3bdf
-  data.tar.gz: 010f0ee92f5132a2ed41da7d789a72955691dbcf880c579fd121cb366ba000bc
+  metadata.gz: 7841a791b1b148d8e8efea668fc70f3acc98c247f8d49fea58a4c672b45a62e6
+  data.tar.gz: 380ca8252b5b9251f30cd925d8b08f2afae56db19a210a8726b44c7304e5cd84
 SHA512:
-  metadata.gz: 876b3302b218236cb89bd838e3030e2c5937d9682edd8e88a47d538ec5f0da21a7d49b55452e278e6c01b7210cb51c4bad3afc6b5767294f16890f5bd630e69b
-  data.tar.gz: 938906cad82d61617a0267dc28dc99e18420c7872593344c1c6adb4fa54c751839226703e1ce6ea81e79dcd35b2650e5868c6c11bcaf83c02d2fb105aa8b35a2
+  metadata.gz: e479a5475e8d6dd7b3589a76300ccc73162cbceb8a15b721462394ff92f02054ba06e8ec5ee3ab08aa391a846d00492c708c893416b4c0c159c53d9b065f755f
+  data.tar.gz: 52daa298a6820a10756bfbf472aff566f5b5508f4e014352aa7a8d2516873b1e69b6392cde1379c0feaeba7c054c6c6c919613c3e09ac4d2328939cde3f01444

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## Current
 
+## Release v1.3.1 (29 May 2024)
+
+* Release 1.3.0 was broken when pushed to RubyGems. 1.3.1 is a packaging fix.
+
+## Release v1.3.0 (28 May 2024)
+
+* (#1042) Align Java Executor Service behavior for `shuttingdown?`, `shutdown?`
+* (#1038) Add `Concurrent.usable_processor_count` that is cgroups aware.
+
+## Release v1.2.3 (16 Jan 2024)
+
+* See [the GitHub release](https://github.com/ruby-concurrency/concurrent-ruby/releases/tag/v1.2.3) for details.
+
+## Release v1.2.2 (24 Feb 2023)
+
+* (#993) Fix arguments passed to `Concurrent::Map`'s `default_proc`.
+
+## Release v1.2.1 (24 Feb 2023)
+
 * (#990) Add missing `require 'fiber'` for `FiberLocalVar`.
 * (#989) Optimize `Concurrent::Map#[]` on CRuby by letting the backing Hash handle the `default_proc`.
 

data/Gemfile

@@ -12,7 +12,7 @@ gem 'concurrent-ruby-ext', Concurrent::VERSION, options.merge(platform: :mri)
 
 group :development do
   gem 'rake', '~> 13.0'
-  gem 'rake-compiler', '~> 1.0', '>= 1.0.7'
+  gem 'rake-compiler', '~> 1.0', '>= 1.0.7', '!= 1.2.4'
   gem 'rake-compiler-dock', '~> 1.0'
   gem 'pry', '~> 0.11', platforms: :mri
 end

data/README.md

@@ -375,6 +375,8 @@ best practice is to depend on `concurrent-ruby` and let users to decide if they
 * [Benoit Daloze](https://github.com/eregon)
 * [Matthew Draper](https://github.com/matthewd)
 * [Rafael França](https://github.com/rafaelfranca)
+* [Charles Oliver Nutter](https://github.com/headius)
+* [Ben Sheldon](https://github.com/bensheldon)
 * [Samuel Williams](https://github.com/ioquatix)
 
 ### Special Thanks to

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

@@ -21,9 +21,9 @@ module Concurrent
   # @!macro internal_implementation_note
   ArrayImplementation = case
                         when Concurrent.on_cruby?
-                          # Array 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.
+                          # Array is not fully thread-safe on CRuby, see
+                          # https://github.com/ruby-concurrency/concurrent-ruby/issues/929
+                          # So we will need to add synchronization here
                           ::Array
 
                         when Concurrent.on_jruby?

data/lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb

@@ -14,7 +14,7 @@ module Concurrent
       # reasons.
       def initialize(options = nil, &default_proc)
         validate_options_hash!(options) if options.kind_of?(::Hash)
-        @backend = Hash.new(&default_proc)
+        set_backend(default_proc)
         @default_proc = default_proc
       end
 
@@ -113,9 +113,17 @@ module Concurrent
 
       private
 
+      def set_backend(default_proc)
+        if default_proc
+          @backend = ::Hash.new { |_h, key| default_proc.call(self, key) }
+        else
+          @backend = {}
+        end
+      end
+
       def initialize_copy(other)
         super
-        @backend = Hash.new(&@default_proc)
+        set_backend(@default_proc)
         self
       end
 

data/lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb

@@ -8,74 +8,77 @@ module Concurrent
     # @!visibility private
     class SynchronizedMapBackend < NonConcurrentMapBackend
 
-      require 'mutex_m'
-      include Mutex_m
-      # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are
-      # not allowed to call each other.
+      def initialize(*args, &block)
+        super
+
+        # WARNING: Mutex is a non-reentrant lock, so the synchronized methods are
+        # not allowed to call each other.
+        @mutex = Mutex.new
+      end
 
       def [](key)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def []=(key, value)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def compute_if_absent(key)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def compute_if_present(key)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def compute(key)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def merge_pair(key, value)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def replace_pair(key, old_value, new_value)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def replace_if_exists(key, new_value)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def get_and_set(key, value)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def key?(key)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def delete(key)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def delete_pair(key, value)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def clear
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def size
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       def get_or_default(key, default_value)
-        synchronize { super }
+        @mutex.synchronize { super }
       end
 
       private
       def dupped_backend
-        synchronize { super }
+        @mutex.synchronize { super }
       end
     end
   end

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

@@ -39,6 +39,10 @@ module Concurrent
   #   The number of tasks that have been completed by the pool since construction.
   #   @return [Integer] The number of tasks that have been completed by the pool since construction.
 
+  # @!macro thread_pool_executor_method_active_count
+  #   The number of threads that are actively executing tasks.
+  #   @return [Integer] The number of threads that are actively executing tasks.
+
   # @!macro thread_pool_executor_attr_reader_idletime
   #   The number of seconds that a thread may be idle before being reclaimed.
   #   @return [Integer] The number of seconds that a thread may be idle before being reclaimed.

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

@@ -57,15 +57,11 @@ if Concurrent.on_jruby?
       end
 
       def ns_shuttingdown?
-        if @executor.respond_to? :isTerminating
-          @executor.isTerminating
-        else
-          false
-        end
+        @executor.isShutdown && !@executor.isTerminated
       end
 
       def ns_shutdown?
-        @executor.isShutdown || @executor.isTerminated
+        @executor.isTerminated
       end
 
       class Job
@@ -88,10 +84,11 @@ if Concurrent.on_jruby?
 
       def initialize(daemonize = true)
         @daemonize = daemonize
+        @java_thread_factory = java.util.concurrent.Executors.defaultThreadFactory
       end
 
       def newThread(runnable)
-        thread = java.util.concurrent.Executors.defaultThreadFactory().newThread(runnable)
+        thread = @java_thread_factory.newThread(runnable)
         thread.setDaemon(@daemonize)
         return thread
       end

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

@@ -73,6 +73,11 @@ if Concurrent.on_jruby?
         @executor.getCompletedTaskCount
       end
 
+      # @!macro thread_pool_executor_method_active_count
+      def active_count
+        @executor.getActiveCount
+      end
+
       # @!macro thread_pool_executor_attr_reader_idletime
       def idletime
         @executor.getKeepAliveTime(java.util.concurrent.TimeUnit::SECONDS)

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

@@ -61,6 +61,13 @@ module Concurrent
       synchronize { @completed_task_count }
     end
 
+    # @!macro thread_pool_executor_method_active_count
+    def active_count
+      synchronize do
+        @pool.length - @ready.length
+      end
+    end
+
     # @!macro executor_service_method_can_overflow_question
     def can_overflow?
       synchronize { ns_limited_queue? }

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

@@ -3,7 +3,7 @@ require 'concurrent/atomic/event'
 require 'concurrent/collection/non_concurrent_priority_queue'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/single_thread_executor'
-
+require 'concurrent/errors'
 require 'concurrent/options'
 
 module Concurrent
@@ -162,7 +162,11 @@ 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 }
+          begin
+            task.executor.post { task.process_task }
+          rescue RejectedExecutionError
+            # ignore and continue
+          end
         else
           @condition.wait([diff, 60].min)
         end

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

@@ -15,9 +15,11 @@ module Concurrent
   # @!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 is not fully thread-safe on CRuby, see
+                         # https://bugs.ruby-lang.org/issues/19237
+                         # https://github.com/ruby/ruby/commit/ffd52412ab
+                         # https://github.com/ruby-concurrency/concurrent-ruby/issues/929
+                         # So we will need to add synchronization here (similar to Concurrent::Map).
                          ::Hash
 
                        when Concurrent.on_jruby?

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

@@ -20,8 +20,8 @@ module Concurrent
                             require 'concurrent/collection/map/truffleruby_map_backend'
                             TruffleRubyMapBackend
                           else
-                            require 'concurrent/collection/map/atomic_reference_map_backend'
-                            AtomicReferenceMapBackend
+                            require 'concurrent/collection/map/synchronized_map_backend'
+                            SynchronizedMapBackend
                           end
                         else
                           warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation'

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

@@ -5,6 +5,7 @@ require 'concurrent/collection/lock_free_stack'
 require 'concurrent/configuration'
 require 'concurrent/errors'
 require 'concurrent/re_include'
+require 'concurrent/utility/monotonic_time'
 
 module Concurrent
 
@@ -22,7 +23,7 @@ module Concurrent
     #
     # @!macro promises.param.args
     #   @param [Object] args arguments which are passed to the task when it's executed.
-    #     (It might be prepended with other arguments, see the @yeild section).
+    #     (It might be prepended with other arguments, see the @yield section).
     #
     # @!macro promises.shortcut.on
     #   Shortcut of {#$0_on} with default `:io` executor supplied.
@@ -63,8 +64,8 @@ module Concurrent
         resolvable_event_on default_executor
       end
 
-      # Created resolvable event, user is responsible for resolving the event once by
-      # {Promises::ResolvableEvent#resolve}.
+      # Creates a resolvable event, user is responsible for resolving the event once
+      # by calling {Promises::ResolvableEvent#resolve}.
       #
       # @!macro promises.param.default_executor
       # @return [ResolvableEvent]
@@ -94,7 +95,7 @@ module Concurrent
         future_on(default_executor, *args, &task)
       end
 
-      # Constructs new Future which will be resolved after block is evaluated on default executor.
+      # Constructs a new Future which will be resolved after block is evaluated on default executor.
       # Evaluation begins immediately.
       #
       # @!macro promises.param.default_executor
@@ -106,7 +107,7 @@ module Concurrent
         ImmediateEventPromise.new(default_executor).future.then(*args, &task)
       end
 
-      # Creates resolved future with will be either fulfilled with the given value or rejection with
+      # Creates a resolved future with will be either fulfilled with the given value or rejected with
       # the given reason.
       #
       # @param [true, false] fulfilled
@@ -118,7 +119,7 @@ module Concurrent
         ImmediateFuturePromise.new(default_executor, fulfilled, value, reason).future
       end
 
-      # Creates resolved future with will be fulfilled with the given value.
+      # Creates a resolved future which will be fulfilled with the given value.
       #
       # @!macro promises.param.default_executor
       # @param [Object] value
@@ -127,7 +128,7 @@ module Concurrent
         resolved_future true, value, nil, default_executor
       end
 
-      # Creates resolved future with will be rejected with the given reason.
+      # Creates a resolved future which will be rejected with the given reason.
       #
       # @!macro promises.param.default_executor
       # @param [Object] reason
@@ -190,7 +191,7 @@ module Concurrent
         delay_on default_executor, *args, &task
       end
 
-      # Creates new event or future which is resolved only after it is touched,
+      # Creates a new event or future which is resolved only after it is touched,
       # see {Concurrent::AbstractEventFuture#touch}.
       #
       # @!macro promises.param.default_executor
@@ -214,7 +215,7 @@ module Concurrent
         schedule_on default_executor, intended_time, *args, &task
       end
 
-      # Creates new event or future which is resolved in intended_time.
+      # Creates a new event or future which is resolved in intended_time.
       #
       # @!macro promises.param.default_executor
       # @!macro promises.param.intended_time
@@ -240,8 +241,8 @@ module Concurrent
         zip_futures_on default_executor, *futures_and_or_events
       end
 
-      # Creates new future which is resolved after all futures_and_or_events are resolved.
-      # Its value is array of zipped future values. Its reason is array of reasons for rejection.
+      # Creates a new future which is resolved after all futures_and_or_events are resolved.
+      # Its value is an array of zipped future values. Its reason is an array of reasons for rejection.
       # If there is an error it rejects.
       # @!macro promises.event-conversion
       #   If event is supplied, which does not have value and can be only resolved, it's
@@ -262,7 +263,7 @@ module Concurrent
         zip_events_on default_executor, *futures_and_or_events
       end
 
-      # Creates new event which is resolved after all futures_and_or_events are resolved.
+      # Creates a new event which is resolved after all futures_and_or_events are resolved.
       # (Future is resolved when fulfilled or rejected.)
       #
       # @!macro promises.param.default_executor
@@ -280,8 +281,8 @@ module Concurrent
 
       alias_method :any, :any_resolved_future
 
-      # Creates new future which is resolved after first futures_and_or_events is resolved.
-      # Its result equals result of the first resolved future.
+      # Creates a new future which is resolved after the first futures_and_or_events is resolved.
+      # Its result equals the result of the first resolved future.
       # @!macro promises.any-touch
       #   If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
       #   futures un-executed if they are not required any more.
@@ -300,9 +301,9 @@ module Concurrent
         any_fulfilled_future_on default_executor, *futures_and_or_events
       end
 
-      # Creates new future which is resolved after first of futures_and_or_events is fulfilled.
-      # Its result equals result of the first resolved future or if all futures_and_or_events reject,
-      # it has reason of the last resolved future.
+      # Creates a new future which is resolved after the first futures_and_or_events is fulfilled.
+      # Its result equals the result of the first resolved future or if all futures_and_or_events reject,
+      # it has reason of the last rejected future.
       # @!macro promises.any-touch
       # @!macro promises.event-conversion
       #
@@ -319,7 +320,7 @@ module Concurrent
         any_event_on default_executor, *futures_and_or_events
       end
 
-      # Creates new event which becomes resolved after first of the futures_and_or_events resolves.
+      # Creates a new event which becomes resolved after the first futures_and_or_events resolves.
       # @!macro promises.any-touch
       #
       # @!macro promises.param.default_executor
@@ -611,7 +612,7 @@ module Concurrent
       #   @yieldparam [Object] value
       #   @yieldparam [Object] reason
       def chain_on(executor, *args, &task)
-        ChainPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        ChainPromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @return [String] Short string representation.
@@ -772,8 +773,17 @@ module Concurrent
         @Lock.synchronize do
           @Waiters.increment
           begin
-            unless resolved?
-              @Condition.wait @Lock, timeout
+            if timeout
+              start = Concurrent.monotonic_time
+              until resolved?
+                break if @Condition.wait(@Lock, timeout) == nil # nil means timeout
+                timeout -= (Concurrent.monotonic_time - start)
+                break if timeout <= 0
+              end
+            else
+              until resolved?
+                @Condition.wait(@Lock, timeout)
+              end
             end
           ensure
             # JRuby may raise ConcurrencyError
@@ -1034,7 +1044,7 @@ module Concurrent
       # @return [Future]
       # @yield [value, *args] to the task.
       def then_on(executor, *args, &task)
-        ThenPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        ThenPromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @!macro promises.shortcut.on
@@ -1052,7 +1062,7 @@ module Concurrent
       # @return [Future]
       # @yield [reason, *args] to the task.
       def rescue_on(executor, *args, &task)
-        RescuePromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        RescuePromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @!macro promises.method.zip

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

@@ -32,6 +32,17 @@ module Concurrent
   # be tested separately then passed to the `TimerTask` for scheduling and
   # running.
   #
+  # A `TimerTask` supports two different types of interval calculations.
+  # A fixed delay will always wait the same amount of time between the
+  # completion of one task and the start of the next. A fixed rate will
+  # attempt to maintain a constant rate of execution regardless of the
+  # duration of the task. For example, if a fixed rate task is scheduled
+  # to run every 60 seconds but the task itself takes 10 seconds to
+  # complete, the next task will be scheduled to run 50 seconds after
+  # the start of the previous task. If the task takes 70 seconds to
+  # complete, the next task will be start immediately after the previous
+  # task completes. Tasks will not be executed concurrently.
+  #
   # In some cases it may be necessary for a `TimerTask` to affect its own
   # execution cycle. To facilitate this, a reference to the TimerTask instance
   # is passed as an argument to the provided block every time the task is
@@ -74,6 +85,12 @@ module Concurrent
   #
   #   #=> 'Boom!'
   #
+  # @example Configuring `:interval_type` with either :fixed_delay or :fixed_rate, default is :fixed_delay
+  #   task = Concurrent::TimerTask.new(execution_interval: 5, interval_type: :fixed_rate) do
+  #          puts 'Boom!'
+  #        end
+  #   task.interval_type #=> :fixed_rate
+  #
   # @example Last `#value` and `Dereferenceable` mixin
   #   task = Concurrent::TimerTask.new(
   #     dup_on_deref: true,
@@ -87,7 +104,7 @@ module Concurrent
   #
   # @example Controlling execution from within the block
   #   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
-  #     task.execution_interval.times{ print 'Boom! ' }
+  #     task.execution_interval.to_i.times{ print 'Boom! ' }
   #     print "\n"
   #     task.execution_interval += 1
   #     if task.execution_interval > 5
@@ -96,7 +113,7 @@ module Concurrent
   #     end
   #   end
   #
-  #   timer_task.execute # blocking call - this task will stop itself
+  #   timer_task.execute
   #   #=> Boom!
   #   #=> Boom! Boom!
   #   #=> Boom! Boom! Boom!
@@ -152,18 +169,30 @@ module Concurrent
     # Default `:execution_interval` in seconds.
     EXECUTION_INTERVAL = 60
 
-    # Default `:timeout_interval` in seconds.
-    TIMEOUT_INTERVAL = 30
+    # Maintain the interval between the end of one execution and the start of the next execution.
+    FIXED_DELAY = :fixed_delay
+
+    # Maintain the interval between the start of one execution and the start of the next.
+    # If execution time exceeds the interval, the next execution will start immediately
+    # after the previous execution finishes. Executions will not run concurrently.
+    FIXED_RATE = :fixed_rate
+
+    # Default `:interval_type`
+    DEFAULT_INTERVAL_TYPE = FIXED_DELAY
 
     # Create a new TimerTask with the given task and configuration.
     #
     # @!macro timer_task_initialize
     #   @param [Hash] opts the options defining task execution.
-    #   @option opts [Integer] :execution_interval number of seconds between
+    #   @option opts [Float] :execution_interval number of seconds between
     #     task executions (default: EXECUTION_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)
+    #   @options opts [Symbol] :interval_type method to calculate the interval
+    #     between executions, can be either :fixed_rate or :fixed_delay.
+    #     (default: :fixed_delay)
+    #   @option opts [Executor] executor, default is `global_io_executor`
     #
     #   @!macro deref_options
     #
@@ -242,6 +271,10 @@ module Concurrent
       end
     end
 
+    # @!attribute [r] interval_type
+    # @return [Symbol] method to calculate the interval between executions
+    attr_reader :interval_type
+
     # @!attribute [rw] timeout_interval
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
@@ -264,11 +297,17 @@ module Concurrent
       set_deref_options(opts)
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
+      if opts[:interval_type] && ![FIXED_DELAY, FIXED_RATE].include?(opts[:interval_type])
+        raise ArgumentError.new('interval_type must be either :fixed_delay or :fixed_rate')
+      end
       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)
+      @interval_type = opts[:interval_type] || DEFAULT_INTERVAL_TYPE
+      @task = Concurrent::SafeTaskExecutor.new(task)
+      @executor = opts[:executor] || Concurrent.global_io_executor
       @running = Concurrent::AtomicBoolean.new(false)
       @value = nil
 
@@ -289,17 +328,18 @@ module Concurrent
 
     # @!visibility private
     def schedule_next_task(interval = execution_interval)
-      ScheduledTask.execute(interval, args: [Concurrent::Event.new], &method(:execute_task))
+      ScheduledTask.execute(interval, executor: @executor, args: [Concurrent::Event.new], &method(:execute_task))
       nil
     end
 
     # @!visibility private
     def execute_task(completion)
       return nil unless @running.true?
-      _success, value, reason = @executor.execute(self)
+      start_time = Concurrent.monotonic_time
+      _success, value, reason = @task.execute(self)
       if completion.try?
         self.value = value
-        schedule_next_task
+        schedule_next_task(calculate_next_interval(start_time))
         time = Time.now
         observers.notify_observers do
           [time, self.value, reason]
@@ -307,5 +347,15 @@ module Concurrent
       end
       nil
     end
+
+    # @!visibility private
+    def calculate_next_interval(start_time)
+      if @interval_type == FIXED_RATE
+        run_time = Concurrent.monotonic_time - start_time
+        [execution_interval - run_time, 0].max
+      else # FIXED_DELAY
+        execution_interval
+      end
+    end
   end
 end