concurrent-ruby 0.9.0.pre2 → 0.9.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e100cda902e2d18d80d34e38ec541d11bde399a
-  data.tar.gz: a56ad16d5a76aa677befbdf3ad2f7b47b0cc1fcb
+  metadata.gz: f405da05002f7882b78a16748dba3c9a3439bb8f
+  data.tar.gz: be024ee9c4ecc15d86840b3599158d2312273459
 SHA512:
-  metadata.gz: 066dcc901e922bb751c79acf6249b693984cda1674adf40efc7dbdd782ca22ff8f313dd4674d282b9b22721522ab03aa481c93399fc94017cc8d90a4c17e2acf
-  data.tar.gz: 36d5fe13bebec7e07b3639c65deb455d0bbcb091a11678c05c8664213573179117517d3f2f097d6413a9f71fc09e1193b8ec189ccaa6d1c422779994638015cd
+  metadata.gz: a1c334847abed2ba6b9b3dbd290b4aa137ccdad02dd1f11aaa4b5fff6ce64cf37ce197ff2dc6ec5ad580053cf65ce38df7334e69ca54dd26f53dfa782654dacb
+  data.tar.gz: ab7cd113db8ee277fa8fda122cdc6efc74e2c245f4614016e2e3c4fcbd6f4c1ca55dd65adb42fa9cec0d08752971774579af3ffc4758054be12b3e0022a63638

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ### Next Release v0.9.0 (Target Date: 7 June 2015)
 
+
+* Updated `AtomicReference`
+  - `AtomicReference#try_update` now simply returns instead of raising exception
+  - `AtomicReference#try_update!` was added to raise exceptions if an update
+    fails. Note: this is the same behavior as the old `try_update`
 * Pure Java implementations of
   - `AtomicBoolean`
   - `AtomicFixnum`
@@ -58,7 +63,7 @@
   - `Channel`
   - `Exchanger`
   - `LazyRegister`
-  - **new Future Framework** <http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge.html> - unified 
+  - **new Future Framework** <http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge.html> - unified
     implementation of Futures and Promises which combines Features of previous `Future`,
     `Promise`, `IVar`, `Event`, `Probe`, `dataflow`, `Delay`, `TimerTask` into single framework. It uses extensively
     new synchronization layer to make all the paths **lock-free** with exception of blocking threads on `#wait`.
@@ -80,7 +85,7 @@
   - Add AbstractContext#default_executor to be able to override executor class wide
   - Add basic IO example
   - Documentation somewhat improved
-  - All messages should have same priority. It's now possible to send `actor << job1 << job2 << :terminate!` and 
+  - All messages should have same priority. It's now possible to send `actor << job1 << job2 << :terminate!` and
     be sure that both jobs are processed first.
 * Refactored `Channel` to use newer synchronization objects
 * Added `#reset` and `#cancel` methods to `TimerSet`
@@ -162,7 +167,7 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
   - `SerializedExecutionDelegator` for serializing *any* executor
 * Updated `Async` with serialized execution
 * Updated `ImmediateExecutor` and `PerThreadExecutor` with full executor service lifecycle
-* Added a `Delay` to root `Actress` initialization 
+* Added a `Delay` to root `Actress` initialization
 * Minor bug fixes to thread pools
 * Refactored many intermittently failing specs
 * Removed Java interop warning `executor.rb:148 warning: ambiguous Java methods found, using submit(java.lang.Runnable)`

data/lib/concurrent.rb

@@ -49,6 +49,62 @@ require 'concurrent/tvar'
 #
 #   @see http://linux.die.net/man/3/clock_gettime Linux clock_gettime(3)
 
+# @!macro [new] copy_options
+#
+#   ## Copy Options
+#
+#   Object references in Ruby are mutable. This can lead to serious
+#   problems when the {#value} of an object is a mutable reference. Which
+#   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
+#   "primative" data type. Each instance can be configured with a few
+#   options that can help protect the program from potentially dangerous
+#   operations. Each of these options can be optionally set when the oject
+#   instance is created:
+#
+#   * `:dup_on_deref` When true the object will call the `#dup` method on
+#     the `value` object every time the `#value` methid is called
+#     (default: false)
+#   * `:freeze_on_deref` When true the object will call the `#freeze`
+#     method on the `value` object every time the `#value` method is called
+#     (default: false)
+#   * `:copy_on_deref` When given a `Proc` object the `Proc` will be run
+#     every time   the `#value` method is called. The `Proc` will be given
+#     the current `value` as its only argument and the result returned by
+#     the block will be the return   value of the `#value` call. When `nil`
+#     this option will be ignored (default: nil)
+#
+#   When multiple deref options are set the order of operations is strictly defined.
+#   The order of deref operations is:
+#   * `:copy_on_deref`
+#   * `:dup_on_deref`
+#   * `:freeze_on_deref`
+#
+#   Because of this ordering there is no need to `#freeze` an object created by a
+#   provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
+#   Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
+#   as close to the behavior of a "pure" functional language (like Erlang, Clojure,
+#   or Haskell) as we are likely to get in Ruby.
+
+# @!macro [attach] deref_options
+#
+#   @option opts [Boolean] :dup_on_deref (false) Call `#dup` before
+#     returning the data from {#value}
+#   @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before
+#     returning the data from {#value}
+#   @option opts [Proc] :copy_on_deref (nil) When calling the {#value}
+#     method, call the given proc passing the internal value as the sole
+#     argument then return the new value returned from the proc.
+
+# @!macro [attach] executor_and_deref_options
+#
+#   @param [Hash] opts the options used to define the behavior at update and deref
+#     and to specify the executor on which to perform actions
+#   @option opts [Executor] :executor when set use the given `Executor` instance.
+#     Three special values are also supported: `:task` returns the global task pool,
+#     `:operation` returns the global operation pool, and `:immediate` returns a new
+#     `ImmediateExecutor` object.
+#   @!macro deref_options
+
 # Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
 # F#, C#, Java, and classic concurrency patterns.
 #

data/lib/concurrent/async.rb

@@ -5,6 +5,7 @@ require 'concurrent/errors'
 require 'concurrent/ivar'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/serialized_execution'
+require 'concurrent/concern/deprecation'
 
 module Concurrent
 
@@ -30,23 +31,12 @@ module Concurrent
   # object. The former method allows methods to be called asynchronously by posting
   # to the global thread pool. The latter allows a method to be called synchronously
   # on the current thread but does so safely with respect to any pending asynchronous
-  # method calls. Both methods return an `Obligation` which can be inspected for
+  # method calls. Both methods return an `IVar` which can be inspected for
   # the result of the method call. Calling a method with `async` will return a
-  # `:pending` `Obligation` whereas `await` will return a `:complete` `Obligation`.
+  # `:pending` `IVar` whereas `await` will return a `:complete` `IVar`.
   # 
   # Very loosely based on the `async` and `await` keywords in C#.
   # 
-  # ### An Important Note About Initialization
-  # 
-  # > This module depends on several internal stnchronization mechanisms that
-  # > must be initialized prior to calling any of the async/await/executor methods.
-  # > To ensure thread-safe initialization the class `new` method will be made
-  # > private when the `Concurrent::Async` module is included. A factory method
-  # > called `create` will be defined in its place. The `create`factory will
-  # > create a new object instance, passing all arguments to the constructor,
-  # > and will initialize all stnchronization mechanisms. This is the only way
-  # > thread-safe initialization can be guaranteed. 
-  # 
   # ### An Important Note About Thread Safe Guarantees
   # 
   # > Thread safe guarantees can only be made when asynchronous method calls
@@ -70,23 +60,19 @@ module Concurrent
   #       nil
   #     end
   #   end
-  #
-  #   horn = Echo.new #=> NoMethodError: private method `new' called for Echo:Class
   #   
-  #   horn = Echo.create
+  #   horn = Echo.new
   #   horn.echo('zero')      # synchronous, not thread-safe
   #   
   #   horn.async.echo('one') # asynchronous, non-blocking, thread-safe
   #   horn.await.echo('two') # synchronous, blocking, thread-safe
   #
-  # @see Concurrent::Concern::Obligation
   # @see Concurrent::IVar
   module Async
 
-    # @!method self.create(*args, &block)
+    # @!method self.new(*args, &block)
     #
-    #   The factory method used to create new instances of the asynchronous
-    #   class. Used instead of `new` to ensure proper initialization of the
+    #   Instanciate a new object and ensure proper initialization of the
     #   synchronization mechanisms.
     #
     #   @param [Array<Object>] args Zero or more arguments to be passed to the
@@ -129,21 +115,13 @@ module Concurrent
     # @!visibility private
     def self.included(base)
       base.singleton_class.send(:alias_method, :original_new, :new)
-      base.send(:private_class_method, :original_new)
       base.extend(ClassMethods)
       super(base)
     end
 
     # @!visibility private
     module ClassMethods
-
-      # @deprecated
       def new(*args, &block)
-        warn '[DEPRECATED] use the `create` method instead'
-        create(*args, &block)
-      end
-
-      def create(*args, &block)
         obj = original_new(*args, &block)
         obj.send(:init_synchronization)
         obj
@@ -280,7 +258,7 @@ module Concurrent
     # @!visibility private
     # @deprecated
     def init_mutex
-      warn '[DEPRECATED] use the `create` method instead'
+      deprecated 'mutex synchronization now happens automatically'
       init_synchronization
     rescue InitializationError
       # suppress

data/lib/concurrent/atom.rb

@@ -18,40 +18,7 @@ module Concurrent
   # new value to the result of running the given block if and only if that
   # value validates.
   #
-  # @!macro [attach] copy_options
-  #   ## Copy Options
-  #
-  #   Object references in Ruby are mutable. This can lead to serious
-  #   problems when the {#value} of an object is a mutable reference. Which
-  #   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
-  #   "primative" data type. Each instance can be configured with a few
-  #   options that can help protect the program from potentially dangerous
-  #   operations. Each of these options can be optionally set when the oject
-  #   instance is created: 
-  #
-  #   * `:dup_on_deref` When true the object will call the `#dup` method on
-  #     the `value` object every time the `#value` methid is called
-  #     (default: false)
-  #   * `:freeze_on_deref` When true the object will call the `#freeze`
-  #     method on the `value` object every time the `#value` method is called
-  #     (default: false)
-  #   * `:copy_on_deref` When given a `Proc` object the `Proc` will be run
-  #     every time   the `#value` method is called. The `Proc` will be given
-  #     the current `value` as its only argument and the result returned by
-  #     the block will be the return   value of the `#value` call. When `nil`
-  #     this option will be ignored (default: nil)
-  #  
-  #   When multiple deref options are set the order of operations is strictly defined.
-  #   The order of deref operations is:
-  #   * `:copy_on_deref`
-  #   * `:dup_on_deref`
-  #   * `:freeze_on_deref`
-  #  
-  #   Because of this ordering there is no need to `#freeze` an object created by a
-  #   provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
-  #   Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
-  #   as close to the behavior of a "pure" functional language (like Erlang, Clojure,
-  #   or Haskell) as we are likely to get in Ruby.
+  # @!macro copy_options
   #
   # @see http://clojure.org/atoms Clojure Atoms
   class Atom < Synchronization::Object
@@ -66,14 +33,7 @@ module Concurrent
     #   intended new value. The validator will return true if the new value
     #   is acceptable else return false (preferrably) or raise an exception.
     #
-    # @!macro [attach] deref_options
-    #   @option opts [Boolean] :dup_on_deref (false) Call `#dup` before
-    #     returning the data from {#value}
-    #   @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before
-    #     returning the data from {#value}
-    #   @option opts [Proc] :copy_on_deref (nil) When calling the {#value}
-    #     method, call the given proc passing the internal value as the sole
-    #     argument then return the new value returned from the proc.
+    # @!macro deref_options
     # 
     # @raise [ArgumentError] if the validator is not a `Proc` (when given)
     def initialize(value, opts = {})

data/lib/concurrent/atomic_reference/direct_update.rb

@@ -13,7 +13,7 @@ module Concurrent
     # Pass the current value to the given block, replacing it
     # with the block's result. May retry if the value changes
     # during the block's execution.
-    # 
+    #
     # @yield [Object] Calculate a new value for the atomic reference using
     #   given (old) value
     # @yieldparam [Object] old_value the starting value of the atomic reference
@@ -27,17 +27,45 @@ module Concurrent
     # @!macro [attach] atomic_reference_method_try_update
     #
     # Pass the current value to the given block, replacing it
+    # with the block's result. Return nil if the update fails.
+    #
+    # @yield [Object] Calculate a new value for the atomic reference using
+    #   given (old) value
+    # @yieldparam [Object] old_value the starting value of the atomic reference
+    #
+    # @note This method was altered to avoid raising an exception by default.
+    # Instead, this method now returns `nil` in case of failure. For more info,
+    # please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
+    #
+    # @return [Object] the new value, or nil if update failed
+    def try_update
+      old_value = get
+      new_value = yield old_value
+
+      return unless compare_and_set old_value, new_value
+
+      new_value
+    end
+
+    # @!macro [attach] atomic_reference_method_try_update!
+    #
+    # Pass the current value to the given block, replacing it
     # with the block's result. Raise an exception if the update
     # fails.
-    # 
+    #
     # @yield [Object] Calculate a new value for the atomic reference using
     #   given (old) value
     # @yieldparam [Object] old_value the starting value of the atomic reference
     #
+    # @note This behavior mimics the behavior of the original
+    # `AtomicReference#try_update` API. The reason this was changed was to
+    # avoid raising exceptions (which are inherently slow) by default. For more
+    # info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
+    #
     # @return [Object] the new value
     #
     # @raise [Concurrent::ConcurrentUpdateError] if the update fails
-    def try_update
+    def try_update!
       old_value = get
       new_value = yield old_value
       unless compare_and_set(old_value, new_value)

data/lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -42,14 +42,14 @@ module Concurrent
 
     # @!macro atomic_reference_method_compare_and_set
     def _compare_and_set(old_value, new_value)
-      return false unless @mutex.try_lock
-      begin
-        return false unless @value.equal? old_value
-        @value = new_value
-      ensure
-        @mutex.unlock
+      @mutex.synchronize do
+        if @value.equal? old_value
+          @value = new_value
+          true
+        else
+          false
+        end
       end
-      true
     end
   end
 end

data/lib/concurrent/configuration.rb

@@ -73,11 +73,10 @@ module Concurrent
     end
   end
 
-  # Disables AtExit hooks including pool auto-termination hooks.
-  # When disabled it will be the application
-  # programmer's responsibility to ensure that the hooks
-  # are shutdown properly prior to application exit
-  # by calling {AtExit.run} method.
+  # Disables AtExit handlers including pool auto-termination handlers.
+  # When disabled it will be the application programmer's responsibility
+  # to ensure that the handlers are shutdown properly prior to application
+  # exit by calling {AtExit.run} method.
   #
   # @note this option should be needed only because of `at_exit` ordering
   #   issues which may arise when running some of the testing frameworks.
@@ -88,13 +87,13 @@ module Concurrent
   #   from within a gem. It should *only* be used from within the main
   #   application and even then it should be used only when necessary.
   # @see AtExit
-  def self.disable_at_exit_hooks!
+  def self.disable_at_exit_handlers!
     AtExit.enabled = false
   end
 
   def self.disable_executor_auto_termination!
-    deprecated_method 'disable_executor_auto_termination!', 'disable_at_exit_hooks!'
-    disable_at_exit_hooks!
+    deprecated_method 'disable_executor_auto_termination!', 'disable_at_exit_handlers!'
+    disable_at_exit_handlers!
   end
 
   # @return [true,false]
@@ -132,8 +131,6 @@ module Concurrent
   # Global thread pool user for global *timers*.
   #
   # @return [Concurrent::TimerSet] the thread pool
-  #
-  # @see Concurrent::timer
   def self.global_timer_set
     GLOBAL_TIMER_SET.value
   end
@@ -249,10 +246,10 @@ module Concurrent
       Concurrent.new_fast_executor
     end
 
-    # @deprecated Use Concurrent.disable_auto_termination_of_global_executors! instead
+    # @deprecated Use Concurrent.disable_executor_auto_termination! instead
     def auto_terminate=(value)
-      deprecated_method 'Concurrent.configuration.auto_terminate=', 'Concurrent.disable_auto_termination_of_global_executors!'
-      Concurrent.disable_auto_termination_of_global_executors! if !value
+      deprecated_method 'Concurrent.configuration.auto_terminate=', 'Concurrent.disable_executor_auto_termination!'
+      Concurrent.disable_executor_auto_termination! if !value
     end
 
     # @deprecated Use Concurrent.auto_terminate_global_executors? instead

data/lib/concurrent/edge.rb

@@ -21,10 +21,10 @@ module Concurrent
   #
   # @!macro [attach] edge_warning
   #   @api Edge
-  #   @note **Edge Feature:** Edge features are under active development and may
-  #     change frequently. They are not expected to keep backward compatibility.
-  #     They may also lack tests and documentation. Use with caution.
+  #   @note **Edge Feature:** Edge 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
+  #     be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move
+  #     to `concurrent-ruby` when final.
   module Edge
-
   end
 end

data/lib/concurrent/errors.rb

@@ -1,40 +1,42 @@
 module Concurrent
 
+  Error = Class.new(StandardError)
+
   # Raised when errors occur during configuration.
-  ConfigurationError = Class.new(StandardError)
+  ConfigurationError = Class.new(Error)
 
   # Raised when an asynchronous operation is cancelled before execution.
-  CancelledOperationError = Class.new(StandardError)
+  CancelledOperationError = Class.new(Error)
 
   # Raised when a lifecycle method (such as `stop`) is called in an improper
   # sequence or when the object is in an inappropriate state.
-  LifecycleError = Class.new(StandardError)
+  LifecycleError = Class.new(Error)
 
   # Raised when an attempt is made to violate an immutability guarantee.
-  ImmutabilityError = Class.new(StandardError)
+  ImmutabilityError = Class.new(Error)
 
   # Raised when an object's methods are called when it has not been
   # properly initialized.
-  InitializationError = Class.new(StandardError)
+  InitializationError = Class.new(Error)
 
   # Raised when an object with a start/stop lifecycle has been started an
   # excessive number of times. Often used in conjunction with a restart
   # policy or strategy.
-  MaxRestartFrequencyError = Class.new(StandardError)
+  MaxRestartFrequencyError = Class.new(Error)
 
   # Raised when an attempt is made to modify an immutable object
   # (such as an `IVar`) after its final state has been set.
-  MultipleAssignmentError = Class.new(StandardError)
+  MultipleAssignmentError = Class.new(Error)
 
   # Raised by an `Executor` when it is unable to process a given task,
   # possibly because of a reject policy or other internal error.
-  RejectedExecutionError = Class.new(StandardError)
+  RejectedExecutionError = Class.new(Error)
 
   # Raised when any finite resource, such as a lock counter, exceeds its
   # maximum limit/threshold.
-  ResourceLimitError = Class.new(StandardError)
+  ResourceLimitError = Class.new(Error)
 
   # Raised when an operation times out.
-  TimeoutError = Class.new(StandardError)
+  TimeoutError = Class.new(Error)
 
 end

data/lib/concurrent/executor/cached_thread_pool.rb

@@ -1,46 +1,32 @@
-require 'concurrent/executor/ruby_cached_thread_pool'
+require 'concurrent/utility/engine'
+require 'concurrent/executor/thread_pool_executor'
 
 module Concurrent
 
-  if Concurrent.on_jruby?
-    require 'concurrent/executor/java_cached_thread_pool'
-  end
-
-  CachedThreadPoolImplementation = case
-                                   when Concurrent.on_jruby?
-                                     JavaCachedThreadPool
-                                   else
-                                     RubyCachedThreadPool
-                                   end
-  private_constant :CachedThreadPoolImplementation
-
-  # @!macro [attach] cached_thread_pool
+  # A thread pool that dynamically grows and shrinks to fit the current workload.
+  # New threads are created as needed, existing threads are reused, and threads
+  # that remain idle for too long are killed and removed from the pool. These
+  # pools are particularly suited to applications that perform a high volume of
+  # short-lived tasks.
   #
-  #   A thread pool that dynamically grows and shrinks to fit the current workload.
-  #   New threads are created as needed, existing threads are reused, and threads
-  #   that remain idle for too long are killed and removed from the pool. These
-  #   pools are particularly suited to applications that perform a high volume of
-  #   short-lived tasks.
+  # On creation a `CachedThreadPool` has zero running threads. New threads are
+  # created on the pool as new operations are `#post`. The size of the pool
+  # will grow until `#max_length` threads are in the pool or until the number
+  # of threads exceeds the number of running and pending operations. When a new
+  # operation is post to the pool the first available idle thread will be tasked
+  # with the new operation.
   #
-  #   On creation a `CachedThreadPool` has zero running threads. New threads are
-  #   created on the pool as new operations are `#post`. The size of the pool
-  #   will grow until `#max_length` threads are in the pool or until the number
-  #   of threads exceeds the number of running and pending operations. When a new
-  #   operation is post to the pool the first available idle thread will be tasked
-  #   with the new operation.
+  # Should a thread crash for any reason the thread will immediately be removed
+  # from the pool. Similarly, threads which remain idle for an extended period
+  # of time will be killed and reclaimed. Thus these thread pools are very
+  # efficient at reclaiming unused resources.
   #
-  #   Should a thread crash for any reason the thread will immediately be removed
-  #   from the pool. Similarly, threads which remain idle for an extended period
-  #   of time will be killed and reclaimed. Thus these thread pools are very
-  #   efficient at reclaiming unused resources.
-  #
-  #   The API and behavior of this class are based on Java's `CachedThreadPool`
+  # The API and behavior of this class are based on Java's `CachedThreadPool`
   #
   # @!macro thread_pool_options
-  # @!macro thread_pool_executor_public_api
-  class CachedThreadPool < CachedThreadPoolImplementation
+  class CachedThreadPool < ThreadPoolExecutor
 
-    # @!macro [new] cached_thread_pool_method_initialize
+    # @!macro [attach] cached_thread_pool_method_initialize
     #
     #   Create a new thread pool.
     #
@@ -50,8 +36,27 @@ module Concurrent
     #   @raise [ArgumentError] if `fallback_policy` is not a known policy
     #
     #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool--
+    def initialize(opts = {})
+      defaults  = { idletime:    DEFAULT_THREAD_IDLETIMEOUT }
+      overrides = { min_threads: 0,
+                    max_threads: DEFAULT_MAX_POOL_SIZE,
+                    max_queue:   DEFAULT_MAX_QUEUE_SIZE }
+      super(defaults.merge(opts).merge(overrides))
+    end
+
+    private
 
-    # @!method initialize(opts = {})
-    #   @!macro cached_thread_pool_method_initialize
+    # @!macro cached_thread_pool_method_initialize
+    # @!visibility private
+    def ns_initialize(opts)
+      super(opts)
+      if Concurrent.on_jruby?
+        @max_queue = 0
+        @executor = java.util.concurrent.Executors.newCachedThreadPool
+        @executor.setRejectedExecutionHandler(FALLBACK_POLICY_CLASSES[@fallback_policy].new)
+        @executor.setKeepAliveTime(opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT), java.util.concurrent.TimeUnit::SECONDS)
+        self.auto_terminate = opts.fetch(:auto_terminate, true)
+      end
+    end
   end
 end

data/lib/concurrent/executor/fixed_thread_pool.rb

@@ -1,19 +1,8 @@
-require 'concurrent/executor/ruby_fixed_thread_pool'
+require 'concurrent/utility/engine'
+require 'concurrent/executor/thread_pool_executor'
 
 module Concurrent
 
-  if Concurrent.on_jruby?
-    require 'concurrent/executor/java_fixed_thread_pool'
-  end
-
-  FixedThreadPoolImplementation = case
-                                  when Concurrent.on_jruby?
-                                    JavaFixedThreadPool
-                                  else
-                                    RubyFixedThreadPool
-                                  end
-  private_constant :FixedThreadPoolImplementation
-
   # @!macro [new] thread_pool_executor_constant_default_max_pool_size
   #   Default maximum number of threads that will be created in the pool.
 
@@ -119,35 +108,7 @@ module Concurrent
 
 
 
-
-  # @!macro [new] fixed_thread_pool_method_initialize
-  #
-  #   Create a new thread pool.
-  #
-  #   @param [Integer] num_threads the number of threads to allocate
-  #   @param [Hash] opts the options defining pool behavior.
-  #   @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
-  #
-  #   @raise [ArgumentError] if `num_threads` is less than or equal to zero
-  #   @raise [ArgumentError] if `fallback_policy` is not a known policy
-  #
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
-
-
-
-
-
-  # @!macro [attach] fixed_thread_pool
-  #
-  #   A thread pool with a set number of threads. The number of threads in the pool
-  #   is set on construction and remains constant. When all threads are busy new
-  #   tasks `#post` to the thread pool are enqueued until a thread becomes available.
-  #   Should a thread crash for any reason the thread will immediately be removed
-  #   from the pool and replaced.
-  #
-  #   The API and behavior of this class are based on Java's `FixedThreadPool`
-  #
-  # @!macro [attach] thread_pool_options
+  # @!macro [new] thread_pool_options
   #
   #   **Thread Pool Options**
   #
@@ -203,11 +164,43 @@ module Concurrent
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html Java Executors class
   #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html Java ExecutorService interface
   #   @see http://ruby-doc.org//core-2.2.0/Kernel.html#method-i-at_exit Kernel#at_exit
-  #
-  # @!macro thread_pool_executor_public_api
-  class FixedThreadPool < FixedThreadPoolImplementation
 
-    # @!method initialize(num_threads, opts = {})
-    #   @!macro fixed_thread_pool_method_initialize
+
+
+
+
+  # @!macro [attach] fixed_thread_pool
+  #
+  #   A thread pool with a set number of threads. The number of threads in the pool
+  #   is set on construction and remains constant. When all threads are busy new
+  #   tasks `#post` to the thread pool are enqueued until a thread becomes available.
+  #   Should a thread crash for any reason the thread will immediately be removed
+  #   from the pool and replaced.
+  #
+  #   The API and behavior of this class are based on Java's `FixedThreadPool`
+  #
+  # @!macro thread_pool_options
+  class FixedThreadPool < ThreadPoolExecutor
+
+    # @!macro [attach] fixed_thread_pool_method_initialize
+    #
+    #   Create a new thread pool.
+    #
+    #   @param [Integer] num_threads the number of threads to allocate
+    #   @param [Hash] opts the options defining pool behavior.
+    #   @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
+    #
+    #   @raise [ArgumentError] if `num_threads` is less than or equal to zero
+    #   @raise [ArgumentError] if `fallback_policy` is not a known policy
+    #
+    #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
+    def initialize(num_threads, opts = {})
+      raise ArgumentError.new('number of threads must be greater than zero') if num_threads.to_i < 1
+      defaults  = { max_queue:   DEFAULT_MAX_QUEUE_SIZE,
+                    idletime:    DEFAULT_THREAD_IDLETIMEOUT }
+      overrides = { min_threads: num_threads,
+                    max_threads: num_threads }
+      super(defaults.merge(opts).merge(overrides))
+    end
   end
 end

data/lib/concurrent/executor/thread_pool_executor.rb

@@ -1,3 +1,4 @@
+require 'concurrent/utility/engine'
 require 'concurrent/executor/ruby_thread_pool_executor'
 
 module Concurrent

data/lib/concurrent/ivar.rb

@@ -34,7 +34,7 @@ module Concurrent
   # ```ruby
   # ivar = Concurrent::IVar.new
   # ivar.set 14
-  # ivar.get #=> 14
+  # ivar.value #=> 14
   # ivar.set 2 # would now be an error
   # ```
   #

data/lib/concurrent/timer_task.rb

@@ -297,13 +297,14 @@ module Concurrent
 
     # @!visibility private
     def schedule_next_task(interval = execution_interval)
-      Concurrent::timer(interval, Concurrent::Event.new, &method(:execute_task))
+      ScheduledTask.execute(interval, args: [Concurrent::Event.new], &method(:execute_task))
+      nil
     end
 
     # @!visibility private
     def execute_task(completion)
-      return unless @running.true?
-      Concurrent::timer(execution_interval, completion, &method(:timeout_task))
+      return nil unless @running.true?
+      ScheduledTask.execute(execution_interval, args: [completion], &method(:timeout_task))
       _success, value, reason = @executor.execute(self)
       if completion.try?
         self.value = value
@@ -313,6 +314,7 @@ module Concurrent
           [time, self.value, reason]
         end
       end
+      nil
     end
 
     # @!visibility private

data/lib/concurrent/version.rb

@@ -1,4 +1,4 @@
 module Concurrent
-  VERSION      = '0.9.0.pre2'
-  EDGE_VERSION = '0.1.0.pre2'
+  VERSION      = '0.9.0.pre3'
+  EDGE_VERSION = '0.1.0.pre3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.0.pre2
+  version: 0.9.0.pre3
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-08 00:00:00.000000000 Z
+date: 2015-06-22 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -69,12 +69,8 @@ files:
 - lib/concurrent/executor/fixed_thread_pool.rb
 - lib/concurrent/executor/immediate_executor.rb
 - lib/concurrent/executor/indirect_immediate_executor.rb
-- lib/concurrent/executor/java_cached_thread_pool.rb
-- lib/concurrent/executor/java_fixed_thread_pool.rb
 - lib/concurrent/executor/java_single_thread_executor.rb
 - lib/concurrent/executor/java_thread_pool_executor.rb
-- lib/concurrent/executor/ruby_cached_thread_pool.rb
-- lib/concurrent/executor/ruby_fixed_thread_pool.rb
 - lib/concurrent/executor/ruby_single_thread_executor.rb
 - lib/concurrent/executor/ruby_thread_pool_executor.rb
 - lib/concurrent/executor/safe_task_executor.rb
@@ -136,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,

data/lib/concurrent/executor/java_cached_thread_pool.rb

@@ -1,34 +0,0 @@
-if Concurrent.on_jruby?
-
-  require 'concurrent/executor/java_thread_pool_executor'
-
-  module Concurrent
-
-    # @!macro cached_thread_pool
-    # @!macro thread_pool_options
-    # @!macro thread_pool_executor_public_api
-    # @!visibility private
-    class JavaCachedThreadPool < JavaThreadPoolExecutor
-
-      # @!macro cached_thread_pool_method_initialize
-      def initialize(opts = {})
-        defaults  = { idletime: DEFAULT_THREAD_IDLETIMEOUT }
-        overrides = { min_threads:     0,
-                      max_threads:     DEFAULT_MAX_POOL_SIZE,
-                      max_queue:       0 }
-        super(defaults.merge(opts).merge(overrides))
-      end
-
-      protected
-
-      def ns_initialize(opts)
-        super(opts)
-        @max_queue = 0
-        @executor = java.util.concurrent.Executors.newCachedThreadPool
-        @executor.setRejectedExecutionHandler(FALLBACK_POLICY_CLASSES[@fallback_policy].new)
-        @executor.setKeepAliveTime(opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT), java.util.concurrent.TimeUnit::SECONDS)
-        self.auto_terminate = opts.fetch(:auto_terminate, true)
-      end
-    end
-  end
-end

data/lib/concurrent/executor/java_fixed_thread_pool.rb

@@ -1,24 +0,0 @@
-if Concurrent.on_jruby?
-
-  require 'concurrent/executor/java_thread_pool_executor'
-
-  module Concurrent
-
-    # @!macro fixed_thread_pool
-    # @!macro thread_pool_options
-    # @!macro thread_pool_executor_public_api
-    # @!visibility private
-    class JavaFixedThreadPool < JavaThreadPoolExecutor
-
-      # @!macro fixed_thread_pool_method_initialize
-      def initialize(num_threads, opts = {})
-        raise ArgumentError.new('number of threads must be greater than zero') if num_threads.to_i < 1
-        defaults  = { max_queue:   DEFAULT_MAX_QUEUE_SIZE,
-                      idletime:    DEFAULT_THREAD_IDLETIMEOUT }
-        overrides = { min_threads: num_threads,
-                      max_threads: num_threads }
-        super(defaults.merge(opts).merge(overrides))
-      end
-    end
-  end
-end

data/lib/concurrent/executor/ruby_cached_thread_pool.rb

@@ -1,20 +0,0 @@
-require 'concurrent/executor/ruby_thread_pool_executor'
-
-module Concurrent
-
-  # @!macro cached_thread_pool
-  # @!macro thread_pool_options
-  # @!macro thread_pool_executor_public_api
-  # @!visibility private
-  class RubyCachedThreadPool < RubyThreadPoolExecutor
-
-    # @!macro cached_thread_pool_method_initialize
-    def initialize(opts = {})
-      defaults  = { idletime: DEFAULT_THREAD_IDLETIMEOUT }
-      overrides = { min_threads:     0,
-                    max_threads:     DEFAULT_MAX_POOL_SIZE,
-                    max_queue:       DEFAULT_MAX_QUEUE_SIZE }
-      super(defaults.merge(opts).merge(overrides))
-    end
-  end
-end

data/lib/concurrent/executor/ruby_fixed_thread_pool.rb

@@ -1,21 +0,0 @@
-require 'concurrent/executor/ruby_thread_pool_executor'
-
-module Concurrent
-
-  # @!macro fixed_thread_pool
-  # @!macro thread_pool_options
-  # @!macro thread_pool_executor_public_api
-  # @!visibility private
-  class RubyFixedThreadPool < RubyThreadPoolExecutor
-
-    # @!macro fixed_thread_pool_method_initialize
-    def initialize(num_threads, opts = {})
-      raise ArgumentError.new('number of threads must be greater than zero') if num_threads.to_i < 1
-      defaults  = { max_queue:   DEFAULT_MAX_QUEUE_SIZE,
-                    idletime:    DEFAULT_THREAD_IDLETIMEOUT }
-      overrides = { min_threads: num_threads,
-                    max_threads: num_threads }
-      super(defaults.merge(opts).merge(overrides))
-    end
-  end
-end