concurrent-ruby 0.9.2-java → 1.0.0-java

data/lib/concurrent/executor/safe_task_executor.rb

@@ -6,26 +6,25 @@ module Concurrent
   # success - indicating if the callable has been executed without errors
   # value - filled by the callable result if it has been executed without errors, nil otherwise
   # reason - the error risen by the callable if it has been executed with errors, nil otherwise
-  class SafeTaskExecutor < Synchronization::Object
+  class SafeTaskExecutor < Synchronization::LockableObject
 
     def initialize(task, opts = {})
-      super()
-      @task = task
+      @task            = task
       @exception_class = opts.fetch(:rescue_exception, false) ? Exception : StandardError
-      ensure_ivar_visibility!
+      super() # ensures visibility
     end
 
     # @return [Array]
     def execute(*args)
       synchronize do
         success = false
-        value = reason = nil
+        value   = reason = nil
 
         begin
-          value = @task.call(*args)
+          value   = @task.call(*args)
           success = true
         rescue @exception_class => ex
-          reason = ex
+          reason  = ex
           success = false
         end
 

data/lib/concurrent/executor/serial_executor_service.rb

@@ -0,0 +1,34 @@
+require 'concurrent/executor/executor_service'
+
+module Concurrent
+
+  # Indicates that the including `ExecutorService` guarantees
+  # that all operations will occur in the order they are post and that no
+  # two operations may occur simultaneously. This module provides no
+  # functionality and provides no guarantees. That is the responsibility
+  # of the including class. This module exists solely to allow the including
+  # object to be interrogated for its serialization status.
+  #
+  # @example
+  #   class Foo
+  #     include Concurrent::SerialExecutor
+  #   end
+  #
+  #   foo = Foo.new
+  #
+  #   foo.is_a? Concurrent::ExecutorService #=> true
+  #   foo.is_a? Concurrent::SerialExecutor  #=> true
+  #   foo.serialized?                       #=> true
+  #
+  # @!visibility private
+  module SerialExecutorService
+    include ExecutorService
+
+    # @!macro executor_service_method_serialized_question
+    #
+    # @note Always returns `true`
+    def serialized?
+      true
+    end
+  end
+end

data/lib/concurrent/executor/serialized_execution.rb

@@ -1,12 +1,11 @@
-require 'delegate'
-require 'concurrent/executor/executor_service'
+require 'concurrent/errors'
 require 'concurrent/concern/logging'
 require 'concurrent/synchronization'
 
 module Concurrent
 
   # Ensures passed jobs in a serialized order never running at the same time.
-  class SerializedExecution < Synchronization::Object
+  class SerializedExecution < Synchronization::LockableObject
     include Concern::Logging
 
     def initialize()
@@ -40,8 +39,8 @@ module Concurrent
     # As {#post} but allows to submit multiple tasks at once, it's guaranteed that they will not
     # be interleaved by other tasks.
     #
-    # @param [Array<Array(Executor, Array<Object>, Proc)>] posts array of triplets where
-    #   first is a {Executor}, second is array of args for task, third is a task (Proc)
+    # @param [Array<Array(ExecutorService, Array<Object>, Proc)>] posts array of triplets where
+    #   first is a {ExecutorService}, second is array of args for task, third is a task (Proc)
     def posts(posts)
       # if can_overflow?
       #   raise ArgumentError, 'SerializedExecution does not support thread-pools which can overflow'
@@ -66,7 +65,7 @@ module Concurrent
       true
     end
 
-    protected
+    private
 
     def ns_initialize
       @being_executed = false
@@ -75,11 +74,11 @@ module Concurrent
 
     def call_job(job)
       did_it_run = begin
-        job.executor.post { work(job) }
-        true
-      rescue RejectedExecutionError => ex
-        false
-      end
+                     job.executor.post { work(job) }
+                     true
+                   rescue RejectedExecutionError => ex
+                     false
+                   end
 
       # TODO not the best idea to run it myself
       unless did_it_run
@@ -105,26 +104,4 @@ module Concurrent
       call_job job if job
     end
   end
-
-  # A wrapper/delegator for any `ExecutorService` that
-  # guarantees serialized execution of tasks.
-  #
-  # @see [SimpleDelegator](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/delegate/rdoc/SimpleDelegator.html)
-  # @see Concurrent::SerializedExecution
-  class SerializedExecutionDelegator < SimpleDelegator
-    include SerialExecutorService
-
-    def initialize(executor)
-      @executor   = executor
-      @serializer = SerializedExecution.new
-      super(executor)
-    end
-
-    # @!macro executor_service_method_post
-    def post(*args, &task)
-      Kernel.raise ArgumentError.new('no block given') unless block_given?
-      return false unless running?
-      @serializer.post(@executor, *args, &task)
-    end
-  end
 end

data/lib/concurrent/executor/serialized_execution_delegator.rb

@@ -0,0 +1,28 @@
+require 'delegate'
+require 'concurrent/executor/serial_executor_service'
+require 'concurrent/executor/serialized_execution'
+
+module Concurrent
+
+  # A wrapper/delegator for any `ExecutorService` that
+  # guarantees serialized execution of tasks.
+  #
+  # @see [SimpleDelegator](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/delegate/rdoc/SimpleDelegator.html)
+  # @see Concurrent::SerializedExecution
+  class SerializedExecutionDelegator < SimpleDelegator
+    include SerialExecutorService
+
+    def initialize(executor)
+      @executor   = executor
+      @serializer = SerializedExecution.new
+      super(executor)
+    end
+
+    # @!macro executor_service_method_post
+    def post(*args, &task)
+      raise ArgumentError.new('no block given') unless block_given?
+      return false unless running?
+      @serializer.post(@executor, *args, &task)
+    end
+  end
+end

data/lib/concurrent/executor/simple_executor_service.rb

@@ -89,7 +89,7 @@ module Concurrent
       @stopped.wait(timeout)
     end
 
-    protected
+    private
 
     def ns_initialize
       @running = Concurrent::AtomicBoolean.new(true)
@@ -97,13 +97,4 @@ module Concurrent
       @count = Concurrent::AtomicFixnum.new(0)
     end
   end
-
-  # @deprecated
-  class PerThreadExecutor < SimpleExecutorService
-
-    def initialize
-      deprecated 'use SimpleExecutorService instead'
-      super
-    end
-  end
 end

data/lib/concurrent/executor/single_thread_executor.rb

@@ -16,15 +16,22 @@ module Concurrent
 
   # @!macro [attach] single_thread_executor
   #
-  #   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.
+  #   A thread pool with a single thread an unlimited queue. Should the thread
+  #   die for any reason it will be removed and replaced, thus ensuring that
+  #   the executor will always remain viable and available to process jobs.
   #
-  #   The API and behavior of this class are based on Java's `SingleThreadExecutor`
+  #   A common pattern for background processing is to create a single thread
+  #   on which an infinite loop is run. The thread's loop blocks on an input
+  #   source (perhaps blocking I/O or a queue) and processes each input as it
+  #   is received. This pattern has several issues. The thread itself is highly
+  #   susceptible to errors during processing. Also, the thread itself must be
+  #   constantly monitored and restarted should it die. `SingleThreadExecutor`
+  #   encapsulates all these bahaviors. The task processor is highly resilient
+  #   to errors from within tasks. Also, should the thread die it will
+  #   automatically be restarted.
+  #
+  #   The API and behavior of this class are based on Java's `SingleThreadExecutor`.
   #
-  # @!macro thread_pool_options
   # @!macro abstract_executor_service_public_api
   class SingleThreadExecutor < SingleThreadExecutorImplementation
 
@@ -32,9 +39,12 @@ module Concurrent
     #
     #   Create a new thread pool.
     #
-    #   @option opts [Symbol] :fallback_policy (:discard) the policy for
-    #     handling new tasks that are received when the queue size has
-    #     reached `max_queue` or after the executor has shut down
+    #   @option opts [Symbol] :fallback_policy (:discard) the policy for handling new
+    #     tasks that are received when the queue size has reached
+    #     `max_queue` or the executor has shut down
+    #
+    #   @raise [ArgumentError] if `:fallback_policy` is not one of the values specified
+    #     in `FALLBACK_POLICIES`
     #
     #   @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html
     #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html

data/lib/concurrent/executor/timer_set.rb

@@ -1,12 +1,13 @@
 require 'concurrent/scheduled_task'
 require 'concurrent/atomic/event'
-require 'concurrent/collection/priority_queue'
-require 'concurrent/concern/deprecation'
+require 'concurrent/collection/non_concurrent_priority_queue'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/single_thread_executor'
 
 module Concurrent
 
+  autoload :Options, 'concurrent/options'
+
   # Executes a collection of tasks, each after a given delay. A master task
   # monitors the set and schedules each task for execution at the appropriate
   # time. Tasks are run on the global thread pool or on the supplied executor.
@@ -16,7 +17,6 @@ module Concurrent
   #
   # @!macro monotonic_clock_warning
   class TimerSet < RubyExecutorService
-    extend Concern::Deprecation
 
     # Create a new set of timed tasks.
     #
@@ -45,8 +45,6 @@ module Concurrent
     #
     # @raise [ArgumentError] if the intended execution time is not in the future.
     # @raise [ArgumentError] if no block is given.
-    #
-    # @!macro deprecated_scheduling_by_clock_time
     def post(delay, *args, &task)
       raise ArgumentError.new('no block given') unless block_given?
       return false unless running?
@@ -69,15 +67,15 @@ module Concurrent
 
     private :<<
 
-    protected
+    private
 
     # Initialize the object.
     #
     # @param [Hash] opts the options to create the object with.
     # @!visibility private
     def ns_initialize(opts)
-      @queue          = Collection::PriorityQueue.new(order: :min)
-      @task_executor  = Executor.executor_from_options(opts) || Concurrent.global_io_executor
+      @queue          = Collection::NonConcurrentPriorityQueue.new(order: :min)
+      @task_executor  = Options.executor_from_options(opts) || Concurrent.global_io_executor
       @timer_executor = SingleThreadExecutor.new
       @condition      = Event.new
       self.auto_terminate = opts.fetch(:auto_terminate, true)
@@ -119,10 +117,10 @@ module Concurrent
       synchronize{ @queue.delete(task) }
     end
 
-    # `ExecutorServic` callback called during shutdown.
+    # `ExecutorService` callback called during shutdown.
     #
     # @!visibility private
-    def shutdown_execution
+    def ns_shutdown_execution
       @queue.clear
       @timer_executor.kill
       stopped_event.set

data/lib/concurrent/executors.rb

@@ -1,10 +1,20 @@
+require 'concurrent/executor/abstract_executor_service'
 require 'concurrent/executor/cached_thread_pool'
+require 'concurrent/executor/executor_service'
 require 'concurrent/executor/fixed_thread_pool'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/indirect_immediate_executor'
+require 'concurrent/executor/java_executor_service'
+require 'concurrent/executor/java_single_thread_executor'
+require 'concurrent/executor/java_thread_pool_executor'
+require 'concurrent/executor/ruby_executor_service'
+require 'concurrent/executor/ruby_single_thread_executor'
+require 'concurrent/executor/ruby_thread_pool_executor'
+require 'concurrent/executor/cached_thread_pool'
 require 'concurrent/executor/safe_task_executor'
-require 'concurrent/executor/simple_executor_service'
+require 'concurrent/executor/serial_executor_service'
+require 'concurrent/executor/serialized_execution'
+require 'concurrent/executor/serialized_execution_delegator'
 require 'concurrent/executor/single_thread_executor'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
-require 'concurrent/executor/serialized_execution'

data/lib/concurrent/future.rb

@@ -1,11 +1,13 @@
 require 'thread'
+require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/ivar'
-require 'concurrent/executor/executor'
 require 'concurrent/executor/safe_task_executor'
 
 module Concurrent
 
+  autoload :Options, 'concurrent/options'
+
   # {include:file:doc/future.md}
   #
   # @!macro copy_options
@@ -27,7 +29,7 @@ module Concurrent
     # @raise [ArgumentError] if no block is given
     def initialize(opts = {}, &block)
       raise ArgumentError.new('no block given') unless block_given?
-      super(IVar::NO_VALUE, opts.merge(__task_from_block__: block), &nil)
+      super(NULL, opts.merge(__task_from_block__: block), &nil)
     end
 
     # Execute an `:unscheduled` `Future`. Immediately sets the state to `:pending` and
@@ -74,7 +76,7 @@ module Concurrent
     end
 
     # @!macro ivar_set_method
-    def set(value = IVar::NO_VALUE, &block)
+    def set(value = NULL, &block)
       check_for_block_or_value!(block_given?, value)
       synchronize do
         if @state != :unscheduled
@@ -129,7 +131,7 @@ module Concurrent
       super
       @state = :unscheduled
       @task = opts[:__task_from_block__]
-      @executor = Executor.executor_from_options(opts) || Concurrent.global_io_executor
+      @executor = Options.executor_from_options(opts) || Concurrent.global_io_executor
       @args = get_arguments_from(opts)
     end
   end

data/lib/concurrent/hash.rb

@@ -0,0 +1,35 @@
+require 'concurrent/utility/engine'
+require 'concurrent/thread_safe/util'
+
+module Concurrent
+  if Concurrent.on_cruby?
+
+    # @!macro [attach] concurrent_hash
+    #
+    #   A thread-safe subclass of Hash. This version locks against the object
+    #   itself for every method call, ensuring only one thread can be reading
+    #   or writing at a time. This includes iteration methods like `#each`.
+    #
+    #   @see http://ruby-doc.org/core-2.2.0/Hash.html Ruby standard library `Hash`
+    class Hash < ::Hash;
+    end
+
+  elsif Concurrent.on_jruby?
+    require 'jruby/synchronized'
+
+    # @!macro concurrent_hash
+    class Hash < ::Hash
+      include JRuby::Synchronized
+    end
+
+  elsif Concurrent.on_rbx?
+    require 'monitor'
+    require 'concurrent/thread_safe/util/array_hash_rbx'
+
+    # @!macro concurrent_hash
+    class Hash < ::Hash
+    end
+
+    ThreadSafe::Util.make_synchronized_on_rbx Hash
+  end
+end

data/lib/concurrent/immutable_struct.rb

@@ -9,6 +9,10 @@ module Concurrent
   module ImmutableStruct
     include Synchronization::AbstractStruct
 
+    def self.included(base)
+      base.safe_initialization!
+    end
+
     # @!macro struct_values
     def values
       ns_values
@@ -77,7 +81,7 @@ module Concurrent
       FACTORY.define_struct(clazz_name, args, &block)
     end
 
-    FACTORY = Class.new(Synchronization::Object) do
+    FACTORY = Class.new(Synchronization::LockableObject) do
       def define_struct(name, members, &block)
         synchronize do
           Synchronization::AbstractStruct.define_struct_class(ImmutableStruct, Synchronization::Object, name, members, &block)

data/lib/concurrent/ivar.rb

@@ -1,5 +1,4 @@
-require 'thread'
-
+require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/collection/copy_on_write_observer_set'
 require 'concurrent/concern/obligation'
@@ -45,13 +44,10 @@ module Concurrent
   #    In Proceedings of Workshop on Graph Reduction, 1986.
   # 2. For recent application:
   #    [DataDrivenFuture in Habanero Java from Rice](http://www.cs.rice.edu/~vs3/hjlib/doc/edu/rice/hj/api/HjDataDrivenFuture.html).
-  class IVar < Synchronization::Object
+  class IVar < Synchronization::LockableObject
     include Concern::Obligation
     include Concern::Observable
 
-    # @!visibility private
-    NO_VALUE = Object.new # :nodoc:
-
     # Create a new `IVar` in the `:pending` state with the (optional) initial value.
     #
     # @param [Object] value the initial value
@@ -62,8 +58,8 @@ module Concurrent
     #   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(value = NO_VALUE, opts = {}, &block)
-      if value != NO_VALUE && block_given?
+    def initialize(value = NULL, opts = {}, &block)
+      if value != NULL && block_given?
         raise ArgumentError.new('provide only a value or a block')
       end
       super(&nil)
@@ -104,16 +100,16 @@ module Concurrent
 
     # @!macro [attach] ivar_set_method
     #   Set the `IVar` to a value and wake or notify all threads waiting on it.
-    #  
+    #
     #   @!macro [attach] ivar_set_parameters_and_exceptions
     #     @param [Object] value the value to store in the `IVar`
     #     @yield A block operation to use for setting the value
     #     @raise [ArgumentError] if both a value and a block are given
     #     @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
     #       been set or otherwise completed
-    #  
+    #
     #   @return [IVar] self
-    def set(value = NO_VALUE)
+    def set(value = NULL)
       check_for_block_or_value!(block_given?, value)
       raise MultipleAssignmentError unless compare_and_set_state(:processing, :pending)
 
@@ -130,7 +126,7 @@ module Concurrent
 
     # @!macro [attach] ivar_fail_method
     #   Set the `IVar` to failed due to some error and wake or notify all threads waiting on it.
-    #  
+    #
     #   @param [Object] reason for the failure
     #   @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
     #     been set or otherwise completed
@@ -145,7 +141,7 @@ module Concurrent
     # @!macro ivar_set_parameters_and_exceptions
     #
     # @return [Boolean] true if the value was set else false
-    def try_set(value = NO_VALUE, &block)
+    def try_set(value = NULL, &block)
       set(value, &block)
       true
     rescue MultipleAssignmentError
@@ -157,11 +153,11 @@ module Concurrent
     # @!visibility private
     def ns_initialize(value, opts)
       value = yield if block_given?
-      init_obligation(self)
+      init_obligation
       self.observers = Collection::CopyOnWriteObserverSet.new
       set_deref_options(opts)
 
-      if value == NO_VALUE
+      if value == NULL
         @state = :pending
       else
         ns_complete_without_notification(true, value, nil)
@@ -204,7 +200,7 @@ module Concurrent
 
     # @!visibility private
     def check_for_block_or_value!(block_given, value) # :nodoc:
-      if (block_given && value != NO_VALUE) || (! block_given && value == NO_VALUE)
+      if (block_given && value != NULL) || (! block_given && value == NULL)
         raise ArgumentError.new('must set with either a value or a block')
       end
     end