concurrent-ruby 1.2.0 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f224c72d89a1bd079ad1086c9ed28a1d4d6432c718b9e0624c9a32afc8500cc8
-  data.tar.gz: dfb811189c8e7eeb2ea1f17fc1e680657dffe767c77bb09312e85a4f29f2bd60
+  metadata.gz: 1c6483d36c3c75859c9b38b6ba2ba13577a0bb89b3b725a032d43f3543797099
+  data.tar.gz: e94ac3e1ba23db29a7bf025736e34a4027ba7a137ae08b493c78ce3756803792
 SHA512:
-  metadata.gz: 807b1aac5e1bdee569df0b9e38fff1ed339f2c8569cd0a7ab565cbbecb23ffc9c6cf968e457e2acecf3abd187ac43da16dc2fb91716c912e78c08aa122dcaf0e
-  data.tar.gz: 07c37140aa1417ad32daa0de92f4c0883c7a96c1c53fba9aa09e34598632b3ad274283034064df41181e59964d0c79e41d083f17912e8e121c4f2d774c988b81
+  metadata.gz: dc0353e60638a409bf891d663626bd2c1c5f05206c08036326d63e239bfe0ea7e1e3480982c75fe44f9d416a7f76a66a2a2aeef78fc60084ed7ff94c7d3181d9
+  data.tar.gz: 24bdd3a040528c05061ec15b4057184be96fa933f69f3321755e8583ba8e6175beec48c36f1671cc3dad7e413588c9601c7f0e5b503b3de947dff63c2ba76b1e

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## Current
 
+## 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`.
+
 ## Release v1.2.0 (23 Jan 2023)
 
 * (#962) Fix ReentrantReadWriteLock to use the same granularity for locals as for Mutex it uses.

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/Rakefile

@@ -271,6 +271,7 @@ namespace :release do
   task :publish => ['publish:ask', 'publish:tag', 'publish:rubygems', 'publish:post_steps']
 
   namespace :publish do
+    publish_base = true
     publish_edge = false
 
     task :ask do
@@ -289,8 +290,8 @@ namespace :release do
     desc '** tag HEAD with current version and push to github'
     task :tag => :ask do
       Dir.chdir(__dir__) do
-        sh "git tag v#{Concurrent::VERSION}"
-        sh "git push origin v#{Concurrent::VERSION}"
+        sh "git tag v#{Concurrent::VERSION}" if publish_base
+        sh "git push origin v#{Concurrent::VERSION}" if publish_base
         sh "git tag edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
         sh "git push origin edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
       end
@@ -299,11 +300,11 @@ namespace :release do
     desc '** push all *.gem files to rubygems'
     task :rubygems => :ask do
       Dir.chdir(__dir__) do
-        sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
+        sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem" if publish_base
         sh "gem push pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem" if publish_edge
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem"
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x64-mingw32.gem"
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x86-mingw32.gem"
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x64-mingw32.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x86-mingw32.gem" if publish_base
       end
     end
 

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/atomic/locals.rb

@@ -1,3 +1,4 @@
+require 'fiber'
 require 'concurrent/utility/engine'
 require 'concurrent/constants'
 

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

@@ -9,8 +9,8 @@ module Concurrent
     # @!visibility private
     class MriMapBackend < NonConcurrentMapBackend
 
-      def initialize(options = nil)
-        super(options)
+      def initialize(options = nil, &default_proc)
+        super(options, &default_proc)
         @write_lock = Mutex.new
       end
 

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

@@ -12,8 +12,10 @@ module Concurrent
       # directly without calling each other. This is important because of the
       # SynchronizedMapBackend which uses a non-reentrant mutex for performance
       # reasons.
-      def initialize(options = nil)
-        @backend = {}
+      def initialize(options = nil, &default_proc)
+        validate_options_hash!(options) if options.kind_of?(::Hash)
+        set_backend(default_proc)
+        @default_proc = default_proc
       end
 
       def [](key)
@@ -55,7 +57,7 @@ module Concurrent
       end
 
       def compute(key)
-        store_computed_value(key, yield(@backend[key]))
+        store_computed_value(key, yield(get_or_default(key, nil)))
       end
 
       def merge_pair(key, value)
@@ -67,7 +69,7 @@ module Concurrent
       end
 
       def get_and_set(key, value)
-        stored_value = @backend[key]
+        stored_value = get_or_default(key, nil)
         @backend[key] = value
         stored_value
       end
@@ -109,13 +111,19 @@ module Concurrent
         @backend.fetch(key, default_value)
       end
 
-      alias_method :_get, :[]
-      alias_method :_set, :[]=
-      private :_get, :_set
       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 = {}
+        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

@@ -88,10 +88,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'
@@ -46,6 +46,12 @@ module Concurrent
     #   @note Atomic methods taking a block do not allow the `self` instance
     #     to be used within the block. Doing so will cause a deadlock.
 
+    # @!method []=(key, value)
+    #   Set a value with key
+    #   @param [Object] key
+    #   @param [Object] value
+    #   @return [Object] the new value
+
     # @!method compute_if_absent(key)
     #   Compute and store new value for key if the key is absent.
     #   @param [Object] key
@@ -119,41 +125,38 @@ 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)
-      else
-        options = nil
-      end
+    # NonConcurrentMapBackend handles default_proc natively
+    unless defined?(Collection::NonConcurrentMapBackend) and self < Collection::NonConcurrentMapBackend
 
-      super(options)
-      @default_proc = block
-    end
+      # @param [Hash, nil] options options to set the :initial_capacity or :load_factor. Ignored on some Rubies.
+      # @param [Proc] default_proc Optional block to compute the default value if the key is not set, like `Hash#default_proc`
+      def initialize(options = nil, &default_proc)
+        if options.kind_of?(::Hash)
+          validate_options_hash!(options)
+        else
+          options = nil
+        end
 
-    # Get a value with key
-    # @param [Object] key
-    # @return [Object] the value
-    def [](key)
-      if value = super # non-falsy value is an existing mapping, return it right away
-        value
-        # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
-        # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
-        # would be returned)
-        # note: nil == value check is not technically necessary
-      elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
-        @default_proc.call(self, key)
-      else
-        value
+        super(options)
+        @default_proc = default_proc
       end
-    end
 
-    # Set a value with key
-    # @param [Object] key
-    # @param [Object] value
-    # @return [Object] the new value
-    def []=(key, value)
-      super
+      # Get a value with key
+      # @param [Object] key
+      # @return [Object] the value
+      def [](key)
+        if value = super # non-falsy value is an existing mapping, return it right away
+          value
+          # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
+          # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
+          # would be returned)
+          # note: nil == value check is not technically necessary
+        elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
+          @default_proc.call(self, key)
+        else
+          value
+        end
+      end
     end
 
     alias_method :get, :[]

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