concurrent-ruby-edge 0.1.2 → 0.2.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e691a974bbd43a36db55136dfefc96376a18ee99
-  data.tar.gz: c2fab3e02530312a7ed81244bbeead41cd616281
+  metadata.gz: 09cfa6d29b8c6ad451d4d5805fe16ff7fe490703
+  data.tar.gz: 721b15c9fa7a8c38e88c9d5f1e8597e0528386c6
 SHA512:
-  metadata.gz: e00ec82a9a7e7a55ca5eab51e46eb3f412a45a4b38c76757348772adfdc72f8066f9b4a5412ed35949e3b7c8145d1d2bd1934d4f4b2cff2ef73922acb59214e8
-  data.tar.gz: 22c85760d062d301affa2af1b4a4a841e8a1064e9f0600909a599a449b2cc0fc2e70f6db6da1d6fb716e45d5ad9e046d7b6532cf76c156c3734cd582cefa04ba
+  metadata.gz: ce588f1344ce16ab7c0d166bdc1f5c86c02c908083d7fcc10c7ead35a665af4325c1e9ccabfc925f289fdb15db1d68a4fff621d67b921b6b75f6115fc4ffc22b
+  data.tar.gz: 479a2bb45adde98a74aa5ced4fea11d1112ccedb64d07e5dc5783d07cf750d905888effd97d8108b3dc2b928f394055423aa5bc6b8343bc26647b62bf4422300

data/README.md

@@ -47,7 +47,7 @@
 
 MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported.
 This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
-Java 8 is required for JRuby (Java 7 support is deprecated in version 0.9 and will be removed in 1.0).
+Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs will be supported.
 
 ## Features & Documentation
 
@@ -62,54 +62,62 @@ This library contains a variety of concurrency abstractions at high and low leve
 #### General-purpose Concurrency Abstractions
 
 * [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
-* [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
 * [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html): An asynchronous operation that produces a value.
   * [Dataflow](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#dataflow-class_method): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
 * [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features.
 * [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html): Like a Future scheduled for a specific future time.
 * [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals.
 
-#### Thread-safe Value Objects
+#### Thread-safe Value Objects, Structures, and Collections
+
+Collection classes that were originally part of the (deprecated) `thread_safe` gem:
+
+* [Array](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Array.html) A thread-safe subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
+* [Hash](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Hash.html) A thread-safe subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
+* [Map](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Map.html) A hash-like object that should have much better performance characteristics, especially under high concurrency, than `Concurrent::Hash`.
+* [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Tuple.html) A fixed size array with volatile (synchronized, thread safe) getters/setters.
+
+Value objects inspired by other languages:
 
-* `Maybe` A thread-safe, immutable object representing an optional value, based on
+* [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
+* [Maybe](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Maybe.html) A thread-safe, immutable object representing an optional value, based on
   [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
-* `Delay` Lazy evaluation of a block yielding an immutable result. Based on Clojure's
+* [Delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html) Lazy evaluation of a block yielding an immutable result. Based on Clojure's
    [delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html).
 
-#### Thread-safe Structures
+Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
+
+* [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ImmutableStruct.html) Immutable struct where values are set at construction and cannot be changed later.
+* [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutableStruct.html) Synchronized, mutable struct where values can be safely changed at any time.
+* [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/SettableStruct.html) Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
 
-Derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
+Thread-safe variables:
 
-* `ImmutableStruct` Immutable struct where values are set at construction and cannot be changed later.
-* `MutableStruct` Synchronized, mutable struct where values can be safely changed at any time.
-* `SettableStruct` Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
+* [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html) A boolean value that can be updated atomically.
+* [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html) A numeric value that can be updated atomically.
+* [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html) An object reference that may be updated atomically.
+* [ThreadLocalVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html) A variable where the value is different for each thread.
 
 #### Java-inspired ThreadPools and Other Executors
 
-* See [ThreadPool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
+* See the [thread pool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
 
 #### Thread Synchronization Classes and Algorithms
 
-* [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html)
-* [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
-* [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
-* [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html)
-
-#### Thread-safe Variables
-
-* [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html)
-* [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html)
-* [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html)
-* [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar)
-* [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar)
-* [Thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
-* [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
-* [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html)
-* [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html)
+* [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html) A synchronization object that allows one thread to wait on multiple other threads.
+* [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html) A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
+* [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html) Old school kernel-style event.
+* [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
+* [I-Structure](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar) Similar to a "future" but can be manually assigned once, after which it becomes immutable.
+* [M-Structure](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar) A synchronized single element container.
+* [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html) A lock that supports multiple readers but only one writer.
+* [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html) A read/write lock with reentrant and upgrade features.
+* [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html) A counting-based locking mechanism that uses permits.
+* [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar) A transactional variable - a single-element container that is used as part of a transaction.
 
 ### Edge Features
 
-These are available in the `concurrent-ruby-edge` companion gem, installed with `gem install concurrent-ruby-edge`.
+These are available in the `concurrent-ruby-edge` companion gem.
 
 These features are under active development and may change frequently. They are expected not to
 keep backward compatibility (there may also lack tests and documentation). Semantic versions will
@@ -125,10 +133,9 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 * [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A single atomic value that represents an identity.
 * [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html):
   Communicating Sequential Processes (CSP).
-* [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
 * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
-* [Atomic Markable Reference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
-* [LockFreeLinked Set](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
+* [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
+* [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
 * [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeStack.html)
 
 #### Statuses:
@@ -139,52 +146,21 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 - **Future/Promise Framework** - API changes; partial documentation and tests; stability good.
 - **Agent** - Incomplete behaviour compared to Clojure's models; stability good.
 - **Channel** - Missing documentation; limted features; stability good.
-- **Exchanger** - Known race condition requiring a new implementation.
 - **LazyRegister** - Missing documentation and tests.
 - **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Needs real world battle testing
 
 ## Usage
 
-All abstractions within this gem can be loaded simply by requiring it:
+Everything within this gem can be loaded simply by requiring it:
 
 ```ruby
 require 'concurrent'
 ```
 
-To reduce the amount of code loaded at runtime, subsets of this gem can be required:
+To use the tools in the Edge gem it must be required separately:
 
 ```ruby
-require 'concurrent'                # everything
-
-# groups
-
-require 'concurrent/atomics'        # atomic and thread synchronization classes
-require 'concurrent/executors'      # Thread pools and other executors
-
-# individual abstractions
-
-require 'concurrent/async'            # Concurrent::Async
-require 'concurrent/atom'             # Concurrent::Atom
-require 'concurrent/dataflow'         # Concurrent::dataflow
-require 'concurrent/delay'            # Concurrent::Delay
-require 'concurrent/future'           # Concurrent::Future
-require 'concurrent/immutable_struct' # Concurrent::ImmutableStruct
-require 'concurrent/ivar'             # Concurrent::IVar
-require 'concurrent/maybe'            # Concurrent::Maybe
-require 'concurrent/mutable_struct'   # Concurrent::MutableStruct
-require 'concurrent/mvar'             # Concurrent::MVar
-require 'concurrent/promise'          # Concurrent::Promise
-require 'concurrent/scheduled_task'   # Concurrent::ScheduledTask
-require 'concurrent/settable_struct'  # Concurrent::SettableStruct
-require 'concurrent/timer_task'       # Concurrent::TimerTask
-require 'concurrent/tvar'             # Concurrent::TVar
-
-# experimental - available in `concurrent-ruby-edge` companion gem
-
-require 'concurrent/actor'          # Concurrent::Actor and supporting code
-require 'concurrent/edge/future'    # new Future Framework
-require 'concurrent/agent'          # Concurrent::Agent
-require 'concurrent/channel '       # Concurrent::Channel and supporting code
+require 'concurrent-edge'
 ```
 
 If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.
@@ -203,6 +179,23 @@ gem 'concurrent-ruby'
 
 and run `bundle install` from your shell.
 
+### Edge Gem Installation
+
+The Edge gem must be installed separately from the core gem:
+
+```shell
+gem install concurrent-ruby-edge
+```
+
+or add the following line to Gemfile:
+
+```ruby
+gem 'concurrent-ruby-edge'
+```
+
+and run `bundle install` from your shell.
+
+
 ### C Extensions for MRI
 
 Potential performance improvements may be achieved under MRI by installing optional C extensions.
@@ -240,7 +233,7 @@ The best practice is to depend on `concurrent-ruby` and let users to decide if t
 
 All published versions of this gem (core, extension, and several platform-specific packages) are compiled,
 packaged, tested, and published using an open, [automated process](https://github.com/ruby-concurrency/rake-compiler-dev-box).
-This process can also be used to create pre-compiled binaries of the extension gem for virtally
+This process can also be used to create pre-compiled binaries of the extension gem for virtually
 any platform. *Documentation is forthcoming...*
 
 ```
@@ -272,11 +265,17 @@ bundle exec rake compile            # Compile all the extensions
 ## Maintainers
 
 * [Jerry D'Antonio](https://github.com/jdantonio) (creator)
+* [Petr Chalupa](https://github.com/pitr-ch)
 * [Michele Della Torre](https://github.com/mighe)
 * [Chris Seaton](https://github.com/chrisseaton)
-* [Lucas Allan](https://github.com/lucasallan)
-* [Petr Chalupa](https://github.com/pitr-ch)
 * [Paweł Obrok](https://github.com/obrok)
+* [Lucas Allan](https://github.com/lucasallan)
+
+### Special Thanks
+
+* [Brian Durand](https://github.com/bdurand) for the `ref` gem
+* [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
+* [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
 
 ## Contributing
 

data/lib/concurrent/actor.rb

@@ -85,7 +85,7 @@ module Concurrent
     # @overload to_spawn_options(opts)
     #   see {Core#initialize} opts
     def self.to_spawn_options(*args)
-      if args.size == 1 && args.first.is_a?(Hash)
+      if args.size == 1 && args.first.is_a?(::Hash)
         args.first
       else
         { class: args[0],

data/lib/concurrent/actor/behaviour/abstract.rb

@@ -6,6 +6,7 @@ module Concurrent
       class Abstract
         include TypeCheck
         include InternalDelegations
+        include Concern::Logging
 
         attr_reader :core, :subsequent
 
@@ -41,7 +42,7 @@ module Concurrent
         def reject_envelope(envelope)
           envelope.reject! ActorTerminated.new(reference)
           dead_letter_routing << envelope unless envelope.future
-          log(DEBUG) { "rejected #{envelope.message} from #{envelope.sender_path}"}
+          log DEBUG, "rejected #{envelope.message} from #{envelope.sender_path}"
         end
       end
     end

data/lib/concurrent/actor/behaviour/sets_results.rb

@@ -14,7 +14,7 @@ module Concurrent
           result = pass envelope
           if result != MESSAGE_PROCESSED && !envelope.future.nil?
             envelope.future.success result
-            log(DEBUG) { "finished processing of #{envelope.message.inspect}"}
+            log DEBUG, "finished processing of #{envelope.message.inspect}"
           end
           nil
         rescue => error

data/lib/concurrent/actor/context.rb

@@ -24,6 +24,7 @@ module Concurrent
     class AbstractContext
       include TypeCheck
       include InternalDelegations
+      include Concern::Logging
 
       attr_reader :core
 
@@ -128,7 +129,7 @@ module Concurrent
       end
 
       def self.to_spawn_options(name_or_opts, *args)
-        if name_or_opts.is_a? Hash
+        if name_or_opts.is_a? ::Hash
           if name_or_opts.key?(:class) && name_or_opts[:class] != self
             raise ArgumentError,
                   ':class option is ignored when calling on context class, use Actor.spawn instead'

data/lib/concurrent/actor/core.rb

@@ -91,7 +91,7 @@ module Concurrent
       # @param [Envelope] envelope
       def on_envelope(envelope)
         schedule_execution do
-          log(DEBUG) { "was #{envelope.future ? 'asked' : 'told'} #{envelope.message.inspect} by #{envelope.sender}" }
+          log DEBUG, "was #{envelope.future ? 'asked' : 'told'} #{envelope.message.inspect} by #{envelope.sender}"
           process_envelope envelope
         end
         nil
@@ -128,7 +128,7 @@ module Concurrent
       end
 
       def broadcast(public, event)
-        log(DEBUG) { "event: #{event.inspect} (#{public ? 'public' : 'private'})" }
+        log DEBUG, "event: #{event.inspect} (#{public ? 'public' : 'private'})"
         @first_behaviour.on_event(public, event)
       end
 
@@ -164,7 +164,7 @@ module Concurrent
       private
 
       def ns_initialize(opts, &block)
-        @mailbox              = Array.new
+        @mailbox              = ::Array.new
         @serialized_execution = SerializedExecution.new
         @children             = Set.new
 
@@ -208,7 +208,7 @@ module Concurrent
       end
 
       def initialize_behaviours(opts)
-        @behaviour_definition = (Type! opts[:behaviour_definition] || @context.behaviour_definition, Array).each do |(behaviour, _)|
+        @behaviour_definition = (Type! opts[:behaviour_definition] || @context.behaviour_definition, ::Array).each do |(behaviour, _)|
           Child! behaviour, Behaviour::Abstract
         end
         @behaviours           = {}

data/lib/concurrent/actor/default_dead_letter_handler.rb

@@ -2,7 +2,7 @@ module Concurrent
   module Actor
     class DefaultDeadLetterHandler < RestartingContext
       def on_message(dead_letter)
-        log(INFO) { "got dead letter #{dead_letter.inspect}"}
+        log INFO, "got dead letter #{dead_letter.inspect}"
       end
     end
   end

data/lib/concurrent/actor/internal_delegations.rb

@@ -2,7 +2,6 @@ module Concurrent
   module Actor
     module InternalDelegations
       include PublicDelegations
-      include Logger::Severity
 
       # @see Core#children
       def children

data/lib/concurrent/actor/root.rb

@@ -14,7 +14,7 @@ module Concurrent
       # to allow spawning of new actors, spawn needs to be called inside the parent Actor
       def on_message(message)
         case
-        when message.is_a?(Array) && message.first == :spawn
+        when message.is_a?(::Array) && message.first == :spawn
           Actor.spawn message[1], &message[2]
         when message == :dead_letter_routing
           @dead_letter_router

data/lib/concurrent/actor/utils/pool.rb

@@ -29,7 +29,7 @@ module Concurrent
       class Pool < RestartingContext
         def initialize(size, &worker_initializer)
           @balancer = Balancer.spawn name: :balancer, supervise: true
-          @workers  = Array.new(size, &worker_initializer)
+          @workers  = ::Array.new(size, &worker_initializer)
           @workers.each do |worker|
             Type! worker, Reference
             @balancer << [:subscribe, worker]

data/lib/concurrent/agent.rb

@@ -1,10 +1,9 @@
-require 'thread'
 require 'concurrent/collection/copy_on_write_observer_set'
 require 'concurrent/concern/dereferenceable'
 require 'concurrent/concern/observable'
 require 'concurrent/concern/logging'
 require 'concurrent/executor/executor'
-require 'concurrent/concern/deprecation'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -81,11 +80,10 @@ module Concurrent
   #   @return [Fixnum] the maximum number of seconds before an update is cancelled
   #
   # @!macro edge_warning
-  class Agent
+  class Agent < Synchronization::Object
     include Concern::Dereferenceable
     include Concern::Observable
     include Concern::Logging
-    include Concern::Deprecation
 
     attr_reader :timeout, :io_executor, :fast_executor
 
@@ -95,15 +93,8 @@ module Concurrent
     #
     # @!macro executor_and_deref_options
     def initialize(initial, opts = {})
-      @value                = initial
-      @rescuers             = []
-      @validator            = Proc.new { |result| true }
-      self.observers        = Collection::CopyOnWriteObserverSet.new
-      @serialized_execution = SerializedExecution.new
-      @io_executor          = Executor.executor_from_options(opts) || Concurrent.global_io_executor
-      @fast_executor        = Executor.executor_from_options(opts) || Concurrent.global_fast_executor
-      init_mutex
-      set_deref_options(opts)
+      super()
+      synchronize { ns_initialize(initial, opts) }
     end
 
     # Specifies a block fast to be performed when an update fast raises
@@ -129,9 +120,7 @@ module Concurrent
     #   #=> puts "Pow!"
     def rescue(clazz = StandardError, &block)
       unless block.nil?
-        mutex.synchronize do
-          @rescuers << Rescuer.new(clazz, block)
-        end
+        synchronize { @rescuers << Rescuer.new(clazz, block) }
       end
       self
     end
@@ -139,7 +128,7 @@ module Concurrent
     alias_method :catch, :rescue
     alias_method :on_error, :rescue
 
-    # A block fast to be performed after every update to validate if the new
+    # A block task 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.
     #
@@ -150,12 +139,7 @@ module Concurrent
     def validate(&block)
 
       unless block.nil?
-        begin
-          mutex.lock
-          @validator = block
-        ensure
-          mutex.unlock
-        end
+        synchronize { @validator = block }
       end
       self
     end
@@ -179,30 +163,13 @@ module Concurrent
     # Update the current value with the result of the given block fast,
     # block can do blocking calls
     #
-    # @param [Fixnum, nil] timeout [DEPRECATED] maximum number of seconds before an update is cancelled
-    #
     # @yield the fast 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)
-      task = if timeout
-               deprecated 'post_off with option timeout options is deprecated and will be removed'
-               lambda do |value|
-                 future = Future.execute do
-                   block.call(value)
-                 end
-                 if future.wait(timeout)
-                   future.value!
-                 else
-                   raise Concurrent::TimeoutError
-                 end
-               end
-             else
-               block
-             end
-      post_on(@io_executor, &task)
+    def post_off(&block)
+      post_on(@io_executor, &block)
     end
 
     # Update the current value with the result of the given block fast,
@@ -227,6 +194,20 @@ module Concurrent
       done.wait timeout
     end
 
+    protected
+
+    def ns_initialize(initial, opts)
+      init_mutex(self)
+      @value                = initial
+      @rescuers             = []
+      @validator            = Proc.new { |result| true }
+      self.observers        = Collection::CopyOnWriteObserverSet.new
+      @serialized_execution = SerializedExecution.new
+      @io_executor          = Executor.executor_from_options(opts) || Concurrent.global_io_executor
+      @fast_executor        = Executor.executor_from_options(opts) || Concurrent.global_fast_executor
+      set_deref_options(opts)
+    end
+
     private
 
     def post_on(executor, &block)
@@ -240,7 +221,7 @@ module Concurrent
 
     # @!visibility private
     def try_rescue(ex) # :nodoc:
-      rescuer = mutex.synchronize do
+      rescuer = synchronize do
         @rescuers.find { |r| ex.is_a?(r.clazz) }
       end
       rescuer.block.call(ex) if rescuer
@@ -251,7 +232,7 @@ module Concurrent
 
     # @!visibility private
     def work(&handler) # :nodoc:
-      validator, value = mutex.synchronize { [@validator, @value] }
+      validator, value = synchronize { [@validator, @value] }
 
       begin
         result = handler.call(value)
@@ -260,14 +241,11 @@ module Concurrent
         exception = ex
       end
 
-      begin
-        mutex.lock
-        should_notify = if !exception && valid
-                          @value = result
-                          true
-                        end
-      ensure
-        mutex.unlock
+      should_notify = synchronize do
+        if !exception && valid
+          @value = result
+          true
+        end
       end
 
       if should_notify

data/lib/concurrent/channel/buffered_channel.rb

@@ -1,3 +1,4 @@
+require 'concurrent/synchronization'
 require 'concurrent/channel/waitable_list'
 
 module Concurrent
@@ -5,14 +6,11 @@ module Concurrent
 
     # @api Channel
     # @!macro edge_warning
-    class BufferedChannel
+    class BufferedChannel < Synchronization::Object
 
       def initialize(size)
-        @mutex = Mutex.new
-        @buffer_condition = ConditionVariable.new
-
-        @probe_set = WaitableList.new
-        @buffer = RingBuffer.new(size)
+        super()
+        synchronize { ns_initialize(size) }
       end
 
       def probe_set_size
@@ -20,11 +18,11 @@ module Concurrent
       end
 
       def buffer_queue_size
-        @mutex.synchronize { @buffer.count }
+        synchronize { @buffer.count }
       end
 
       def push(value)
-        until set_probe_or_push_into_buffer(value)
+        until set_probe_or_ns_push_into_buffer(value)
         end
       end
 
@@ -35,15 +33,13 @@ module Concurrent
       end
 
       def select(probe)
-        @mutex.synchronize do
-
+        synchronize do
           if @buffer.empty?
             @probe_set.put(probe)
             true
           else
-            shift_buffer if probe.try_set([peek_buffer, self])
+            ns_shift_buffer if probe.try_set([ns_peek_buffer, self])
           end
-
         end
       end
 
@@ -51,37 +47,43 @@ module Concurrent
         @probe_set.delete(probe)
       end
 
+      protected
+
+      def ns_initialize(size)
+        @probe_set = WaitableList.new
+        @buffer = RingBuffer.new(size)
+      end
+
       private
 
-      def push_into_buffer(value)
-        @buffer_condition.wait(@mutex) while @buffer.full?
+      def ns_push_into_buffer(value)
+        ns_wait while @buffer.full?
         @buffer.offer value
-        @buffer_condition.broadcast
+        ns_broadcast
       end
 
-      def peek_buffer
-        @buffer_condition.wait(@mutex) while @buffer.empty?
+      def ns_peek_buffer
+        ns_wait while @buffer.empty?
         @buffer.peek
       end
 
-      def shift_buffer
-        @buffer_condition.wait(@mutex) while @buffer.empty?
+      def ns_shift_buffer
+        ns_wait while @buffer.empty?
         result = @buffer.poll
-        @buffer_condition.broadcast
+        ns_broadcast
         result
       end
 
-      def set_probe_or_push_into_buffer(value)
-        @mutex.synchronize do
+      def set_probe_or_ns_push_into_buffer(value)
+        synchronize do
           if @probe_set.empty?
-            push_into_buffer(value)
+            ns_push_into_buffer(value)
             true
           else
             @probe_set.take.try_set([value, self])
           end
         end
       end
-
     end
   end
 end

data/lib/concurrent/channel/ring_buffer.rb

@@ -8,7 +8,7 @@ module Concurrent
     class RingBuffer
 
       def initialize(capacity)
-        @buffer = Array.new(capacity)
+        @buffer = ::Array.new(capacity)
         @first = @last = 0
         @count = 0
       end

data/lib/concurrent/edge/atomic_markable_reference.rb

@@ -174,7 +174,7 @@ module Concurrent
       end
 
       # Internal/private ImmutableArray for representing pairs
-      class ImmutableArray < Array
+      class ImmutableArray < ::Array
         def self.new(*args)
           super(*args).freeze
         end

data/lib/concurrent/edge/future.rb

@@ -1,4 +1,5 @@
 require 'concurrent' # TODO do not require whole concurrent gem
+require 'concurrent/concern/deprecation'
 require 'concurrent/edge/lock_free_stack'
 
 
@@ -602,7 +603,7 @@ module Concurrent
       def exception(*args)
         raise 'obligation is not failed' unless failed?
         reason = @State.get.reason
-        if reason.is_a?(Array)
+        if reason.is_a?(::Array)
           reason.each { |e| log ERROR, 'Edge::Future', e }
           Concurrent::Error.new 'multiple exceptions, inspect log'
         else
@@ -1014,7 +1015,7 @@ module Concurrent
       private
 
       def initialize_blocked_by(blocked_by_futures)
-        @BlockedBy = Array(blocked_by_futures)
+        @BlockedBy = [blocked_by_futures].flatten
       end
 
       def clear_blocked_by!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0.pre1
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2015-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 1.0.0.pre1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 1.0.0.pre1
 description: |
   These features are under active development and may change frequently. They are expected not to
   keep backward compatibility (there may also lack tests and documentation). Semantic versions will
@@ -100,9 +100,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.8