concurrent-ruby 0.9.2-java → 1.0.0-java

data/lib/concurrent/atomic/reentrant_read_write_lock.rb

@@ -99,13 +99,15 @@ module Concurrent
     # @!visibility private
     WRITE_LOCK_MASK = MAX_WRITERS
 
+    safe_initialization!
+
     # Create a new `ReentrantReadWriteLock` in the unlocked state.
     def initialize
+      super()
       @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
-      ensure_ivar_visibility!
     end
 
     # Execute a block operation within a read lock.

data/lib/concurrent/atomic/ruby_thread_local_var.rb

@@ -0,0 +1,172 @@
+require 'thread'
+require 'concurrent/atomic/abstract_thread_local_var'
+
+module Concurrent
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class RubyThreadLocalVar < AbstractThreadLocalVar
+
+    # Each thread has a (lazily initialized) array of thread-local variable values
+    # Each time a new thread-local var is created, we allocate an "index" for it
+    # For example, if the allocated index is 1, that means slot #1 in EVERY
+    #   thread's thread-local array will be used for the value of that TLV
+    #
+    # The good thing about using a per-THREAD structure to hold values, rather
+    #   than a per-TLV structure, is that no synchronization is needed when
+    #    reading and writing those values (since the structure is only ever
+    #    accessed by a single thread)
+    #
+    # Of course, when a TLV is GC'd, 1) we need to recover its index for use
+    #   by other new TLVs (otherwise the thread-local arrays could get bigger
+    #   and bigger with time), and 2) we need to null out all the references
+    #   held in the now-unused slots (both to avoid blocking GC of those objects,
+    #   and also to prevent "stale" values from being passed on to a new TLV
+    #   when the index is reused)
+    # Because we need to null out freed slots, we need to keep references to
+    #   ALL the thread-local arrays -- ARRAYS is for that
+    # But when a Thread is GC'd, we need to drop the reference to its thread-local
+    #   array, so we don't leak memory
+
+    # @!visibility private
+    FREE = []
+    LOCK = Mutex.new
+    ARRAYS = {} # used as a hash set
+    @@next = 0
+    private_constant :FREE, :LOCK, :ARRAYS
+
+    # @!macro [attach] thread_local_var_method_initialize
+    #
+    #   Creates a thread local variable.
+    #
+    #   @param [Object] default the default value when otherwise unset
+    def initialize(default = nil)
+      @default = default
+      allocate_storage
+    end
+
+    # @!macro thread_local_var_method_get
+    def value
+      if array = get_threadlocal_array
+        value = array[@index]
+        if value.nil?
+          @default
+        elsif value.equal?(NULL)
+          nil
+        else
+          value
+        end
+      else
+        @default
+      end
+    end
+
+    # @!macro thread_local_var_method_set
+    def value=(value)
+      me = Thread.current
+      # We could keep the thread-local arrays in a hash, keyed by Thread
+      # But why? That would require locking
+      # Using Ruby's built-in thread-local storage is faster
+      unless array = get_threadlocal_array(me)
+        array = set_threadlocal_array([], me)
+        LOCK.synchronize { ARRAYS[array.object_id] = array }
+        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
+      end
+      array[@index] = (value.nil? ? NULL : value)
+      value
+    end
+
+    # @!macro thread_local_var_method_bind
+    def bind(value, &block)
+      if block_given?
+        old_value = self.value
+        begin
+          self.value = value
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
+    end
+
+    protected
+
+    # @!visibility private
+    def allocate_storage
+      @index = LOCK.synchronize do
+        FREE.pop || begin
+        result = @@next
+        @@next += 1
+        result
+        end
+      end
+      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
+    end
+
+    # @!visibility private
+    def self.threadlocal_finalizer(index)
+      proc do
+        LOCK.synchronize do
+          FREE.push(index)
+          # The cost of GC'ing a TLV is linear in the number of threads using TLVs
+          # But that is natural! More threads means more storage is used per TLV
+          # So naturally more CPU time is required to free more storage
+          ARRAYS.each_value do |array|
+            array[index] = nil
+          end
+        end
+      end
+    end
+
+    # @!visibility private
+    def self.thread_finalizer(array)
+      proc do
+        LOCK.synchronize do
+          # The thread which used this thread-local array is now gone
+          # So don't hold onto a reference to the array (thus blocking GC)
+          ARRAYS.delete(array.object_id)
+        end
+      end
+    end
+
+    private
+
+    if Thread.instance_methods.include?(:thread_variable_get)
+
+      def get_threadlocal_array(thread = Thread.current)
+        thread.thread_variable_get(:__threadlocal_array__)
+      end
+
+      def set_threadlocal_array(array, thread = Thread.current)
+        thread.thread_variable_set(:__threadlocal_array__, array)
+      end
+
+    else
+
+      def get_threadlocal_array(thread = Thread.current)
+        thread[:__threadlocal_array__]
+      end
+
+      def set_threadlocal_array(array, thread = Thread.current)
+        thread[:__threadlocal_array__] = array
+      end
+    end
+
+    # This exists only for use in testing
+    # @!visibility private
+    def value_for(thread)
+      if array = get_threadlocal_array(thread)
+        value = array[@index]
+        if value.nil?
+          @default
+        elsif value.equal?(NULL)
+          nil
+        else
+          value
+        end
+      else
+        @default
+      end
+    end
+  end
+end

data/lib/concurrent/atomic/semaphore.rb

@@ -1,207 +1,113 @@
+require 'concurrent/atomic/mutex_semaphore'
 require 'concurrent/synchronization'
 
 module Concurrent
 
-  # @!macro [attach] semaphore
+  ###################################################################
+
+  # @!macro [new] semaphore_method_initialize
   #
-  #   A counting semaphore. Conceptually, a semaphore maintains a set of
-  #   permits. Each {#acquire} blocks if necessary until a permit is
-  #   available, and then takes it. Each {#release} adds a permit, potentially
-  #   releasing a blocking acquirer.
-  #   However, no actual permit objects are used; the Semaphore just keeps a
-  #   count of the number available and acts accordingly.
+  #   Create a new `Semaphore` with the initial `count`.
   #
-  # @!visibility private
+  #   @param [Fixnum] count the initial count
   #
-  # @!macro internal_implementation_note
-  class MutexSemaphore < Synchronization::Object
-
-    # @!macro [attach] semaphore_method_initialize
-    #
-    #   Create a new `Semaphore` with the initial `count`.
-    #
-    #   @param [Fixnum] count the initial count
-    #
-    #   @raise [ArgumentError] if `count` is not an integer or is less than zero
-    def initialize(count)
-      unless count.is_a?(Fixnum) && count >= 0
-        fail ArgumentError, 'count must be an non-negative integer'
-      end
-      super()
-      synchronize { ns_initialize count }
-    end
-
-    # @!macro [attach] semaphore_method_acquire
-    #
-    #   Acquires the given number of permits from this semaphore,
-    #     blocking until all are available.
-    #
-    #   @param [Fixnum] permits Number of permits to acquire
-    #
-    #   @raise [ArgumentError] if `permits` is not an integer or is less than
-    #     one
-    #
-    #   @return [Nil]
-    def acquire(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
-      synchronize do
-        try_acquire_timed(permits, nil)
-        nil
-      end
-    end
-
-    # @!macro [attach] semaphore_method_available_permits
-    #
-    #   Returns the current number of permits available in this semaphore.
-    #
-    #   @return [Integer]
-    def available_permits
-      synchronize { @free }
-    end
-
-    # @!macro [attach] semaphore_method_drain_permits
-    #
-    #   Acquires and returns all permits that are immediately available.
-    #
-    #   @return [Integer]
-    def drain_permits
-      synchronize do
-        @free.tap { |_| @free = 0 }
-      end
-    end
+  #   @raise [ArgumentError] if `count` is not an integer or is less than zero
 
-    # @!macro [attach] semaphore_method_try_acquire
-    #
-    #   Acquires the given number of permits from this semaphore,
-    #     only if all are available at the time of invocation or within
-    #     `timeout` interval
-    #
-    #   @param [Fixnum] permits the number of permits to acquire
-    #
-    #   @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
-    #
-    #   @return [Boolean] `false` if no permits are available, `true` when
-    #     acquired a permit
-    def try_acquire(permits = 1, timeout = nil)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
-      synchronize do
-        if timeout.nil?
-          try_acquire_now(permits)
-        else
-          try_acquire_timed(permits, timeout)
-        end
-      end
-    end
+  # @!macro [new] semaphore_method_acquire
+  #
+  #   Acquires the given number of permits from this semaphore,
+  #     blocking until all are available.
+  #
+  #   @param [Fixnum] permits Number of permits to acquire
+  #
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than
+  #     one
+  #
+  #   @return [nil]
 
-    # @!macro [attach] semaphore_method_release
-    #
-    #   Releases the given number of permits, returning them to the semaphore.
-    #
-    #   @param [Fixnum] permits Number of permits to return to the semaphore.
-    #
-    #   @raise [ArgumentError] if `permits` is not a number or is less than one
-    #
-    #   @return [Nil]
-    def release(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
-      synchronize do
-        @free += permits
-        permits.times { ns_signal }
-      end
-      nil
-    end
+  # @!macro [new] semaphore_method_available_permits
+  #
+  #   Returns the current number of permits available in this semaphore.
+  #
+  #   @return [Integer]
 
-    # @!macro [attach] semaphore_method_reduce_permits
-    #
-    #   @api private
-    #
-    #   Shrinks the number of available permits by the indicated reduction.
-    #
-    #   @param [Fixnum] reduction Number of permits to remove.
-    #
-    #   @raise [ArgumentError] if `reduction` is not an integer or is negative
-    #
-    #   @raise [ArgumentError] if `@free` - `@reduction` is less than zero
-    #
-    #   @return [Nil]
-    def reduce_permits(reduction)
-      unless reduction.is_a?(Fixnum) && reduction >= 0
-        fail ArgumentError, 'reduction must be an non-negative integer'
-      end
-      synchronize { @free -= reduction }
-      nil
-    end
+  # @!macro [new] semaphore_method_drain_permits
+  #
+  #   Acquires and returns all permits that are immediately available.
+  #
+  #   @return [Integer]
 
-    protected
+  # @!macro [new] semaphore_method_try_acquire
+  #
+  #   Acquires the given number of permits from this semaphore,
+  #     only if all are available at the time of invocation or within
+  #     `timeout` interval
+  #
+  #   @param [Fixnum] permits the number of permits to acquire
+  #
+  #   @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
+  #
+  #   @return [Boolean] `false` if no permits are available, `true` when
+  #     acquired a permit
 
-    # @!visibility private
-    def ns_initialize(count)
-      @free = count
-    end
+  # @!macro [new] semaphore_method_release
+  #
+  #   Releases the given number of permits, returning them to the semaphore.
+  #
+  #   @param [Fixnum] permits Number of permits to return to the semaphore.
+  #
+  #   @raise [ArgumentError] if `permits` is not a number or is less than one
+  #
+  #   @return [nil]
 
-    private
+  ###################################################################
 
-    # @!visibility private
-    def try_acquire_now(permits)
-      if @free >= permits
-        @free -= permits
-        true
-      else
-        false
-      end
-    end
+  # @!macro [new] semaphore_public_api
+  #
+  #   @!method initialize(count)
+  #     @!macro semaphore_method_initialize
+  #
+  #   @!method acquire(permits = 1)
+  #     @!macro semaphore_method_acquire
+  #
+  #   @!method available_permits
+  #     @!macro semaphore_method_available_permits
+  #
+  #   @!method drain_permits
+  #     @!macro semaphore_method_drain_permits
+  #
+  #   @!method try_acquire(permits = 1, timeout = nil)
+  #     @!macro semaphore_method_try_acquire
+  #
+  #   @!method release(permits = 1)
+  #     @!macro semaphore_method_release
 
-    # @!visibility private
-    def try_acquire_timed(permits, timeout)
-      ns_wait_until(timeout) { try_acquire_now(permits) }
-    end
-  end
+  ###################################################################
 
   # @!visibility private
   # @!macro internal_implementation_note
   SemaphoreImplementation = case
-                            when Concurrent.on_jruby?
+                            when defined?(JavaSemaphore)
                               JavaSemaphore
                             else
                               MutexSemaphore
                             end
   private_constant :SemaphoreImplementation
 
-  # @!macro semaphore
+  # @!macro [attach] semaphore
   #
-  # @see Concurrent::MutexSemaphore
+  #   A counting semaphore. Conceptually, a semaphore maintains a set of
+  #   permits. Each {#acquire} blocks if necessary until a permit is
+  #   available, and then takes it. Each {#release} adds a permit, potentially
+  #   releasing a blocking acquirer.
+  #   However, no actual permit objects are used; the Semaphore just keeps a
+  #   count of the number available and acts accordingly.
+  #
+  # @!macro semaphore_public_api
   class Semaphore < SemaphoreImplementation
-
-    # @!method initialize(count)
-    #   @!macro semaphore_method_initialize
-
-    # @!method acquire(permits = 1)
-    #   @!macro semaphore_method_acquire
-
-    # @!method available_permits
-    #   @!macro semaphore_method_available_permits
-
-    # @!method drain_permits
-    #   @!macro semaphore_method_drain_permits
-
-    # @!method try_acquire(permits = 1, timeout = nil)
-    #   @!macro semaphore_method_try_acquire
-
-    # @!method release(permits = 1)
-    #   @!macro semaphore_method_release
-
-    # @!method reduce_permits(reduction)
-    #   @!macro semaphore_method_reduce_permits
-
   end
 end