concurrent-ruby 0.8.0.pre2-java → 0.9.0-java

data/lib/concurrent/atomic/semaphore.rb

@@ -1,7 +1,21 @@
-require 'concurrent/atomic/condition'
+require 'concurrent/synchronization'
 
 module Concurrent
-  class MutexSemaphore
+
+  # @!macro [attach] semaphore
+  #
+  #   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.
+  #
+  # @!visibility private
+  #
+  # @!macro internal_implementation_note
+  class MutexSemaphore < Synchronization::Object
+
     # @!macro [attach] semaphore_method_initialize
     #
     #   Create a new `Semaphore` with the initial `count`.
@@ -13,9 +27,8 @@ module Concurrent
       unless count.is_a?(Fixnum) && count >= 0
         fail ArgumentError, 'count must be an non-negative integer'
       end
-      @mutex = Mutex.new
-      @condition = Condition.new
-      @free = count
+      super()
+      synchronize { ns_initialize count }
     end
 
     # @!macro [attach] semaphore_method_acquire
@@ -33,7 +46,7 @@ module Concurrent
       unless permits.is_a?(Fixnum) && permits > 0
         fail ArgumentError, 'permits must be an integer greater than zero'
       end
-      @mutex.synchronize do
+      synchronize do
         try_acquire_timed(permits, nil)
         nil
       end
@@ -45,7 +58,7 @@ module Concurrent
     #
     #   @return [Integer]
     def available_permits
-      @mutex.synchronize { @free }
+      synchronize { @free }
     end
 
     # @!macro [attach] semaphore_method_drain_permits
@@ -54,7 +67,7 @@ module Concurrent
     #
     #   @return [Integer]
     def drain_permits
-      @mutex.synchronize do
+      synchronize do
         @free.tap { |_| @free = 0 }
       end
     end
@@ -79,7 +92,7 @@ module Concurrent
       unless permits.is_a?(Fixnum) && permits > 0
         fail ArgumentError, 'permits must be an integer greater than zero'
       end
-      @mutex.synchronize do
+      synchronize do
         if timeout.nil?
           try_acquire_now(permits)
         else
@@ -101,15 +114,15 @@ module Concurrent
       unless permits.is_a?(Fixnum) && permits > 0
         fail ArgumentError, 'permits must be an integer greater than zero'
       end
-      @mutex.synchronize do
+      synchronize do
         @free += permits
-        permits.times { @condition.signal }
+        permits.times { ns_signal }
       end
       nil
     end
 
     # @!macro [attach] semaphore_method_reduce_permits
-    # 
+    #
     #   @api private
     #
     #   Shrinks the number of available permits by the indicated reduction.
@@ -125,12 +138,20 @@ module Concurrent
       unless reduction.is_a?(Fixnum) && reduction >= 0
         fail ArgumentError, 'reduction must be an non-negative integer'
       end
-      @mutex.synchronize { @free -= reduction }
-      nil 
+      synchronize { @free -= reduction }
+      nil
+    end
+
+    protected
+
+    # @!visibility private
+    def ns_initialize(count)
+      @free = count
     end
 
     private
 
+    # @!visibility private
     def try_acquire_now(permits)
       if @free >= permits
         @free -= permits
@@ -140,93 +161,47 @@ module Concurrent
       end
     end
 
+    # @!visibility private
     def try_acquire_timed(permits, timeout)
-      remaining = Condition::Result.new(timeout)
-      while !try_acquire_now(permits) && remaining.can_wait?
-        @condition.signal
-        remaining = @condition.wait(@mutex, remaining.remaining_time)
-      end
-      remaining.can_wait? ? true : false
+      ns_wait_until(timeout) { try_acquire_now(permits) }
     end
   end
 
-  if RUBY_PLATFORM == 'java'
-
-    # @!macro semaphore
-    #     
-    #   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.
-    class JavaSemaphore
-      # @!macro semaphore_method_initialize
-      def initialize(count)
-        unless count.is_a?(Fixnum) && count >= 0
-          fail(ArgumentError,
-               'count must be in integer greater than or equal zero')
-        end
-        @semaphore = java.util.concurrent.Semaphore.new(count)
-      end
+  # @!visibility private
+  # @!macro internal_implementation_note
+  SemaphoreImplementation = case
+                            when Concurrent.on_jruby?
+                              JavaSemaphore
+                            else
+                              MutexSemaphore
+                            end
+  private_constant :SemaphoreImplementation
 
-      # @!macro semaphore_method_acquire
-      def acquire(permits = 1)
-        unless permits.is_a?(Fixnum) && permits > 0
-          fail ArgumentError, 'permits must be an integer greater than zero'
-        end
-        @semaphore.acquire(permits)
-      end
+  # @!macro semaphore
+  #
+  # @see Concurrent::MutexSemaphore
+  class Semaphore < SemaphoreImplementation
 
-      # @!macro semaphore_method_available_permits
-      def available_permits
-        @semaphore.availablePermits
-      end
+    # @!method initialize(count)
+    #   @!macro semaphore_method_initialize
 
-      # @!macro semaphore_method_drain_permits
-      def drain_permits
-        @semaphore.drainPermits
-      end
+    # @!method acquire(permits = 1)
+    #   @!macro semaphore_method_acquire
 
-      # @!macro semaphore_method_try_acquire
-      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
-        if timeout.nil?
-          @semaphore.tryAcquire(permits)
-        else
-          @semaphore.tryAcquire(permits,
-                                 timeout,
-                                 java.util.concurrent.TimeUnit::SECONDS)
-        end
-      end
+    # @!method available_permits
+    #   @!macro semaphore_method_available_permits
 
-      # @!macro semaphore_method_release
-      def release(permits = 1)
-        unless permits.is_a?(Fixnum) && permits > 0
-          fail ArgumentError, 'permits must be an integer greater than zero'
-        end
-        @semaphore.release(permits)
-        true
-      end
+    # @!method drain_permits
+    #   @!macro semaphore_method_drain_permits
 
-      # @!macro semaphore_method_reduce_permits
-      def reduce_permits(reduction)
-        unless reduction.is_a?(Fixnum) && reduction >= 0
-          fail ArgumentError, 'reduction must be an non-negative integer'
-        end
-        @semaphore.reducePermits(reduction)
-      end
-    end
+    # @!method try_acquire(permits = 1, timeout = nil)
+    #   @!macro semaphore_method_try_acquire
 
-    # @!macro semaphore
-    class Semaphore < JavaSemaphore
-    end
+    # @!method release(permits = 1)
+    #   @!macro semaphore_method_release
 
-  else
+    # @!method reduce_permits(reduction)
+    #   @!macro semaphore_method_reduce_permits
 
-    # @!macro semaphore
-    class Semaphore < MutexSemaphore
-    end
   end
 end

data/lib/concurrent/atomic/thread_local_var.rb

@@ -1,8 +1,9 @@
-require 'concurrent/atomic'
+require 'concurrent/atomic/thread_local_var/weak_key_map'
 
 module Concurrent
 
-  # @!macro [attach] abstract_thread_local_var
+  # @!macro [attach] 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.
@@ -29,64 +30,31 @@ module Concurrent
   #     end
   #   
   #     v.value #=> 14
+  #
+  #   @see https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html Java ThreadLocal
+  #
+  # @!visibility private
   class AbstractThreadLocalVar
 
-    module ThreadLocalRubyStorage
-
-      protected
-
-      unless RUBY_PLATFORM == 'java'
-        require 'ref'
-      end
-
-      def allocate_storage
-        @storage = Ref::WeakKeyMap.new
-      end
-
-      def get
-        @storage[Thread.current]
-      end
-
-      def set(value, &block)
-        key = Thread.current
-
-        @storage[key] = value
-
-        if block_given?
-          begin
-            block.call
-          ensure
-            @storage.delete key
-          end
-        end
-      end
-    end
-
-    module ThreadLocalJavaStorage
-
-      protected
-
-      def allocate_storage
-        @var = java.lang.ThreadLocal.new
-      end
-
-      def get
-        @var.get
-      end
-
-      def set(value)
-        @var.set(value)
-      end
-
-    end
-
+    # @!visibility private
     NIL_SENTINEL = Object.new
+    private_constant :NIL_SENTINEL
 
+    # @!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 [attach] thread_local_var_method_get
+    #
+    #   Returns the value in the current thread's copy of this thread-local variable.
+    #
+    #   @return [Object] the current value
     def value
       value = get
 
@@ -99,10 +67,24 @@ module Concurrent
       end
     end
 
+    # @!macro [attach] 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
     def value=(value)
       bind value
     end
 
+    # @!macro [attach] 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, &block)
       if value.nil?
         stored_value = NIL_SENTINEL
@@ -110,20 +92,110 @@ module Concurrent
         stored_value = value
       end
 
-      set stored_value, &block
+      set(stored_value, &block)
 
       value
     end
 
+    protected
+
+    # @!visibility private
+    def allocate_storage
+      raise NotImplementedError
+    end
+
+    # @!visibility private
+    def get
+      raise NotImplementedError
+    end
+
+    # @!visibility private
+    def set(value)
+      raise NotImplementedError
+    end
   end
 
-  # @!macro abstract_thread_local_var
-  class ThreadLocalVar < AbstractThreadLocalVar
-    if RUBY_PLATFORM == 'java'
-      include ThreadLocalJavaStorage
-    else
-      include ThreadLocalRubyStorage
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class RubyThreadLocalVar < AbstractThreadLocalVar
+
+    protected
+
+    # @!visibility private
+    def allocate_storage
+      @storage = WeakKeyMap.new
+    end
+
+    # @!visibility private
+    def get
+      @storage[Thread.current]
+    end
+
+    # @!visibility private
+    def set(value)
+      key = Thread.current
+
+      @storage[key] = value
+
+      if block_given?
+        begin
+          yield
+        ensure
+          @storage.delete(key)
+        end
+      end
     end
   end
 
+  if Concurrent.on_jruby?
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class JavaThreadLocalVar < AbstractThreadLocalVar
+
+      protected
+
+      # @!visibility private
+      def allocate_storage
+        @var = java.lang.ThreadLocal.new
+      end
+
+      # @!visibility private
+      def get
+        @var.get
+      end
+
+      # @!visibility private
+      def set(value)
+        @var.set(value)
+      end
+    end
+  end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  ThreadLocalVarImplementation = case
+                                 when Concurrent.on_jruby?
+                                   JavaThreadLocalVar
+                                 else
+                                   RubyThreadLocalVar
+                                 end
+  private_constant :ThreadLocalVarImplementation
+
+  # @!macro thread_local_var
+  class ThreadLocalVar < ThreadLocalVarImplementation
+
+    # @!method initialize(default = nil)
+    #   @!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
+
+  end
 end