concurrent-ruby 1.1.10 → 1.2.0

data/lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb

@@ -1,7 +1,8 @@
 require 'thread'
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/lock'
 
 module Concurrent
 

data/lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb

@@ -1,8 +1,10 @@
 require 'thread'
 require 'concurrent/atomic/atomic_reference'
+require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
-require 'concurrent/atomic/thread_local_var'
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/lock'
+require 'concurrent/atomic/lock_local_var'
 
 module Concurrent
 
@@ -109,7 +111,7 @@ module Concurrent
       @Counter    = AtomicFixnum.new(0)       # single integer which represents lock state
       @ReadQueue  = Synchronization::Lock.new # used to queue waiting readers
       @WriteQueue = Synchronization::Lock.new # used to queue waiting writers
-      @HeldCount  = ThreadLocalVar.new(0)     # indicates # of R & W locks held by this thread
+      @HeldCount  = LockLocalVar.new(0) # indicates # of R & W locks held by this thread
     end
 
     # Execute a block operation within a read lock.

data/lib/concurrent-ruby/concurrent/atomic/semaphore.rb

@@ -1,5 +1,4 @@
 require 'concurrent/atomic/mutex_semaphore'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -11,7 +10,7 @@ module Concurrent
   #
   #   @param [Fixnum] count the initial count
   #
-  #   @raise [ArgumentError] if `count` is not an integer or is less than zero
+  #   @raise [ArgumentError] if `count` is not an integer
 
   # @!macro semaphore_method_acquire
   #
@@ -21,8 +20,7 @@ module Concurrent
   #
   #   @param [Fixnum] permits Number of permits to acquire
   #
-  #   @raise [ArgumentError] if `permits` is not an integer or is less than
-  #     one
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than zero
   #
   #   @return [nil, BasicObject] Without a block, `nil` is returned. If a block
   #   is given, its return value is returned.
@@ -52,8 +50,7 @@ module Concurrent
   #   @param [Fixnum] timeout the number of seconds to wait for the counter
   #     or `nil` to return immediately
   #
-  #   @raise [ArgumentError] if `permits` is not an integer or is less than
-  #     one
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than zero
   #
   #   @return [true, false, nil, BasicObject] `false` if no permits are
   #     available, `true` when acquired a permit. If a block is given, the
@@ -66,7 +63,7 @@ module Concurrent
   #
   #   @param [Fixnum] permits Number of permits to return to the semaphore.
   #
-  #   @raise [ArgumentError] if `permits` is not a number or is less than one
+  #   @raise [ArgumentError] if `permits` is not a number or is less than zero
   #
   #   @return [nil]
 
@@ -96,8 +93,8 @@ module Concurrent
 
   # @!visibility private
   # @!macro internal_implementation_note
-  SemaphoreImplementation = case
-                            when defined?(JavaSemaphore)
+  SemaphoreImplementation = if Concurrent.on_jruby?
+                              require 'concurrent/utility/native_extension_loader'
                               JavaSemaphore
                             else
                               MutexSemaphore

data/lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb

@@ -1,104 +1,111 @@
-require 'concurrent/utility/engine'
-require 'concurrent/atomic/ruby_thread_local_var'
-require 'concurrent/atomic/java_thread_local_var'
+require 'concurrent/constants'
+require_relative 'locals'
 
 module Concurrent
 
-  ###################################################################
-
-  # @!macro thread_local_var_method_initialize
+  # A `ThreadLocalVar` is a variable where the value is different for each thread.
+  # Each variable may have a default value, but when you modify the variable only
+  # the current thread will ever see that change.
+  #
+  # This is similar to Ruby's built-in thread-local variables (`Thread#thread_variable_get`),
+  # but with these major advantages:
+  # * `ThreadLocalVar` has its own identity, it doesn't need a Symbol.
+  # * Each Ruby's built-in thread-local variable leaks some memory forever (it's a Symbol held forever on the thread),
+  #   so it's only OK to create a small amount of them.
+  #   `ThreadLocalVar` has no such issue and it is fine to create many of them.
+  # * Ruby's built-in thread-local variables leak forever the value set on each thread (unless set to nil explicitly).
+  #   `ThreadLocalVar` automatically removes the mapping for each thread once the `ThreadLocalVar` instance is GC'd.
+  #
+  # @!macro thread_safe_variable_comparison
+  #
+  # @example
+  #   v = ThreadLocalVar.new(14)
+  #   v.value #=> 14
+  #   v.value = 2
+  #   v.value #=> 2
+  #
+  # @example
+  #   v = ThreadLocalVar.new(14)
+  #
+  #   t1 = Thread.new do
+  #     v.value #=> 14
+  #     v.value = 1
+  #     v.value #=> 1
+  #   end
   #
-  #   Creates a thread local variable.
+  #   t2 = Thread.new do
+  #     v.value #=> 14
+  #     v.value = 2
+  #     v.value #=> 2
+  #   end
   #
-  #   @param [Object] default the default value when otherwise unset
-  #   @param [Proc] default_block Optional block that gets called to obtain the
-  #     default value for each thread
+  #   v.value #=> 14
+  class ThreadLocalVar
+    LOCALS = ThreadLocals.new
 
-  # @!macro thread_local_var_method_get
-  #
-  #   Returns the value in the current thread's copy of this thread-local variable.
-  #
-  #   @return [Object] the current value
+    # Creates a thread local variable.
+    #
+    # @param [Object] default the default value when otherwise unset
+    # @param [Proc] default_block Optional block that gets called to obtain the
+    #   default value for each thread
+    def initialize(default = nil, &default_block)
+      if default && block_given?
+        raise ArgumentError, "Cannot use both value and block as default value"
+      end
 
-  # @!macro thread_local_var_method_set
-  #
-  #   Sets the current thread's copy of this thread-local variable to the specified value.
-  #
-  #   @param [Object] value the value to set
-  #   @return [Object] the new value
+      if block_given?
+        @default_block = default_block
+        @default = nil
+      else
+        @default_block = nil
+        @default = default
+      end
 
-  # @!macro thread_local_var_method_bind
-  #
-  #   Bind the given value to thread local storage during
-  #   execution of the given block.
-  #
-  #   @param [Object] value the value to bind
-  #   @yield the operation to be performed with the bound variable
-  #   @return [Object] the value
+      @index = LOCALS.next_index(self)
+    end
 
+    # Returns the value in the current thread's copy of this thread-local variable.
+    #
+    # @return [Object] the current value
+    def value
+      LOCALS.fetch(@index) { default }
+    end
 
-  ###################################################################
+    # Sets the current thread's copy of this thread-local variable to the specified value.
+    #
+    # @param [Object] value the value to set
+    # @return [Object] the new value
+    def value=(value)
+      LOCALS.set(@index, value)
+    end
 
-  # @!macro thread_local_var_public_api
-  #
-  #   @!method initialize(default = nil, &default_block)
-  #     @!macro thread_local_var_method_initialize
-  #
-  #   @!method value
-  #     @!macro thread_local_var_method_get
-  #
-  #   @!method value=(value)
-  #     @!macro thread_local_var_method_set
-  #
-  #   @!method bind(value, &block)
-  #     @!macro thread_local_var_method_bind
+    # Bind the given value to thread local storage during
+    # execution of the given block.
+    #
+    # @param [Object] value the value to bind
+    # @yield the operation to be performed with the bound variable
+    # @return [Object] the value
+    def bind(value)
+      if block_given?
+        old_value = self.value
+        self.value = value
+        begin
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
+    end
 
-  ###################################################################
+    protected
 
-  # @!visibility private
-  # @!macro internal_implementation_note
-  ThreadLocalVarImplementation = case
-                                 when Concurrent.on_jruby?
-                                   JavaThreadLocalVar
-                                 else
-                                   RubyThreadLocalVar
-                                 end
-  private_constant :ThreadLocalVarImplementation
-
-  # @!macro thread_local_var
-  #
-  #   A `ThreadLocalVar` is a variable where the value is different for each thread.
-  #   Each variable may have a default value, but when you modify the variable only
-  #   the current thread will ever see that change.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   @example
-  #     v = ThreadLocalVar.new(14)
-  #     v.value #=> 14
-  #     v.value = 2
-  #     v.value #=> 2
-  #
-  #   @example
-  #     v = ThreadLocalVar.new(14)
-  #
-  #     t1 = Thread.new do
-  #       v.value #=> 14
-  #       v.value = 1
-  #       v.value #=> 1
-  #     end
-  #
-  #     t2 = Thread.new do
-  #       v.value #=> 14
-  #       v.value = 2
-  #       v.value #=> 2
-  #     end
-  #
-  #     v.value #=> 14
-  #
-  #   @see https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html Java ThreadLocal
-  #
-  # @!macro thread_local_var_public_api
-  class ThreadLocalVar < ThreadLocalVarImplementation
+    # @!visibility private
+    def default
+      if @default_block
+        self.value = @default_block.call
+      else
+        @default
+      end
+    end
   end
 end

data/lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb

@@ -0,0 +1,37 @@
+require 'concurrent/errors'
+
+module Concurrent
+
+  # Define update methods that use direct paths
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  module AtomicDirectUpdate
+    def update
+      true until compare_and_set(old_value = get, new_value = yield(old_value))
+      new_value
+    end
+
+    def try_update
+      old_value = get
+      new_value = yield old_value
+
+      return unless compare_and_set old_value, new_value
+
+      new_value
+    end
+
+    def try_update!
+      old_value = get
+      new_value = yield old_value
+      unless compare_and_set(old_value, new_value)
+        if $VERBOSE
+          raise ConcurrentUpdateError, "Update failed"
+        else
+          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
+        end
+      end
+      new_value
+    end
+  end
+end

data/lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb

@@ -1,8 +1,13 @@
+require 'concurrent/atomic_reference/atomic_direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+require 'concurrent/synchronization/safe_initialization'
+
 module Concurrent
 
   # @!visibility private
   # @!macro internal_implementation_note
-  class MutexAtomicReference < Synchronization::LockableObject
+  class MutexAtomicReference
+    extend Concurrent::Synchronization::SafeInitialization
     include AtomicDirectUpdate
     include AtomicNumericCompareAndSetWrapper
     alias_method :compare_and_swap, :compare_and_set
@@ -10,7 +15,8 @@ module Concurrent
     # @!macro atomic_reference_method_initialize
     def initialize(value = nil)
       super()
-      synchronize { ns_initialize(value) }
+      @Lock = ::Mutex.new
+      @value = value
     end
 
     # @!macro atomic_reference_method_get
@@ -49,8 +55,13 @@ module Concurrent
 
     protected
 
-    def ns_initialize(value)
-      @value = value
+    # @!visibility private
+    def synchronize
+      if @Lock.owned?
+        yield
+      else
+        @Lock.synchronize { yield }
+      end
     end
   end
 end

data/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
   module Collection

data/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
   module Collection

data/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb

@@ -1,3 +1,5 @@
+require 'concurrent/synchronization/object'
+
 module Concurrent
 
   # @!macro warn.edge

data/lib/concurrent-ruby/concurrent/concern/logging.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'concurrent/atomic/atomic_reference'
 
 module Concurrent
   module Concern
@@ -15,8 +16,6 @@ module Concurrent
       # @param [String, nil] message when nil block is used to generate the message
       # @yieldreturn [String] a message
       def log(level, progname, message = nil, &block)
-        #NOTE: Cannot require 'concurrent/configuration' above due to circular references.
-        #      Assume that the gem has been initialized if we've gotten this far.
         logger = if defined?(@logger) && @logger
                    @logger
                  else
@@ -30,3 +29,88 @@ module Concurrent
     end
   end
 end
+
+module Concurrent
+  extend Concern::Logging
+
+  # @return [Logger] Logger with provided level and output.
+  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
+    # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
+    lambda do |severity, progname, message = nil, &block|
+      return false if severity < level
+
+      message           = block ? block.call : message
+      formatted_message = case message
+                          when String
+                            message
+                          when Exception
+                            format "%s (%s)\n%s",
+                                   message.message, message.class, (message.backtrace || []).join("\n")
+                          else
+                            message.inspect
+                          end
+
+      output.print format "[%s] %5s -- %s: %s\n",
+                          Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
+                          Logger::SEV_LABEL[severity],
+                          progname,
+                          formatted_message
+      true
+    end
+  end
+
+  # Use logger created by #create_simple_logger to log concurrent-ruby messages.
+  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
+    Concurrent.global_logger = create_simple_logger level, output
+  end
+
+  # @return [Logger] Logger with provided level and output.
+  # @deprecated
+  def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
+    logger           = Logger.new(output)
+    logger.level     = level
+    logger.formatter = lambda do |severity, datetime, progname, msg|
+      formatted_message = case msg
+                          when String
+                            msg
+                          when Exception
+                            format "%s (%s)\n%s",
+                                   msg.message, msg.class, (msg.backtrace || []).join("\n")
+                          else
+                            msg.inspect
+                          end
+      format "[%s] %5s -- %s: %s\n",
+             datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
+             severity,
+             progname,
+             formatted_message
+    end
+
+    lambda do |loglevel, progname, message = nil, &block|
+      logger.add loglevel, message, progname, &block
+    end
+  end
+
+  # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
+  # @deprecated
+  def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
+    Concurrent.global_logger = create_stdlib_logger level, output
+  end
+
+  # TODO (pitr-ch 27-Dec-2016): remove deadlocking stdlib_logger methods
+
+  # Suppresses all output when used for logging.
+  NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
+
+  # @!visibility private
+  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
+  private_constant :GLOBAL_LOGGER
+
+  def self.global_logger
+    GLOBAL_LOGGER.value
+  end
+
+  def self.global_logger=(value)
+    GLOBAL_LOGGER.value = value
+  end
+end

data/lib/concurrent-ruby/concurrent/configuration.rb

@@ -1,102 +1,19 @@
 require 'thread'
 require 'concurrent/delay'
 require 'concurrent/errors'
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/concern/logging'
 require 'concurrent/concern/deprecation'
 require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/fixed_thread_pool'
 require 'concurrent/executor/cached_thread_pool'
 require 'concurrent/utility/processor_counter'
 
 module Concurrent
-  extend Concern::Logging
   extend Concern::Deprecation
 
   autoload :Options, 'concurrent/options'
   autoload :TimerSet, 'concurrent/executor/timer_set'
   autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
 
-  # @return [Logger] Logger with provided level and output.
-  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
-    # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
-    lambda do |severity, progname, message = nil, &block|
-      return false if severity < level
-
-      message           = block ? block.call : message
-      formatted_message = case message
-                          when String
-                            message
-                          when Exception
-                            format "%s (%s)\n%s",
-                                   message.message, message.class, (message.backtrace || []).join("\n")
-                          else
-                            message.inspect
-                          end
-
-      output.print format "[%s] %5s -- %s: %s\n",
-                          Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
-                          Logger::SEV_LABEL[severity],
-                          progname,
-                          formatted_message
-      true
-    end
-  end
-
-  # Use logger created by #create_simple_logger to log concurrent-ruby messages.
-  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
-    Concurrent.global_logger = create_simple_logger level, output
-  end
-
-  # @return [Logger] Logger with provided level and output.
-  # @deprecated
-  def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    logger           = Logger.new(output)
-    logger.level     = level
-    logger.formatter = lambda do |severity, datetime, progname, msg|
-      formatted_message = case msg
-                          when String
-                            msg
-                          when Exception
-                            format "%s (%s)\n%s",
-                                   msg.message, msg.class, (msg.backtrace || []).join("\n")
-                          else
-                            msg.inspect
-                          end
-      format "[%s] %5s -- %s: %s\n",
-             datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
-             severity,
-             progname,
-             formatted_message
-    end
-
-    lambda do |loglevel, progname, message = nil, &block|
-      logger.add loglevel, message, progname, &block
-    end
-  end
-
-  # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
-  # @deprecated
-  def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    Concurrent.global_logger = create_stdlib_logger level, output
-  end
-
-  # TODO (pitr-ch 27-Dec-2016): remove deadlocking stdlib_logger methods
-
-  # Suppresses all output when used for logging.
-  NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
-
-  # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
-  private_constant :GLOBAL_LOGGER
-
-  def self.global_logger
-    GLOBAL_LOGGER.value
-  end
-
-  def self.global_logger=(value)
-    GLOBAL_LOGGER.value = value
-  end
-
   # @!visibility private
   GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor }
   private_constant :GLOBAL_FAST_EXECUTOR
@@ -136,14 +53,14 @@ module Concurrent
   #
   # @return [ThreadPoolExecutor] the thread pool
   def self.global_fast_executor
-    GLOBAL_FAST_EXECUTOR.value
+    GLOBAL_FAST_EXECUTOR.value!
   end
 
   # Global thread pool optimized for long, blocking (IO) *tasks*.
   #
   # @return [ThreadPoolExecutor] the thread pool
   def self.global_io_executor
-    GLOBAL_IO_EXECUTOR.value
+    GLOBAL_IO_EXECUTOR.value!
   end
 
   def self.global_immediate_executor
@@ -154,7 +71,7 @@ module Concurrent
   #
   # @return [Concurrent::TimerSet] the thread pool
   def self.global_timer_set
-    GLOBAL_TIMER_SET.value
+    GLOBAL_TIMER_SET.value!
   end
 
   # General access point to global executors.

data/lib/concurrent-ruby/concurrent/delay.rb

@@ -1,7 +1,7 @@
 require 'thread'
 require 'concurrent/concern/obligation'
 require 'concurrent/executor/immediate_executor'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
@@ -67,7 +67,7 @@ module Concurrent
 
     # Return the value this object represents after applying the options
     # specified by the `#set_deref_options` method. If the delayed operation
-    # raised an exception this method will return nil. The execption object
+    # raised an exception this method will return nil. The exception object
     # can be accessed via the `#reason` method.
     #
     # @param [Numeric] timeout the maximum number of seconds to wait

data/lib/concurrent-ruby/concurrent/errors.rb

@@ -66,4 +66,9 @@ module Concurrent
     end
   end
 
+  # @!macro internal_implementation_note
+  class ConcurrentUpdateError < ThreadError
+    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
+    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
+  end
 end

data/lib/concurrent-ruby/concurrent/exchanger.rb

@@ -289,6 +289,7 @@ module Concurrent
   end
 
   if Concurrent.on_jruby?
+    require 'concurrent/utility/native_extension_loader'
 
     # @!macro internal_implementation_note
     # @!visibility private

data/lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb

@@ -1,7 +1,7 @@
 require 'concurrent/errors'
 require 'concurrent/concern/deprecation'
 require 'concurrent/executor/executor_service'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent