Make synchronize private by default

can be made public if required in descendant

Author: pitr-ch

ext/com/concurrent_ruby/ext/SynchronizationLibrary.java

@@ -13,6 +13,7 @@
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.load.Library;
 import org.jruby.runtime.Block;
+import org.jruby.runtime.Visibility;
 import org.jruby.RubyBoolean;
 import org.jruby.RubyNil;
 import org.jruby.runtime.ThreadContext;
@@ -54,14 +55,14 @@ public IRubyObject initialize(ThreadContext context, IRubyObject[] args, Block b
             }
         }
 
-        @JRubyMethod(name = "synchronize")
+        @JRubyMethod(name = "synchronize", visibility = Visibility.PRIVATE)
         public IRubyObject rubySynchronize(ThreadContext context, Block block) {
             synchronized (this) {
                 return block.yield(context, null);
             }
         }
 
-        @JRubyMethod(name = "ns_wait", optional = 1, visibility = 'private')
+        @JRubyMethod(name = "ns_wait", optional = 1, visibility = Visibility.PRIVATE)
         public IRubyObject nsWait(ThreadContext context, IRubyObject[] args) {
             Ruby runtime = context.runtime;
             if (args.length > 1) {
@@ -93,13 +94,13 @@ public IRubyObject nsWait(ThreadContext context, IRubyObject[] args) {
             return this;
         }
 
-        @JRubyMethod(name = "ns_signal", visibility = 'private')
+        @JRubyMethod(name = "ns_signal", visibility = Visibility.PRIVATE)
         public IRubyObject nsSignal(ThreadContext context) {
             notify();
             return this;
         }
 
-        @JRubyMethod(name = "ns_broadcast", visibility = 'private')
+        @JRubyMethod(name = "ns_broadcast", visibility = Visibility.PRIVATE)
         public IRubyObject nsBroadcast(ThreadContext context) {
             notifyAll();
             return this;

lib/concurrent/delay.rb

@@ -79,6 +79,8 @@ def initialize(opts = {}, &block)
       @computing = false
     end
 
+    protected :synchronize
+
     # 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

lib/concurrent/ivar.rb

@@ -66,6 +66,8 @@ def initialize(value = NO_VALUE, opts = {})
       set(value) unless value == NO_VALUE
     end
 
+    protected :synchronize
+
     # Add an observer on this object that will receive notification on update.
     #
     # Upon completion the `IVar` will notify all observers in a thread-safe way.

lib/concurrent/synchronization/abstract_object.rb

@@ -34,14 +34,15 @@ def initialize(*args, &block)
         raise NotImplementedError
       end
 
+      private
+
       # @yield runs the block synchronized against this object,
-      #   equvivalent of java's `synchronize(this) {}`
+      #   equivalent of java's `synchronize(this) {}`
+      # @note can by made public in descendants if required by `public :synchronize`
       def synchronize
         raise NotImplementedError
       end
 
-      private
-
       # initialization of the object called inside synchronize block
       def ns_initialize(*args, &block)
       end

lib/concurrent/synchronization/java_pure_object.rb

@@ -9,12 +9,12 @@ def initialize(*args, &block)
           synchronize { ns_initialize(*args, &block) }
         end
 
+        private
+
         def synchronize
           JRuby.reference0(self).synchronized { yield }
         end
 
-        private
-
         def ns_wait(timeout = nil)
           success = JRuby.reference0(Thread.current).wait_timeout(JRuby.reference0(self), timeout)
           self

lib/concurrent/synchronization/monitor_object.rb

@@ -7,12 +7,12 @@ def initialize(*args, &block)
         synchronize { ns_initialize(*args, &block) }
       end
 
+      private
+
       def synchronize
         @__lock__do_not_use_directly.synchronize { yield }
       end
 
-      private
-
       def ns_wait(timeout = nil)
         @__condition__do_not_use_directly.wait timeout
         self

lib/concurrent/synchronization/mutex_object.rb

@@ -7,6 +7,8 @@ def initialize(*args, &block)
         synchronize { ns_initialize(*args, &block) }
       end
 
+      private
+
       def synchronize
         if @__lock__do_not_use_directly.owned?
           yield
@@ -15,8 +17,6 @@ def synchronize
         end
       end
 
-      private
-
       def ns_signal
         @__condition__do_not_use_directly.signal
         self

lib/concurrent/synchronization/rbx_object.rb

@@ -9,12 +9,12 @@ def initialize(*args, &block)
           end
         end
 
+        private
+
         def synchronize(&block)
           Rubinius.synchronize(self, &block)
         end
 
-        private
-
         def ns_wait(timeout = nil)
           wchan = Rubinius::Channel.new