RubyGems - concurrent-ruby - Versions diffs - 0.8.0 → 0.9.0.pre2 - Mend

concurrent-ruby 0.8.0 → 0.9.0.pre2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (144) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +97 -2
data/README.md +103 -54
data/lib/concurrent.rb +34 -14
data/lib/concurrent/async.rb +164 -50
data/lib/concurrent/atom.rb +171 -0
data/lib/concurrent/atomic/atomic_boolean.rb +57 -107
data/lib/concurrent/atomic/atomic_fixnum.rb +73 -101
data/lib/concurrent/atomic/atomic_reference.rb +49 -0
data/lib/concurrent/atomic/condition.rb +23 -12
data/lib/concurrent/atomic/count_down_latch.rb +23 -21
data/lib/concurrent/atomic/cyclic_barrier.rb +47 -47
data/lib/concurrent/atomic/event.rb +33 -42
data/lib/concurrent/atomic/read_write_lock.rb +252 -0
data/lib/concurrent/atomic/semaphore.rb +64 -89
data/lib/concurrent/atomic/thread_local_var.rb +130 -58
data/lib/concurrent/atomic/thread_local_var/weak_key_map.rb +236 -0
data/lib/concurrent/atomic_reference/direct_update.rb +3 -0
data/lib/concurrent/atomic_reference/jruby.rb +6 -3
data/lib/concurrent/atomic_reference/mutex_atomic.rb +10 -32
data/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb +3 -0
data/lib/concurrent/atomic_reference/rbx.rb +4 -1
data/lib/concurrent/atomic_reference/ruby.rb +6 -3
data/lib/concurrent/atomics.rb +74 -4
data/lib/concurrent/collection/copy_on_notify_observer_set.rb +115 -0
data/lib/concurrent/collection/copy_on_write_observer_set.rb +119 -0
data/lib/concurrent/collection/priority_queue.rb +300 -245
data/lib/concurrent/concern/deprecation.rb +27 -0
data/lib/concurrent/concern/dereferenceable.rb +88 -0
data/lib/concurrent/concern/logging.rb +25 -0
data/lib/concurrent/concern/obligation.rb +228 -0
data/lib/concurrent/concern/observable.rb +85 -0
data/lib/concurrent/configuration.rb +226 -112
data/lib/concurrent/dataflow.rb +2 -3
data/lib/concurrent/delay.rb +141 -50
data/lib/concurrent/edge.rb +30 -0
data/lib/concurrent/errors.rb +10 -0
data/lib/concurrent/exchanger.rb +25 -1
data/lib/concurrent/executor/cached_thread_pool.rb +46 -33
data/lib/concurrent/executor/executor.rb +46 -299
data/lib/concurrent/executor/executor_service.rb +521 -0
data/lib/concurrent/executor/fixed_thread_pool.rb +206 -26
data/lib/concurrent/executor/immediate_executor.rb +9 -9
data/lib/concurrent/executor/indirect_immediate_executor.rb +4 -3
data/lib/concurrent/executor/java_cached_thread_pool.rb +18 -16
data/lib/concurrent/executor/java_fixed_thread_pool.rb +11 -18
data/lib/concurrent/executor/java_single_thread_executor.rb +17 -16
data/lib/concurrent/executor/java_thread_pool_executor.rb +55 -102
data/lib/concurrent/executor/ruby_cached_thread_pool.rb +9 -18
data/lib/concurrent/executor/ruby_fixed_thread_pool.rb +10 -21
data/lib/concurrent/executor/ruby_single_thread_executor.rb +14 -16
data/lib/concurrent/executor/ruby_thread_pool_executor.rb +250 -166
data/lib/concurrent/executor/safe_task_executor.rb +5 -4
data/lib/concurrent/executor/serialized_execution.rb +22 -18
data/lib/concurrent/executor/{per_thread_executor.rb → simple_executor_service.rb} +29 -20
data/lib/concurrent/executor/single_thread_executor.rb +32 -21
data/lib/concurrent/executor/thread_pool_executor.rb +72 -60
data/lib/concurrent/executor/timer_set.rb +96 -84
data/lib/concurrent/executors.rb +1 -1
data/lib/concurrent/future.rb +70 -38
data/lib/concurrent/immutable_struct.rb +89 -0
data/lib/concurrent/ivar.rb +152 -60
data/lib/concurrent/lazy_register.rb +40 -20
data/lib/concurrent/maybe.rb +226 -0
data/lib/concurrent/mutable_struct.rb +227 -0
data/lib/concurrent/mvar.rb +44 -43
data/lib/concurrent/promise.rb +208 -134
data/lib/concurrent/scheduled_task.rb +339 -43
data/lib/concurrent/settable_struct.rb +127 -0
data/lib/concurrent/synchronization.rb +17 -0
data/lib/concurrent/synchronization/abstract_object.rb +163 -0
data/lib/concurrent/synchronization/abstract_struct.rb +158 -0
data/lib/concurrent/synchronization/condition.rb +53 -0
data/lib/concurrent/synchronization/java_object.rb +35 -0
data/lib/concurrent/synchronization/lock.rb +32 -0
data/lib/concurrent/synchronization/monitor_object.rb +24 -0
data/lib/concurrent/synchronization/mutex_object.rb +43 -0
data/lib/concurrent/synchronization/object.rb +78 -0
data/lib/concurrent/synchronization/rbx_object.rb +75 -0
data/lib/concurrent/timer_task.rb +87 -100
data/lib/concurrent/tvar.rb +42 -38
data/lib/concurrent/utilities.rb +3 -1
data/lib/concurrent/utility/at_exit.rb +97 -0
data/lib/concurrent/utility/engine.rb +40 -0
data/lib/concurrent/utility/monotonic_time.rb +59 -0
data/lib/concurrent/utility/native_extension_loader.rb +56 -0
data/lib/concurrent/utility/processor_counter.rb +156 -0
data/lib/concurrent/utility/timeout.rb +18 -14
data/lib/concurrent/utility/timer.rb +11 -6
data/lib/concurrent/version.rb +2 -1
data/lib/concurrent_ruby.rb +1 -0
metadata +47 -83
data/lib/concurrent/actor.rb +0 -103
data/lib/concurrent/actor/behaviour.rb +0 -70
data/lib/concurrent/actor/behaviour/abstract.rb +0 -48
data/lib/concurrent/actor/behaviour/awaits.rb +0 -21
data/lib/concurrent/actor/behaviour/buffer.rb +0 -54
data/lib/concurrent/actor/behaviour/errors_on_unknown_message.rb +0 -12
data/lib/concurrent/actor/behaviour/executes_context.rb +0 -18
data/lib/concurrent/actor/behaviour/linking.rb +0 -45
data/lib/concurrent/actor/behaviour/pausing.rb +0 -77
data/lib/concurrent/actor/behaviour/removes_child.rb +0 -16
data/lib/concurrent/actor/behaviour/sets_results.rb +0 -36
data/lib/concurrent/actor/behaviour/supervised.rb +0 -59
data/lib/concurrent/actor/behaviour/supervising.rb +0 -34
data/lib/concurrent/actor/behaviour/terminates_children.rb +0 -13
data/lib/concurrent/actor/behaviour/termination.rb +0 -54
data/lib/concurrent/actor/context.rb +0 -154
data/lib/concurrent/actor/core.rb +0 -217
data/lib/concurrent/actor/default_dead_letter_handler.rb +0 -9
data/lib/concurrent/actor/envelope.rb +0 -41
data/lib/concurrent/actor/errors.rb +0 -27
data/lib/concurrent/actor/internal_delegations.rb +0 -49
data/lib/concurrent/actor/public_delegations.rb +0 -40
data/lib/concurrent/actor/reference.rb +0 -81
data/lib/concurrent/actor/root.rb +0 -37
data/lib/concurrent/actor/type_check.rb +0 -48
data/lib/concurrent/actor/utils.rb +0 -10
data/lib/concurrent/actor/utils/ad_hoc.rb +0 -21
data/lib/concurrent/actor/utils/balancer.rb +0 -42
data/lib/concurrent/actor/utils/broadcast.rb +0 -52
data/lib/concurrent/actor/utils/pool.rb +0 -59
data/lib/concurrent/actress.rb +0 -3
data/lib/concurrent/agent.rb +0 -209
data/lib/concurrent/atomic.rb +0 -92
data/lib/concurrent/atomic/copy_on_notify_observer_set.rb +0 -118
data/lib/concurrent/atomic/copy_on_write_observer_set.rb +0 -117
data/lib/concurrent/atomic/synchronization.rb +0 -51
data/lib/concurrent/channel/buffered_channel.rb +0 -85
data/lib/concurrent/channel/channel.rb +0 -41
data/lib/concurrent/channel/unbuffered_channel.rb +0 -35
data/lib/concurrent/channel/waitable_list.rb +0 -40
data/lib/concurrent/channels.rb +0 -5
data/lib/concurrent/collection/blocking_ring_buffer.rb +0 -71
data/lib/concurrent/collection/ring_buffer.rb +0 -59
data/lib/concurrent/collections.rb +0 -3
data/lib/concurrent/dereferenceable.rb +0 -108
data/lib/concurrent/executor/ruby_thread_pool_worker.rb +0 -73
data/lib/concurrent/logging.rb +0 -20
data/lib/concurrent/obligation.rb +0 -171
data/lib/concurrent/observable.rb +0 -73
data/lib/concurrent/options_parser.rb +0 -52
data/lib/concurrent/utility/processor_count.rb +0 -152
data/lib/extension_helper.rb +0 -37

data/lib/concurrent/actress.rb DELETED Viewed

@@ -1,3 +0,0 @@
-require 'concurrent/actor'
-Concurrent::Actress = Concurrent::Actor

data/lib/concurrent/agent.rb DELETED Viewed

@@ -1,209 +0,0 @@
-require 'thread'
-require 'concurrent/dereferenceable'
-require 'concurrent/observable'
-require 'concurrent/options_parser'
-require 'concurrent/utility/timeout'
-require 'concurrent/logging'
-module Concurrent
-  # {include:file:doc/agent.md}
-  #
-  # @!attribute [r] timeout
-  #   @return [Fixnum] the maximum number of seconds before an update is cancelled
-  class Agent
-    include Dereferenceable
-    include Concurrent::Observable
-    include Logging
-    attr_reader :timeout, :task_executor, :operation_executor
-    # Initialize a new Agent with the given initial value and provided options.
-    #
-    # @param [Object] initial the initial value
-    # @param [Hash] opts the options used to define the behavior at update and deref
-    #
-    # @option opts [Boolean] :operation (false) when `true` will execute the future on the global
-    #   operation pool (for long-running operations), when `false` will execute the future on the
-    #   global task pool (for short-running tasks)
-    # @option opts [object] :executor when provided will run all operations on
-    #   this executor rather than the global thread pool (overrides :operation)
-    #
-    # @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
-    # @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
-    # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
-    #   returning the value returned from the proc
-    def initialize(initial, opts = {})
-      @value                = initial
-      @rescuers             = []
-      @validator            = Proc.new { |result| true }
-      self.observers        = CopyOnWriteObserverSet.new
-      @serialized_execution = SerializedExecution.new
-      @task_executor        = OptionsParser.get_task_executor_from(opts)
-      @operation_executor   = OptionsParser.get_operation_executor_from(opts)
-      init_mutex
-      set_deref_options(opts)
-    end
-    # Specifies a block operation to be performed when an update operation raises
-    # an exception. Rescue blocks will be checked in order they were added. The first
-    # block for which the raised exception "is-a" subclass of the given `clazz` will
-    # be called. If no `clazz` is given the block will match any caught exception.
-    # This behavior is intended to be identical to Ruby's `begin/rescue/end` behavior.
-    # Any number of rescue handlers can be added. If no rescue handlers are added then
-    # caught exceptions will be suppressed.
-    #
-    # @param [Exception] clazz the class of exception to catch
-    # @yield the block to be called when a matching exception is caught
-    # @yieldparam [StandardError] ex the caught exception
-    #
-    # @example
-    #   score = Concurrent::Agent.new(0).
-    #             rescue(NoMethodError){|ex| puts "Bam!" }.
-    #             rescue(ArgumentError){|ex| puts "Pow!" }.
-    #             rescue{|ex| puts "Boom!" }
-    #
-    #   score << proc{|current| raise ArgumentError }
-    #   sleep(0.1)
-    #   #=> puts "Pow!"
-    def rescue(clazz = StandardError, &block)
-      unless block.nil?
-        mutex.synchronize do
-          @rescuers << Rescuer.new(clazz, block)
-        end
-      end
-      self
-    end
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
-    # A block operation to be performed after every update to validate if the new
-    # value is valid. If the new value is not valid then the current value is not
-    # updated. If no validator is provided then all updates are considered valid.
-    #
-    # @yield the block to be called after every update operation to determine if
-    #   the result is valid
-    # @yieldparam [Object] value the result of the last update operation
-    # @yieldreturn [Boolean] true if the value is valid else false
-    def validate(&block)
-      unless block.nil?
-        begin
-          mutex.lock
-          @validator = block
-        ensure
-          mutex.unlock
-        end
-      end
-      self
-    end
-    alias_method :validates, :validate
-    alias_method :validate_with, :validate
-    alias_method :validates_with, :validate
-    # Update the current value with the result of the given block operation,
-    # block should not do blocking calls, use #post_off for blocking calls
-    #
-    # @yield the operation to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    # @return [true, nil] nil when no block is given
-    def post(&block)
-      post_on(@task_executor, &block)
-    end
-    # Update the current value with the result of the given block operation,
-    # block can do blocking calls
-    #
-    # @param [Fixnum, nil] timeout maximum number of seconds before an update is cancelled
-    #
-    # @yield the operation to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    # @return [true, nil] nil when no block is given
-    def post_off(timeout = nil, &block)
-      block = if timeout
-                lambda { |value| Concurrent::timeout(timeout) { block.call(value) } }
-              else
-                block
-              end
-      post_on(@operation_executor, &block)
-    end
-    # Update the current value with the result of the given block operation,
-    # block should not do blocking calls, use #post_off for blocking calls
-    #
-    # @yield the operation to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    def <<(block)
-      post(&block)
-      self
-    end
-    # Waits/blocks until all the updates sent before this call are done.
-    #
-    # @param [Numeric] timeout the maximum time in second to wait.
-    # @return [Boolean] false on timeout, true otherwise
-    def await(timeout = nil)
-      done = Event.new
-      post { |val| done.set; val }
-      done.wait timeout
-    end
-    private
-    def post_on(executor, &block)
-      return nil if block.nil?
-      @serialized_execution.post(executor) { work(&block) }
-      true
-    end
-    # @!visibility private
-    Rescuer = Struct.new(:clazz, :block) # :nodoc:
-    # @!visibility private
-    def try_rescue(ex) # :nodoc:
-      rescuer = mutex.synchronize do
-        @rescuers.find { |r| ex.is_a?(r.clazz) }
-      end
-      rescuer.block.call(ex) if rescuer
-    rescue Exception => ex
-      # suppress
-      log DEBUG, ex
-    end
-    # @!visibility private
-    def work(&handler) # :nodoc:
-      validator, value = mutex.synchronize { [@validator, @value] }
-      begin
-        result = handler.call(value)
-        valid  = validator.call(result)
-      rescue Exception => ex
-        exception = ex
-      end
-      begin
-        mutex.lock
-        should_notify = if !exception && valid
-                          @value = result
-                          true
-                        end
-      ensure
-        mutex.unlock
-      end
-      if should_notify
-        time = Time.now
-        observers.notify_observers { [time, self.value] }
-      end
-      try_rescue(exception)
-    end
-  end
-end

data/lib/concurrent/atomic.rb DELETED Viewed

@@ -1,92 +0,0 @@
-#####################################################################
-# Attempt to check for the deprecated ruby-atomic gem and warn the
-# user that they should use the new implementation instead.
-if defined?(Atomic)
-  warn <<-RUBY
-[ATOMIC] Detected an `Atomic` class, which may indicate a dependency
-on the ruby-atomic gem. That gem has been deprecated and merged into
-the concurrent-ruby gem. Please use the Concurrent::Atomic class for
-atomic references and not the Atomic class.
-RUBY
-end
-#####################################################################
-require_relative '../extension_helper'
-require 'concurrent/atomic_reference/concurrent_update_error'
-require 'concurrent/atomic_reference/mutex_atomic'
-begin
-  # force fallback impl with FORCE_ATOMIC_FALLBACK=1
-  if /[^0fF]/ =~ ENV['FORCE_ATOMIC_FALLBACK']
-    ruby_engine = 'mutex_atomic'
-  else
-    ruby_engine = defined?(RUBY_ENGINE)? RUBY_ENGINE : 'ruby'
-  end
-  require "concurrent/atomic_reference/#{ruby_engine}"
-rescue LoadError
-  #warn 'Compiled extensions not installed, pure Ruby Atomic will be used.'
-end
-if defined? Concurrent::JavaAtomic
-  # @!macro [attach] atomic_reference
-  #
-  #   An object reference that may be updated atomically.
-  #
-  #       Testing with ruby 2.1.2
-  #
-  #       *** Sequential updates ***
-  #                        user     system      total        real
-  #       no lock      0.000000   0.000000   0.000000 (  0.005502)
-  #       mutex        0.030000   0.000000   0.030000 (  0.025158)
-  #       MutexAtomic  0.100000   0.000000   0.100000 (  0.103096)
-  #       CAtomic      0.040000   0.000000   0.040000 (  0.034012)
-  #
-  #       *** Parallel updates ***
-  #                        user     system      total        real
-  #       no lock      0.010000   0.000000   0.010000 (  0.009387)
-  #       mutex        0.030000   0.010000   0.040000 (  0.032545)
-  #       MutexAtomic  0.830000   2.280000   3.110000 (  2.146622)
-  #       CAtomic      0.040000   0.000000   0.040000 (  0.038332)
-  #
-  #       Testing with jruby 1.9.3
-  #
-  #       *** Sequential updates ***
-  #                        user     system      total        real
-  #       no lock      0.170000   0.000000   0.170000 (  0.051000)
-  #       mutex        0.370000   0.010000   0.380000 (  0.121000)
-  #       MutexAtomic  1.530000   0.020000   1.550000 (  0.471000)
-  #       JavaAtomic   0.370000   0.010000   0.380000 (  0.112000)
-  #
-  #       *** Parallel updates ***
-  #                        user     system      total        real
-  #       no lock      0.390000   0.000000   0.390000 (  0.105000)
-  #       mutex        0.480000   0.040000   0.520000 (  0.145000)
-  #       MutexAtomic  1.600000   0.180000   1.780000 (  0.511000)
-  #       JavaAtomic   0.460000   0.010000   0.470000 (  0.131000)
-  #
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
-  class Concurrent::Atomic < Concurrent::JavaAtomic
-  end
-elsif defined? Concurrent::RbxAtomic
-  # @!macro atomic_reference
-  class Concurrent::Atomic < Concurrent::RbxAtomic
-  end
-elsif defined? Concurrent::CAtomic
-  # @!macro atomic_reference
-  class Concurrent::Atomic < Concurrent::CAtomic
-  end
-else
-  # @!macro atomic_reference
-  class Concurrent::Atomic < Concurrent::MutexAtomic
-  end
-end

data/lib/concurrent/atomic/copy_on_notify_observer_set.rb DELETED Viewed

@@ -1,118 +0,0 @@
-module Concurrent
-  # A thread safe observer set implemented using copy-on-read approach:
-  # observers are added and removed from a thread safe collection; every time
-  # a notification is required the internal data structure is copied to
-  # prevent concurrency issues
-  class CopyOnNotifyObserverSet
-    def initialize
-      @mutex = Mutex.new
-      @observers = {}
-    end
-    # Adds an observer to this set
-    # If a block is passed, the observer will be created by this method and no other params should be passed
-    # @param [Object] observer the observer to add
-    # @param [Symbol] func the function to call on the observer during notification. Default is :update
-    # @return [Object] the added observer
-    def add_observer(observer=nil, func=:update, &block)
-      if observer.nil? && block.nil?
-        raise ArgumentError, 'should pass observer as a first argument or block'
-      elsif observer && block
-        raise ArgumentError.new('cannot provide both an observer and a block')
-      end
-      if block
-        observer = block
-        func = :call
-      end
-      begin
-        @mutex.lock
-        @observers[observer] = func
-      ensure
-        @mutex.unlock
-      end
-        observer
-    end
-    # @param [Object] observer the observer to remove
-    # @return [Object] the deleted observer
-    def delete_observer(observer)
-      @mutex.lock
-      @observers.delete(observer)
-      @mutex.unlock
-      observer
-    end
-    # Deletes all observers
-    # @return [CopyOnWriteObserverSet] self
-    def delete_observers
-      @mutex.lock
-      @observers.clear
-      @mutex.unlock
-      self
-    end
-    # @return [Integer] the observers count
-    def count_observers
-      @mutex.lock
-      result = @observers.count
-      @mutex.unlock
-      result
-    end
-    # Notifies all registered observers with optional args
-    # @param [Object] args arguments to be passed to each observer
-    # @return [CopyOnWriteObserverSet] self
-    def notify_observers(*args, &block)
-      observers = duplicate_observers
-      notify_to(observers, *args, &block)
-      self
-    end
-    # Notifies all registered observers with optional args and deletes them.
-    #
-    # @param [Object] args arguments to be passed to each observer
-    # @return [CopyOnWriteObserverSet] self
-    def notify_and_delete_observers(*args, &block)
-      observers = duplicate_and_clear_observers
-      notify_to(observers, *args, &block)
-      self
-    end
-    private
-    def duplicate_and_clear_observers
-      @mutex.lock
-      observers = @observers.dup
-      @observers.clear
-      @mutex.unlock
-      observers
-    end
-    def duplicate_observers
-      @mutex.lock
-      observers = @observers.dup
-      @mutex.unlock
-      observers
-    end
-    def notify_to(observers, *args)
-      raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
-      observers.each do |observer, function|
-        args = yield if block_given?
-        observer.send(function, *args)
-      end
-    end
-  end
-end

data/lib/concurrent/atomic/copy_on_write_observer_set.rb DELETED Viewed

@@ -1,117 +0,0 @@
-module Concurrent
-  # A thread safe observer set implemented using copy-on-write approach:
-  # every time an observer is added or removed the whole internal data structure is
-  # duplicated and replaced with a new one.
-  class CopyOnWriteObserverSet
-    def initialize
-      @mutex = Mutex.new
-      @observers = {}
-    end
-    # Adds an observer to this set
-    # If a block is passed, the observer will be created by this method and no other params should be passed
-    # @param [Object] observer the observer to add
-    # @param [Symbol] func the function to call on the observer during notification. Default is :update
-    # @return [Object] the added observer
-    def add_observer(observer=nil, func=:update, &block)
-      if observer.nil? && block.nil?
-        raise ArgumentError, 'should pass observer as a first argument or block'
-      elsif observer && block
-        raise ArgumentError.new('cannot provide both an observer and a block')
-      end
-      if block
-        observer = block
-        func = :call
-      end
-      begin
-        @mutex.lock
-        new_observers = @observers.dup
-        new_observers[observer] = func
-        @observers = new_observers
-        observer
-      ensure
-        @mutex.unlock
-      end
-    end
-    # @param [Object] observer the observer to remove
-    # @return [Object] the deleted observer
-    def delete_observer(observer)
-      @mutex.lock
-      new_observers = @observers.dup
-      new_observers.delete(observer)
-      @observers = new_observers
-      observer
-    ensure
-      @mutex.unlock
-    end
-    # Deletes all observers
-    # @return [CopyOnWriteObserverSet] self
-    def delete_observers
-      self.observers = {}
-      self
-    end
-    # @return [Integer] the observers count
-    def count_observers
-      observers.count
-    end
-    # Notifies all registered observers with optional args
-    # @param [Object] args arguments to be passed to each observer
-    # @return [CopyOnWriteObserverSet] self
-    def notify_observers(*args, &block)
-      notify_to(observers, *args, &block)
-      self
-    end
-    # Notifies all registered observers with optional args and deletes them.
-    #
-    # @param [Object] args arguments to be passed to each observer
-    # @return [CopyOnWriteObserverSet] self
-    def notify_and_delete_observers(*args, &block)
-      old = clear_observers_and_return_old
-      notify_to(old, *args, &block)
-      self
-    end
-    private
-    def notify_to(observers, *args)
-      raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
-      observers.each do |observer, function|
-        args = yield if block_given?
-        observer.send(function, *args)
-      end
-    end
-    def observers
-      @mutex.lock
-      @observers
-    ensure
-      @mutex.unlock
-    end
-    def observers=(new_set)
-      @mutex.lock
-      @observers = new_set
-    ensure
-      @mutex.unlock
-    end
-    def clear_observers_and_return_old
-      @mutex.lock
-      old_observers = @observers
-      @observers = {}
-      old_observers
-    ensure
-      @mutex.unlock
-    end
-  end
-end