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

data/lib/concurrent/synchronization.rb

@@ -0,0 +1,17 @@
+require 'concurrent/utility/engine'
+require 'concurrent/synchronization/abstract_object'
+require 'concurrent/synchronization/java_object'
+require 'concurrent/synchronization/mutex_object'
+require 'concurrent/synchronization/monitor_object'
+require 'concurrent/synchronization/rbx_object'
+require 'concurrent/synchronization/object'
+
+require 'concurrent/synchronization/condition'
+require 'concurrent/synchronization/lock'
+
+module Concurrent
+  # {include:file:doc/synchronization.md}
+  module Synchronization
+  end
+end
+

data/lib/concurrent/synchronization/abstract_object.rb

@@ -0,0 +1,163 @@
+module Concurrent
+  module Synchronization
+
+    # @!macro synchronization_object
+    # @!visibility private
+    class AbstractObject
+
+      # @!macro [attach] synchronization_object_method_initialize
+      #  
+      #   @abstract for helper ivar initialization if needed,
+      #     otherwise it can be left empty. It has to call ns_initialize.
+      def initialize(*args, &block)
+        raise NotImplementedError
+      end
+
+      protected
+
+      # @!macro [attach] synchronization_object_method_synchronize
+      #  
+      #   @yield runs the block synchronized against this object,
+      #     equivalent of java's `synchronize(this) {}`
+      #   @note can by made public in descendants if required by `public :synchronize`
+      def synchronize
+        raise NotImplementedError
+      end
+
+      # @!macro [attach] synchronization_object_method_ns_initialize
+      #  
+      #   initialization of the object called inside synchronize block
+      #   @note has to be called manually when required in children of this class
+      #   @example
+      #     class Child < Concurrent::Synchornization::Object
+      #       def initialize(*args, &block)
+      #         super(&nil)
+      #         synchronize { ns_initialize(*args, &block) }
+      #       end
+      #     
+      #       def ns_initialize(*args, &block)
+      #         @args = args          
+      #       end
+      #     end
+      def ns_initialize(*args, &block)
+      end
+
+      # @!macro [attach] synchronization_object_method_ns_wait_until
+      #  
+      #   Wait until condition is met or timeout passes,
+      #   protects against spurious wake-ups.
+      #   @param [Numeric, nil] timeout in seconds, `nil` means no timeout
+      #   @yield condition to be met
+      #   @yieldreturn [true, false]
+      #   @return [true, false] if condition met
+      #   @note only to be used inside synchronized block
+      #   @note to provide direct access to this method in a descendant add method
+      #     ```
+      #     def wait_until(timeout = nil, &condition)
+      #       synchronize { ns_wait_until(timeout, &condition) }
+      #     end
+      #     ```
+      def ns_wait_until(timeout = nil, &condition)
+        if timeout
+          wait_until = Concurrent.monotonic_time + timeout
+          loop do
+            now              = Concurrent.monotonic_time
+            condition_result = condition.call
+            # 0.001 correction to avoid error when `wait_until - now` is smaller than 0.0005 and rounded to 0
+            # when passed to java #wait(long timeout)
+            return condition_result if (now + 0.001) >= wait_until || condition_result
+            ns_wait wait_until - now
+          end
+        else
+          ns_wait timeout until condition.call
+          true
+        end
+      end
+
+      # @!macro [attach] synchronization_object_method_ns_wait
+      #  
+      #   Wait until another thread calls #signal or #broadcast,
+      #   spurious wake-ups can happen.
+      #  
+      #   @param [Numeric, nil] timeout in seconds, `nil` means no timeout
+      #   @return [self]
+      #   @note only to be used inside synchronized block
+      #   @note to provide direct access to this method in a descendant add method
+      #     ```
+      #     def wait(timeout = nil)
+      #       synchronize { ns_wait(timeout) }
+      #     end
+      #     ```
+      def ns_wait(timeout = nil)
+        raise NotImplementedError
+      end
+
+      # @!macro [attach] synchronization_object_method_ns_signal
+      #    
+      #   Signal one waiting thread.
+      #   @return [self]
+      #   @note only to be used inside synchronized block
+      #   @note to provide direct access to this method in a descendant add method
+      #     ```
+      #     def signal
+      #       synchronize { ns_signal }
+      #     end
+      #     ```
+      def ns_signal
+        raise NotImplementedError
+      end
+
+      # @!macro [attach] synchronization_object_method_ns_broadcast
+      #  
+      #   Broadcast to all waiting threads.
+      #   @return [self]
+      #   @note only to be used inside synchronized block
+      #   @note to provide direct access to this method in a descendant add method
+      #     ```
+      #     def broadcast
+      #       synchronize { ns_broadcast }
+      #     end
+      #     ```
+      def ns_broadcast
+        raise NotImplementedError
+      end
+
+      # @!macro [attach] synchronization_object_method_ensure_ivar_visibility
+      #  
+      #   Allows to construct immutable objects where all fields are visible after initialization, not requiring
+      #   further synchronization on access.
+      #   @example
+      #     class AClass
+      #       attr_reader :val
+      #       def initialize(val)
+      #         @val = val # final value, after assignment it's not changed (just convention, not enforced)
+      #         ensure_ivar_visibility!
+      #         # now it can be shared as Java's final field
+      #       end
+      #     end
+      def ensure_ivar_visibility!
+        raise NotImplementedError
+      end
+
+      # @!macro [attach] synchronization_object_method_self_attr_volatile
+      #    
+      #   creates methods for reading and writing to a instance variable with volatile (Java semantic) instance variable
+      #   return [Array<Symbol>] names of defined method names
+      def self.attr_volatile(*names)
+        names.each do |name|
+          ivar = :"@volatile_#{name}"
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              #{ivar}
+            end
+
+            def #{name}=(value)
+              #{ivar} = value
+            end
+          RUBY
+        end
+        names.map { |n| [n, :"#{n}="] }.flatten
+      end
+    end
+  end
+end

data/lib/concurrent/synchronization/abstract_struct.rb

@@ -0,0 +1,158 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    module AbstractStruct
+
+      # @!visibility private
+      def initialize(*values)
+        super()
+        ns_initialize(*values)
+        ensure_ivar_visibility!
+      end
+
+      # @!macro [attach] struct_length
+      #
+      #   Returns the number of struct members.
+      #
+      #   @return [Fixnum] the number of struct members
+      def length
+        self.class::MEMBERS.length
+      end
+      alias_method :size, :length
+
+      # @!macro [attach] struct_members
+      #
+      #   Returns the struct members as an array of symbols.
+      #
+      #   @return [Array] the struct members as an array of symbols
+      def members
+        self.class::MEMBERS.dup
+      end
+
+      protected
+
+      # @!macro struct_values
+      #
+      # @!visibility private
+      def ns_values
+        @values.dup
+      end
+
+      # @!macro struct_values_at
+      #
+      # @!visibility private
+      def ns_values_at(indexes)
+        @values.values_at(*indexes)
+      end
+
+      # @!macro struct_to_h
+      #
+      # @!visibility private
+      def ns_to_h
+        length.times.reduce({}){|memo, i| memo[self.class::MEMBERS[i]] = @values[i]; memo}
+      end
+
+      # @!macro struct_get
+      #
+      # @!visibility private
+      def ns_get(member)
+        if member.is_a? Integer
+          if member >= @values.length
+            raise IndexError.new("offset #{member} too large for struct(size:#{@values.length})")
+          end
+          @values[member]
+        else
+          send(member)
+        end
+      rescue NoMethodError
+        raise NameError.new("no member '#{member}' in struct")
+      end
+
+      # @!macro struct_equality
+      #
+      # @!visibility private
+      def ns_equality(other)
+        self.class == other.class && self.values == other.values
+      end
+
+      # @!macro struct_each
+      #
+      # @!visibility private
+      def ns_each
+        values.each{|value| yield value }
+      end
+
+      # @!macro struct_each_pair
+      #
+      # @!visibility private
+      def ns_each_pair
+        @values.length.times do |index|
+          yield self.class::MEMBERS[index], @values[index]
+        end
+      end
+
+      # @!macro struct_select
+      #
+      # @!visibility private
+      def ns_select
+        values.select{|value| yield value }
+      end
+
+      # @!macro struct_inspect
+      #
+      # @!visibility private
+      def ns_inspect
+        struct = pr_underscore(self.class.ancestors[1])
+        clazz = ((self.class.to_s =~ /^#<Class:/) == 0) ? '' : " #{self.class}"
+        "#<#{struct}#{clazz} #{ns_to_h}>"
+      end
+
+      # @!macro struct_merge
+      #
+      # @!visibility private
+      def ns_merge(other, &block)
+        self.class.new(*self.to_h.merge(other, &block).values)
+      end
+
+      # @!visibility private
+      def pr_underscore(clazz)
+        word = clazz.to_s
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      # @!visibility private
+      def self.define_struct_class(parent, base, name, members, &block)
+        clazz = Class.new(base || Object) do
+          include parent
+          self.const_set(:MEMBERS, members.collect{|member| member.to_s.to_sym}.freeze) 
+          def ns_initialize(*values)
+            raise ArgumentError.new('struct size differs') if values.length > length
+            @values = values.fill(nil, values.length..length-1)
+          end
+        end
+        unless name.nil?
+          begin
+            parent.const_set(name, clazz)
+            parent.const_get(name)
+          rescue NameError
+            raise NameError.new("identifier #{name} needs to be constant") 
+          end
+        end
+        members.each_with_index do |member, index|
+          clazz.send(:define_method, member) do
+            @values[index]
+          end
+        end
+        clazz.class_exec(&block) unless block.nil?
+        clazz
+      end
+    end
+  end
+end

data/lib/concurrent/synchronization/condition.rb

@@ -0,0 +1,53 @@
+module Concurrent
+  module Synchronization
+    class Condition < Object
+
+      singleton_class.send :alias_method, :private_new, :new
+      private_class_method :new
+
+      def initialize(lock)
+        @Lock = lock
+        ensure_ivar_visibility!
+        super()
+      end
+
+      def wait(timeout = nil)
+        @Lock.synchronize { ns_wait(timeout) }
+      end
+
+      def ns_wait(timeout = nil)
+        synchronize { super(timeout) }
+      end
+
+      def wait_until(timeout = nil, &condition)
+        @Lock.synchronize { ns_wait_until(timeout, &condition) }
+      end
+
+      def ns_wait_until(timeout = nil, &condition)
+        synchronize { super(timeout, &condition) }
+      end
+
+      def signal
+        @Lock.synchronize { ns_signal }
+      end
+
+      def ns_signal
+        synchronize { super }
+      end
+
+      def broadcast
+        @Lock.synchronize { ns_broadcast }
+      end
+
+      def ns_broadcast
+        synchronize { super }
+      end
+    end
+
+    class Object < Implementation
+      def new_condition
+        Condition.private_new(self)
+      end
+    end
+  end
+end

data/lib/concurrent/synchronization/java_object.rb

@@ -0,0 +1,34 @@
+require 'concurrent/utility/native_extension_loader' # load native part first
+
+module Concurrent
+  module Synchronization
+
+    if Concurrent.on_jruby?
+
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JavaObject < AbstractObject
+
+        def self.attr_volatile(*names)
+          names.each do |name|
+
+            ivar = :"@volatile_#{name}"
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                instance_variable_get_volatile(:#{ivar})
+              end
+
+              def #{name}=(value)
+                instance_variable_set_volatile(:#{ivar}, value)
+              end
+            RUBY
+
+          end
+          names.map { |n| [n, :"#{n}="] }.flatten
+        end
+
+      end
+    end
+  end
+end

data/lib/concurrent/synchronization/lock.rb

@@ -0,0 +1,32 @@
+module Concurrent
+  module Synchronization
+    class Lock < Object
+
+      public :synchronize
+
+      def wait(timeout = nil)
+        synchronize { ns_wait(timeout) }
+      end
+
+      public :ns_wait
+
+      def wait_until(timeout = nil, &condition)
+        synchronize { ns_wait_until(timeout, &condition) }
+      end
+
+      public :ns_wait_until
+
+      def signal
+        synchronize { ns_signal }
+      end
+
+      public :ns_signal
+      
+      def broadcast
+        synchronize { ns_broadcast }
+      end
+
+      public :ns_broadcast
+    end
+  end
+end