Add ns_initialize which is always called inside synchronize block

Author: pitr-ch

ext/com/concurrent_ruby/ext/SynchronizationLibrary.java

@@ -47,9 +47,11 @@ public JavaObject(Ruby runtime, RubyClass metaClass) {
             super(runtime, metaClass);
         }
 
-        @JRubyMethod
-        public IRubyObject initialize(ThreadContext context) {
-            return context.nil;
+        @JRubyMethod(rest = true)
+        public IRubyObject initialize(ThreadContext context, IRubyObject[] args, Block block) {
+            synchronized (this) {
+                return callMethod(context, "ns_initialize", args, block);
+            }
         }
 
         @JRubyMethod(name = "synchronize")
@@ -59,7 +61,7 @@ public IRubyObject rubySynchronize(ThreadContext context, Block block) {
             }
         }
 
-        @JRubyMethod(name = "ns_wait", optional = 1)
+        @JRubyMethod(name = "ns_wait", optional = 1, visibility = 'private')
         public IRubyObject nsWait(ThreadContext context, IRubyObject[] args) {
             Ruby runtime = context.runtime;
             if (args.length > 1) {
@@ -91,13 +93,13 @@ public IRubyObject nsWait(ThreadContext context, IRubyObject[] args) {
             return this;
         }
 
-        @JRubyMethod(name = "ns_signal")
+        @JRubyMethod(name = "ns_signal", visibility = 'private')
         public IRubyObject nsSignal(ThreadContext context) {
             notify();
             return this;
         }
 
-        @JRubyMethod(name = "ns_broadcast")
+        @JRubyMethod(name = "ns_broadcast", visibility = 'private')
         public IRubyObject nsBroadcast(ThreadContext context) {
             notifyAll();
             return this;

lib/concurrent/actor/core.rb

@@ -47,7 +47,7 @@ class Core < Synchronization::Object
       #   any logging system
       # @param [Proc] block for class instantiation
       def initialize(opts = {}, &block)
-        super(&nil)
+        super(&nil) # TODO use ns_initialize
         synchronize do
           @mailbox              = Array.new
           @serialized_execution = SerializedExecution.new

lib/concurrent/at_exit.rb

@@ -8,14 +8,6 @@ module Concurrent
   class AtExitImplementation < Synchronization::Object
     include Logging
 
-    def initialize(enabled = true)
-      super()
-      synchronize do
-        @handlers = {}
-        @enabled  = enabled
-      end
-    end
-
     # Add a handler to be run at `Kernel#at_exit`
     # @param [Object] handler_id optionally provide an id, if allready present, handler is replaced
     # @yield the handler
@@ -80,6 +72,11 @@ def run
 
     private
 
+    def ns_initialize(enabled = true)
+      @handlers = {}
+      @enabled  = enabled
+    end
+
     def runner
       run if synchronize { @enabled }
     end

lib/concurrent/atomic/count_down_latch.rb

@@ -21,11 +21,10 @@ class PureCountDownLatch < Synchronization::Object
     #
     #   @raise [ArgumentError] if `count` is not an integer or is less than zero
     def initialize(count = 1)
-      super()
       unless count.is_a?(Fixnum) && count >= 0
         raise ArgumentError.new('count must be in integer greater than or equal zero')
       end
-      synchronize { @count = count }
+      super(count)
     end
 
     # @!macro [attach] count_down_latch_method_wait
@@ -58,6 +57,12 @@ def count_down
     def count
       synchronize { @count }
     end
+
+    private
+
+    def ns_initialize(count)
+      @count = count
+    end
   end
 
   if Concurrent.on_jruby?

lib/concurrent/atomic/cyclic_barrier.rb

@@ -15,15 +15,10 @@ class CyclicBarrier < Synchronization::Object
     #
     # @raise [ArgumentError] if `parties` is not an integer or is less than zero
     def initialize(parties, &block)
-      super(&nil)
       if !parties.is_a?(Fixnum) || parties < 1
         raise ArgumentError.new('count must be in integer greater than or equal zero')
       end
-      synchronize do
-        @parties = parties
-        @action  = block
-        ns_next_generation
-      end
+      super(parties, &block)
     end
 
     # @return [Fixnum] the number of threads needed to pass the barrier
@@ -101,6 +96,11 @@ def ns_next_generation
       @number_waiting = 0
     end
 
+    def ns_initialize(parties, &block)
+      @parties = parties
+      @action  = block
+      ns_next_generation
+    end
 
   end
 end

lib/concurrent/atomic/event.rb

@@ -19,10 +19,6 @@ class Event < Synchronization::Object
     # `Event` will block.
     def initialize
       super
-      synchronize do
-        @set       = false
-        @iteration = 0
-      end
     end
 
     # Is the object in the set state?
@@ -83,5 +79,10 @@ def ns_set
       end
       true
     end
+
+    def ns_initialize
+      @set       = false
+      @iteration = 0
+    end
   end
 end

lib/concurrent/edge/future.rb

@@ -33,8 +33,8 @@ def future(default_executor = :io, &task)
 
       alias_method :async, :future
 
-      # Constructs new Future which will be completed after block is evaluated on executor. Evaluation is delays until
-      # requested by {Future#wait} method, {Future#value} and {Future#value!} methods are calling {Future#wait} internally.
+      # Constructs new Future which will be completed after block is evaluated on executor. Evaluation is delayed until
+      # requested by `#wait`, `#value`, `#value!`, etc.
       # @return [Delay]
       def delay(default_executor = :io, &task)
         Delay.new(default_executor).event.chain(&task)
@@ -84,12 +84,6 @@ def post_on(executor, *args, &job)
     class Event < Synchronization::Object
       extend FutureShortcuts
 
-      # @api private
-      def initialize(promise, default_executor = :io)
-        super()
-        synchronize { ns_initialize(promise, default_executor) }
-      end
-
       # Is obligation completion still pending?
       # @return [Boolean]
       def pending?
@@ -624,12 +618,6 @@ def evaluate_to!(*args, &block)
 
     # @abstract
     class AbstractPromise < Synchronization::Object
-      # @api private
-      def initialize(*args, &block)
-        super(&nil)
-        synchronize { ns_initialize(*args, &block) }
-      end
-
       def default_executor
         future.default_executor
       end

lib/concurrent/executor/serialized_execution.rb

@@ -15,14 +15,6 @@ def call
       end
     end
 
-    def initialize
-      super(&nil)
-      synchronize do
-        @being_executed = false
-        @stash          = []
-      end
-    end
-
     # Submit a task to the executor for asynchronous processing.
     #
     # @param [Executor] executor to be used for this job
@@ -71,6 +63,11 @@ def posts(posts)
 
     private
 
+    def ns_initialize
+      @being_executed = false
+      @stash          = []
+    end
+
     def call_job(job)
       did_it_run = begin
         job.executor.post { work(job) }

lib/concurrent/synchronization.rb

@@ -7,22 +7,21 @@
 
 module Concurrent
   module Synchronization
-    class Object < case
-                           when Concurrent.on_jruby?
-                             JavaObject
+    Implementation = case
+                     when Concurrent.on_jruby?
+                       JavaObject
+                     when Concurrent.on_cruby? && (RUBY_VERSION.split('.').map(&:to_i) <=> [1, 9, 3]) <= 0
+                       MonitorObject
+                     when Concurrent.on_cruby?
+                       MutexObject
+                     when Concurrent.on_rbx?
+                       RbxObject
+                     else
+                       MutexObject
+                     end
+    private_constant :Implementation
 
-                           when Concurrent.on_cruby? && (RUBY_VERSION.split('.').map(&:to_i) <=> [1, 9, 3]) <= 0
-                             MonitorObject
-
-                           when Concurrent.on_cruby?
-                             MutexObject
-
-                           when Concurrent.on_rbx?
-                             RbxObject
-
-                           else
-                             MutexObject
-                           end
+    class Object < Implementation
     end
   end
 end

lib/concurrent/synchronization/abstract_object.rb

@@ -8,8 +8,8 @@ module Synchronization
     # the classes using it. Use {Synchronization::Object} not this abstract class.
     #
     # @note this object does not support usage together with
-    #   [Thread#wakeup](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-wakeup)
-    #   and [Thread#raise](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-raise).
+    #   [`Thread#wakeup`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-wakeup)
+    #   and [`Thread#raise`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-raise).
     #   `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `Synchronization::Object#wait` and
     #   `Thread#wakeup` will not work on all platforms.
     #
@@ -29,8 +29,8 @@ module Synchronization
     class AbstractObject
 
       # @abstract for helper ivar initialization if needed,
-      #     otherwise it can be left empty.
-      def initialize
+      #   otherwise it can be left empty. It has to call ns_initialize.
+      def initialize(*args, &block)
         raise NotImplementedError
       end
 
@@ -52,6 +52,10 @@ def wait(timeout = nil)
         self
       end
 
+      # initialization of the object called inside synchronize block
+      def ns_initialize(*args, &block)
+      end
+
       # Wait until condition is met or timeout passes,
       # protects against spurious wake-ups.
       # @param [Numeric, nil] timeout in seconds, `nil` means no timeout