concurrent-ruby-edge 0.4.1 → 0.5.0

data/lib-edge/concurrent/edge/processing_actor.rb

@@ -15,9 +15,9 @@ module Concurrent
   #     values[-5, 5]                                      # => [49996, 49997, 49998, 49999, 50000]
   # @!macro warn.edge
   class ProcessingActor < Synchronization::Object
-    # TODO (pitr-ch 18-Dec-2016): (un)linking, bidirectional, sends special message, multiple link calls has no effect,
-    # TODO (pitr-ch 21-Dec-2016): Make terminated a cancellation token?
-    # link_spawn atomic, Can it be fixed by sending exit when linked dead actor?
+
+    # TODO (pitr-ch 29-Jan-2019): simplify as much as possible, maybe even do not delegate to mailbox, no ask linking etc
+    # TODO (pitr-ch 03-Feb-2019): remove completely
 
     safe_initialization!
 
@@ -55,31 +55,33 @@ module Concurrent
     # @param [Object] args Arguments passed to the process.
     # @param [Promises::Channel] channel which serves as mailing box. The channel can have limited
     #   size to achieve backpressure.
-    # @yield args to the process to get back a future which represents the actors execution.
+    # @yield [actor, *args] to the process to get back a future which represents the actors execution.
+    # @yieldparam [ProcessingActor] actor
     # @yieldparam [Object] *args
     # @yieldreturn [Promises::Future(Object)] a future representing next step of execution
     # @return [ProcessingActor]
-    # @example
-    #   # TODO (pitr-ch 19-Jan-2017): actor with limited mailbox
     def self.act_listening(channel, *args, &process)
-      actor = ProcessingActor.new channel
-      Promises.
-          future(actor, *args, &process).
-          run.
-          chain_resolvable(actor.instance_variable_get(:@Terminated))
-      actor
+      ProcessingActor.new channel, *args, &process
     end
 
-    # Receives a message when available, used in the actor's process.
-    # @return [Promises::Future(Object)] a future which will be fulfilled with a message from
-    #   mailbox when it is available.
-    def receive(probe = Promises.resolvable_future)
-      # TODO (pitr-ch 27-Dec-2016): patterns
-      @Mailbox.pop probe
+    # # Receives a message when available, used in the actor's process.
+    # # @return [Promises::Future(Object)] a future which will be fulfilled with a message from
+    # #   mailbox when it is available.
+    # def receive(*channels)
+    #   channels = [@Mailbox] if channels.empty?
+    #   Promises::Channel.select(*channels)
+    #   # TODO (pitr-ch 27-Dec-2016): support patterns
+    #   #   - put any received message aside if it does not match
+    #   #   - on each receive call check the messages put aside
+    #   #   - track where the message came from, cannot later receive m form other channel only because it matches
+    # end
+
+    def receive(channel = mailbox)
+      channel.pop_op
     end
 
     # Tells a message to the actor. May block current thread if the mailbox is full.
-    # {#tell} is a better option since it does not block. It's usually used to integrate with
+    # {#tell_op} is a better option since it does not block. It's usually used to integrate with
     # threading code.
     # @example
     #   Thread.new(actor) do |actor|
@@ -91,7 +93,7 @@ module Concurrent
     # @param [Object] message
     # @return [self]
     def tell!(message)
-      @Mailbox.push(message).wait!
+      @Mailbox.push(message)
       self
     end
 
@@ -99,61 +101,78 @@ module Concurrent
     # @param [Object] message
     # @return [Promises::Future(ProcessingActor)] a future which will be fulfilled with the actor
     #   when the message is pushed to mailbox.
-    def tell(message)
-      @Mailbox.push(message).then(self) { |_, actor| actor }
+    def tell_op(message)
+      @Mailbox.push_op(message).then(self) { |_ch, actor| actor }
     end
 
-    # Simplifies common pattern when a message sender also requires an answer to the message
-    # from the actor. It appends a resolvable_future for the answer after the message.
-    # @todo has to be nice also on the receive side, cannot make structure like this [message = [...], answer]
-    #   all receives should receive something friendly
-    # @param [Object] message
-    # @param [Promises::ResolvableFuture] answer
-    # @return [Promises::Future] a future which will be fulfilled with the answer to the message
-    # @example
-    #     add_once_actor = Concurrent::ProcessingActor.act do |actor|
-    #       actor.receive.then do |(a, b), answer|
-    #         result = a + b
-    #         answer.fulfill result
-    #         # terminate with result value
-    #         result
-    #       end
-    #     end
-    #     # => <#Concurrent::ProcessingActor:0x7fcd1315f6e8 termination:pending>
+    # # Simplifies common pattern when a message sender also requires an answer to the message
+    # # from the actor. It appends a resolvable_future for the answer after the message.
+    # # @todo has to be nice also on the receive side, cannot make structure like this [message = [...], answer]
+    # #   all receives should receive something friendly
+    # # @param [Object] message
+    # # @param [Promises::ResolvableFuture] answer
+    # # @return [Promises::Future] a future which will be fulfilled with the answer to the message
+    # # @example
+    # #     add_once_actor = Concurrent::ProcessingActor.act do |actor|
+    # #       actor.receive.then do |(a, b), answer|
+    # #         result = a + b
+    # #         answer.fulfill result
+    # #         # terminate with result value
+    # #         result
+    # #       end
+    # #     end
+    # #     # => <#Concurrent::ProcessingActor:0x7fcd1315f6e8 termination:pending>
+    # #
+    # #     add_once_actor.ask([1, 2]).value!                  # => 3
+    # #     # fails the actor already added once
+    # #     add_once_actor.ask(%w(ab cd)).reason
+    # #     # => #<RuntimeError: actor terminated normally before answering with a value: 3>
+    # #     add_once_actor.termination.value!                  # => 3
+    # def ask(message, answer = Promises.resolvable_future)
+    #   raise 'to be removed'
     #
-    #     add_once_actor.ask([1, 2]).value!                  # => 3
-    #     # fails the actor already added once
-    #     add_once_actor.ask(%w(ab cd)).reason
-    #     # => #<RuntimeError: actor terminated normally before answering with a value: 3>
-    #     add_once_actor.termination.value!                  # => 3
-    def ask(message, answer = Promises.resolvable_future)
-      tell [message, answer]
-      # do not leave answers unanswered when actor terminates.
-      Promises.any(
-          Promises.fulfilled_future(:answer).zip(answer),
-          Promises.fulfilled_future(:termination).zip(@Terminated)
-      ).chain do |fulfilled, (which, value), (_, reason)|
-        # TODO (pitr-ch 20-Jan-2017): we have to know which future was resolved
-        # TODO (pitr-ch 20-Jan-2017): make the combinator programmable, so anyone can create what is needed
-        # FIXME (pitr-ch 19-Jan-2017): ensure no callbacks are accumulated on @Terminated
-        if which == :termination
-          raise reason.nil? ? format('actor terminated normally before answering with a value: %s', value) : reason
-        else
-          fulfilled ? value : raise(reason)
-        end
-      end
+    #   # TODO (pitr-ch 12-Dec-2018): REMOVE, the process ends up as another future not a value, no nice way to do ask in the actor
+    #   tell [message, answer]
+    #   # do not leave answers unanswered when actor terminates.
+    #   Promises.any(
+    #       Promises.fulfilled_future(:answer).zip(answer),
+    #       Promises.fulfilled_future(:termination).zip(@Terminated)
+    #   ).chain do |fulfilled, (which, value), (_, reason)|
+    #     # TODO (pitr-ch 20-Jan-2017): we have to know which future was resolved
+    #     # TODO (pitr-ch 20-Jan-2017): make the combinator programmable, so anyone can create what is needed
+    #     # FIXME (pitr-ch 19-Jan-2017): ensure no callbacks are accumulated on @Terminated
+    #     if which == :termination
+    #       raise reason.nil? ? format('actor terminated normally before answering with a value: %s', value) : reason
+    #     else
+    #       fulfilled ? value : raise(reason)
+    #     end
+    #   end
+    # end
+
+    # actor.ask2 { |a| [:count, a] }
+    def ask_op(answer = Promises.resolvable_future, &message_provider)
+      # TODO (pitr-ch 12-Dec-2018): is it ok to let the answers be unanswered when the actor terminates
+      tell_op(message_provider.call(answer)).then(answer) { |_, a| a }
+
+      # answer.chain { |v| [true, v] } | @Terminated.then
     end
 
     # @return [String] string representation.
-    def inspect
-      format '%s termination:%s>', super[0..-2], termination.state
+    def to_s
+      format '%s termination: %s>', super[0..-2], termination.state
+    end
+
+    alias_method :inspect, :to_s
+
+    def to_ary
+      [@Mailbox, @Terminated]
     end
 
     private
 
-    def initialize(channel = Promises::Channel.new)
+    def initialize(channel, *args, &process)
       @Mailbox    = channel
-      @Terminated = Promises.resolvable_future
+      @Terminated = Promises.future(self, *args, &process).run
       super()
     end
 

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

@@ -12,7 +12,7 @@ module Concurrent
         # Asks the actor with its value.
         # @return [Future] new future with the response form the actor
         def then_ask(actor)
-          self.then { |v| actor.ask(v) }.flat
+          self.then(actor) { |v, a| a.ask_op(v) }.flat
         end
       end
 
@@ -49,97 +49,6 @@ module Concurrent
       include FlatShortcuts
     end
 
-    # @!macro warn.edge
-    class Channel < Concurrent::Synchronization::Object
-      safe_initialization!
-
-      # Default size of the Channel, makes it accept unlimited number of messages.
-      UNLIMITED = ::Object.new
-      UNLIMITED.singleton_class.class_eval do
-        include Comparable
-
-        def <=>(other)
-          1
-        end
-
-        def to_s
-          'unlimited'
-        end
-      end
-
-      # A channel to pass messages between promises. The size is limited to support back pressure.
-      # @param [Integer, UNLIMITED] size the maximum number of messages stored in the channel.
-      def initialize(size = UNLIMITED)
-        super()
-        @Size        = size
-        # TODO (pitr-ch 26-Dec-2016): replace with lock-free implementation
-        @Mutex       = Mutex.new
-        @Probes      = []
-        @Messages    = []
-        @PendingPush = []
-      end
-
-
-      # Returns future which will fulfill when the message is added to the channel. Its value is the message.
-      # @param [Object] message
-      # @return [Future]
-      def push(message)
-        @Mutex.synchronize do
-          while true
-            if @Probes.empty?
-              if @Size > @Messages.size
-                @Messages.push message
-                return Promises.fulfilled_future message
-              else
-                pushed = Promises.resolvable_future
-                @PendingPush.push [message, pushed]
-                return pushed.with_hidden_resolvable
-              end
-            else
-              probe = @Probes.shift
-              if probe.fulfill [self, message], false
-                return Promises.fulfilled_future(message)
-              end
-            end
-          end
-        end
-      end
-
-      # Returns a future witch will become fulfilled with a value from the channel when one is available.
-      # @param [ResolvableFuture] probe the future which will be fulfilled with a channel value
-      # @return [Future] the probe, its value will be the message when available.
-      def pop(probe = Concurrent::Promises.resolvable_future)
-        # TODO (pitr-ch 26-Dec-2016): improve performance
-        pop_for_select(probe).then(&:last)
-      end
-
-      # @!visibility private
-      def pop_for_select(probe = Concurrent::Promises.resolvable_future)
-        @Mutex.synchronize do
-          if @Messages.empty?
-            @Probes.push probe
-          else
-            message = @Messages.shift
-            probe.fulfill [self, message]
-
-            unless @PendingPush.empty?
-              message, pushed = @PendingPush.shift
-              @Messages.push message
-              pushed.fulfill message
-            end
-          end
-        end
-        probe
-      end
-
-      # @return [String] Short string representation.
-      def to_s
-        format '%s size:%s>', super[0..-2], @Size
-      end
-
-      alias_method :inspect, :to_s
-    end
-
     class Future < AbstractEventFuture
       # @!macro warn.edge
       module NewChannelIntegration
@@ -147,8 +56,8 @@ module Concurrent
         # @param [Channel] channel to push to.
         # @return [Future] a future which is fulfilled after the message is pushed to the channel.
         #   May take a moment if the channel is full.
-        def then_push_channel(channel)
-          self.then { |value| channel.push value }.flat_future
+        def then_channel_push(channel)
+          self.then(channel) { |value, ch| ch.push_op value }.flat_future
         end
 
       end
@@ -157,22 +66,6 @@ module Concurrent
     end
 
     module FactoryMethods
-      # @!macro warn.edge
-      module NewChannelIntegration
-
-        # Selects a channel which is ready to be read from.
-        # @param [Channel] channels
-        # @return [Future] a future which is fulfilled with pair [channel, message] when one of the channels is
-        #   available for reading
-        def select_channel(*channels)
-          probe = Promises.resolvable_future
-          channels.each { |ch| ch.pop_for_select probe }
-          probe
-        end
-      end
-
-      include NewChannelIntegration
-
       # @!macro promises.shortcut.on
       # @return [Future]
       # @!macro warn.edge
@@ -200,5 +93,82 @@ module Concurrent
       end
     end
 
+    module Resolvable
+      include InternalStates
+
+      # Reserves the event or future, if reserved others are prevented from resolving it.
+      # Advanced feature.
+      # Be careful about the order of reservation to avoid deadlocks,
+      # the method blocks if the future or event is already reserved
+      # until it is released or resolved.
+      #
+      # @example
+      #   f = Concurrent::Promises.resolvable_future
+      #   reserved = f.reserve
+      #   Thread.new { f.resolve true, :val, nil } # fails
+      #   f.resolve true, :val, nil, true if reserved # must be called only if reserved
+      # @return [true, false] on successful reservation
+      def reserve
+        while true
+          return true if compare_and_set_internal_state(PENDING, RESERVED)
+          return false if resolved?
+          # FIXME (pitr-ch 17-Jan-2019): sleep until given up or resolved instead of busy wait
+          Thread.pass
+        end
+      end
+
+      # @return [true, false] on successful release of the reservation
+      def release
+        compare_and_set_internal_state(RESERVED, PENDING)
+      end
+
+      # @return [Comparable] an item to sort the resolvable events or futures
+      #   by to get the right global locking order of resolvable events or futures
+      # @see .atomic_resolution
+      def self.locking_order_by(resolvable)
+        resolvable.object_id
+      end
+
+      # Resolves all passed events and futures to the given resolutions
+      # if possible (all are unresolved) or none.
+      #
+      # @param [Hash{Resolvable=>resolve_arguments}, Array<Array(Resolvable, resolve_arguments)>] resolvable_map
+      #   collection of resolvable events and futures which should be resolved all at once
+      #   and what should they be resolved to, examples:
+      #   ```ruby
+      #   { a_resolvable_future1 => [true, :val, nil],
+      #     a_resolvable_future2 => [false, nil, :err],
+      #     a_resolvable_event => [] }
+      #   ```
+      #    or
+      #   ```ruby
+      #   [[a_resolvable_future1, [true, :val, nil]],
+      #    [a_resolvable_future2, [false, nil, :err]],
+      #    [a_resolvable_event, []]]
+      #   ```
+      # @return [true, false] if success
+      def self.atomic_resolution(resolvable_map)
+        # atomic_resolution event => [], future => [true, :v, nil]
+        sorted = resolvable_map.to_a.sort_by { |resolvable, _| locking_order_by resolvable }
+
+        reserved = 0
+        while reserved < sorted.size && sorted[reserved].first.reserve
+          reserved += 1
+        end
+
+        if reserved == sorted.size
+          sorted.each { |resolvable, args| resolvable.resolve(*args, true, true) }
+          true
+        else
+          while reserved > 0
+            reserved -= 1
+            raise 'has to be reserved' unless sorted[reserved].first.release
+          end
+          false
+        end
+      end
+    end
+
+
   end
 end

data/lib-edge/concurrent/edge/throttle.rb

@@ -1,102 +1,121 @@
 module Concurrent
-  # @!macro throttle.example.throttled_block
-  #   @example
-  #     max_two = Throttle.new 2
-  #     10.times.map do
-  #       Thread.new do
-  #         max_two.throttled_block do
-  #           # Only 2 at the same time
-  #           do_stuff
-  #         end
-  #       end
-  #     end
-  # @!macro throttle.example.throttled_future
-  #   @example
-  #     throttle.throttled_future(1) do |arg|
-  #       arg.succ
-  #     end
-  # @!macro throttle.example.throttled_future_chain
-  #   @example
-  #     throttle.throttled_future_chain do |trigger|
-  #       trigger.
-  #           # 2 throttled promises
-  #           chain { 1 }.
-  #           then(&:succ)
-  #     end
-  # @!macro throttle.example.then_throttled_by
-  #   @example
-  #     data     = (1..5).to_a
-  #     db       = data.reduce({}) { |h, v| h.update v => v.to_s }
-  #     max_two  = Throttle.new 2
+  # A tool managing concurrency level of tasks.
+  # The maximum capacity is set in constructor.
+  # Each acquire will lower the available capacity and release will increase it.
+  # When there is no available capacity the current thread may either be blocked or
+  # an event is returned which will be resolved when capacity becomes available.
   #
-  #     futures = data.map do |data|
-  #       Promises.future(data) do |data|
-  #         # un-throttled, concurrency level equal data.size
-  #         data + 1
-  #       end.then_throttled_by(max_two, db) do |v, db|
-  #         # throttled, only 2 tasks executed at the same time
-  #         # e.g. limiting access to db
-  #         db[v]
-  #       end
-  #     end
+  # The more common usage of the Throttle is with a proxy executor
+  # `a_throttle.on(Concurrent.global_io_executor)`.
+  # Anything executed on the proxy executor will be throttled and
+  # execute on the given executor. There can be more than one proxy executors.
+  # All abstractions which execute tasks have option to specify executor,
+  # therefore the proxy executor can be injected to any abstraction
+  # throttling its concurrency level.
   #
-  #     futures.map(&:value!) # => [2, 3, 4, 5, nil]
-
-  # A tool manage concurrency level of future tasks.
+  # {include:file:docs-source/throttle.out.md}
   #
-  # @!macro throttle.example.then_throttled_by
-  # @!macro throttle.example.throttled_future
-  # @!macro throttle.example.throttled_future_chain
-  # @!macro throttle.example.throttled_block
   # @!macro warn.edge
   class Throttle < Synchronization::Object
-    # TODO (pitr-ch 21-Dec-2016): consider using sized channel for implementation instead when available
-
     safe_initialization!
-    attr_atomic(:can_run)
-    private :can_run, :can_run=, :swap_can_run, :compare_and_set_can_run, :update_can_run
 
-    # New throttle.
-    # @param [Integer] limit
-    def initialize(limit)
+    attr_atomic(:capacity)
+    private :capacity, :capacity=, :swap_capacity, :compare_and_set_capacity, :update_capacity
+
+    # @return [Integer] The available capacity.
+    def available_capacity
+      current_capacity = capacity
+      current_capacity >= 0 ? current_capacity : 0
+    end
+
+    # Create throttle.
+    # @param [Integer] capacity How many tasks using this throttle can run at the same time.
+    def initialize(capacity)
       super()
-      @Limit       = limit
-      self.can_run = limit
-      @Queue       = LockFreeQueue.new
+      @MaxCapacity            = capacity
+      @Queue                  = LockFreeQueue.new
+      @executor_cache         = [nil, nil]
+      self.capacity = capacity
     end
 
-    # @return [Integer] The limit.
-    def limit
-      @Limit
+    # @return [Integer] The maximum capacity.
+    def max_capacity
+      @MaxCapacity
     end
 
-    # New event which will be resolved when depending tasks can execute.
-    # Has to be used and after the critical work is done {#release} must be called exactly once.
-    # @return [Promises::Event]
+    # Blocks current thread until there is capacity available in the throttle.
+    # The acquired capacity has to be returned to the throttle by calling {#release}.
+    # If block is passed then the block is called after the capacity is acquired and
+    # it is automatically released after the block is executed.
+    #
+    # @param [Numeric] timeout the maximum time in second to wait.
+    # @yield [] block to execute after the capacity is acquired
+    # @return [Object, self, true, false]
+    #   * When no timeout and no block it returns self
+    #   * When no timeout and with block it returns the result of the block
+    #   * When with timeout and no block it returns true when acquired and false when timed out
+    #   * When with timeout and with block it returns the result of the block of nil on timing out
     # @see #release
-    def trigger
-      while true
-        current_can_run = can_run
-        if compare_and_set_can_run current_can_run, current_can_run - 1
-          if current_can_run > 0
-            return Promises.resolved_event
+    def acquire(timeout = nil, &block)
+      event = acquire_or_event
+      if event
+        within_timeout = event.wait(timeout)
+        # release immediately when acquired later after the timeout since it is unused
+        event.on_resolution!(self, &:release) unless within_timeout
+      else
+        within_timeout = true
+      end
+
+      called = false
+      if timeout
+        if block
+          if within_timeout
+            called = true
+            block.call
           else
-            event = Promises.resolvable_event
-            @Queue.push event
-            return event
+            nil
           end
+        else
+          within_timeout
+        end
+      else
+        if block
+          called = true
+          block.call
+        else
+          self
+        end
+      end
+    ensure
+      release if called
+    end
+
+    # Tries to acquire capacity from the throttle.
+    # Returns true when there is capacity available.
+    # The acquired capacity has to be returned to the throttle by calling {#release}.
+    # @return [true, false]
+    # @see #release
+    def try_acquire
+      while true
+        current_capacity = capacity
+        if current_capacity > 0
+          return true if compare_and_set_capacity(
+              current_capacity, current_capacity - 1)
+        else
+          return false
         end
       end
     end
 
-    # Has to be called once for each trigger after it is ok to execute another throttled task.
+    # Releases previously acquired capacity back to Throttle.
+    # Has to be called exactly once for each acquired capacity.
     # @return [self]
-    # @see #trigger
+    # @see #acquire_operation, #acquire, #try_acquire
     def release
       while true
-        current_can_run = can_run
-        if compare_and_set_can_run current_can_run, current_can_run + 1
-          if current_can_run < 0
+        current_capacity = capacity
+        if compare_and_set_capacity current_capacity, current_capacity + 1
+          if current_capacity < 0
             # release called after trigger which pushed a trigger, busy wait is ok
             Thread.pass until (trigger = @Queue.pop)
             trigger.resolve
@@ -106,94 +125,101 @@ module Concurrent
       end
     end
 
-    # Blocks current thread until the block can be executed.
-    # @yield to throttled block
-    # @yieldreturn [Object] is used as a result of the method
-    # @return [Object] the result of the block
-    # @!macro throttle.example.throttled_block
-    def throttled_block(&block)
-      trigger.wait
-      block.call
-    ensure
-      release
-    end
-
     # @return [String] Short string representation.
     def to_s
-      format '%s limit:%s can_run:%d>', super[0..-2], @Limit, can_run
+      format '%s capacity available %d of %d>', super[0..-2], capacity, @MaxCapacity
     end
 
     alias_method :inspect, :to_s
 
-    module PromisesIntegration
-
-      # Allows to throttle a chain of promises.
-      # @yield [trigger] a trigger which has to be used to build up a chain of promises, the last one is result
-      #   of the block. When the last one resolves, {Throttle#release} is called on the throttle.
-      # @yieldparam [Promises::Event, Promises::Future] trigger
-      # @yieldreturn [Promises::Event, Promises::Future] The final future of the throttled chain.
-      # @return [Promises::Event, Promises::Future] The final future of the throttled chain.
-      # @!macro throttle.example.throttled_future_chain
-      def throttled_future_chain(&throttled_futures)
-        throttled_futures.call(trigger).on_resolution! { release }
+    # @!visibility private
+    def acquire_or_event
+      while true
+        current_capacity = capacity
+        if compare_and_set_capacity current_capacity, current_capacity - 1
+          if current_capacity > 0
+            return nil
+          else
+            event = Promises.resolvable_event
+            @Queue.push event
+            return event
+          end
+        end
       end
+    end
 
-      # Behaves as {Promises::FactoryMethods#future} but the future is throttled.
-      # @return [Promises::Future]
-      # @see Promises::FactoryMethods#future
-      # @!macro throttle.example.throttled_future
-      def throttled_future(*args, &task)
-        trigger.chain(*args, &task).on_resolution! { release }
+    include Promises::FactoryMethods
+
+    # @param [ExecutorService] executor
+    # @return [ExecutorService] An executor which wraps given executor and allows to post tasks only
+    #   as available capacity in the throttle allows.
+    # @example throttling future
+    #   a_future.then_on(a_throttle.on(:io)) { a_throttled_task }
+    def on(executor = Promises::FactoryMethods.default_executor)
+      current_executor, current_cache = @executor_cache
+      return current_cache if current_executor == executor && current_cache
+
+      if current_executor.nil?
+        # cache first proxy
+        proxy_executor  = ProxyExecutor.new(self, Concurrent.executor(executor))
+        @executor_cache = [executor, proxy_executor]
+        return proxy_executor
+      else
+        # do not cache more than 1 executor
+        ProxyExecutor.new(self, Concurrent.executor(executor))
       end
     end
 
-    include PromisesIntegration
-  end
+    # Uses executor provided by {#on} therefore
+    # all events and futures created using factory methods on this object will be throttled.
+    # Overrides {Promises::FactoryMethods#default_executor}.
+    #
+    # @return [ExecutorService]
+    # @see Promises::FactoryMethods#default_executor
+    def default_executor
+      on(super)
+    end
 
-  module Promises
+    class ProxyExecutor < Synchronization::Object
+      safe_initialization!
 
-    class AbstractEventFuture < Synchronization::Object
-      module ThrottleIntegration
+      include ExecutorService
 
-        # @yieldparam [Future] a trigger
-        # @yieldreturn [Future, Event]
-        # @return [Future, Event]
-        def throttled_by(throttle, &throttled_futures)
-          a_trigger = self & self.chain { throttle.trigger }.flat_event
-          throttled_futures.call(a_trigger).on_resolution! { throttle.release }
-        end
+      def initialize(throttle, executor)
+        super()
+        @Throttle = throttle
+        @Executor = executor
+      end
 
-        # Behaves as {AbstractEventFuture#chain} but the it is throttled.
-        # @return [Future, Event]
-        # @see AbstractEventFuture#chain
-        def chain_throttled_by(throttle, *args, &block)
-          throttled_by(throttle) { |trigger| trigger.chain(*args, &block) }
+      def post(*args, &task)
+        if (event = @Throttle.acquire_or_event)
+          event.on_resolution! { inner_post(*args, &task) }
+        else
+          inner_post(*args, &task)
         end
       end
 
-      include ThrottleIntegration
-    end
+      def can_overflow?
+        @Executor.can_overflow?
+      end
 
-    class Future < AbstractEventFuture
-      module ThrottleIntegration
+      def serialized?
+        @Executor.serialized?
+      end
 
-        # Behaves as {Future#then} but the it is throttled.
-        # @return [Future]
-        # @see Future#then
-        # @!macro throttle.example.then_throttled_by
-        def then_throttled_by(throttle, *args, &block)
-          throttled_by(throttle) { |trigger| trigger.then(*args, &block) }
-        end
+      private
 
-        # Behaves as {Future#rescue} but the it is throttled.
-        # @return [Future]
-        # @see Future#rescue
-        def rescue_throttled_by(throttle, *args, &block)
-          throttled_by(throttle) { |trigger| trigger.rescue(*args, &block) }
+      def inner_post(*arguments, &task)
+        @Executor.post(*arguments) do |*args|
+          begin
+            task.call(*args)
+          ensure
+            @Throttle.release
+          end
         end
       end
-
-      include ThrottleIntegration
     end
+
+    private_constant :ProxyExecutor
   end
 end