optimized some other class

Author: mighe

lib/concurrent/delay.rb

@@ -71,7 +71,17 @@ def initialize(opts = {}, &block)
     #
     # @see Concurrent::Dereferenceable
     def value
-      mutex.synchronize do
+      mutex.lock
+      execute_task_once
+      result = apply_deref_options(@value)
+      mutex.unlock
+
+      result
+    end
+
+    private
+
+      def execute_task_once
         if @state == :pending
           begin
             @value = @task.call
@@ -81,8 +91,6 @@ def value
             @state = :rejected
           end
         end
-        return apply_deref_options(@value)
       end
-    end
   end
 end

lib/concurrent/dereferenceable.rb

@@ -26,8 +26,12 @@ module Dereferenceable
     #
     # @return [Object] the current value of the object
     def value
-      mutex.synchronize{ apply_deref_options(@value) }
+      mutex.lock
+      result = apply_deref_options(@value)
+      mutex.unlock
+      result
     end
+
     alias_method :deref, :value
 
     protected
@@ -36,7 +40,10 @@ def value
     #
     # @param [Object] val the new value
     def value=(val)
-      mutex.synchronize{ @value = val }
+      mutex.lock
+      result = @value = val
+      mutex.unlock
+      result
     end
 
     # A mutex lock used for synchronizing thread-safe operations. Methods defined
@@ -71,12 +78,13 @@ def init_mutex
     # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
     #   returning the value returned from the proc
     def set_deref_options(opts = {})
-      mutex.synchronize do
-        @dup_on_deref = opts[:dup_on_deref] || opts[:dup]
-        @freeze_on_deref = opts[:freeze_on_deref] || opts[:freeze]
-        @copy_on_deref = opts[:copy_on_deref] || opts[:copy]
-        @do_nothing_on_deref = ! (@dup_on_deref || @freeze_on_deref || @copy_on_deref)
-      end
+      mutex.lock
+      @dup_on_deref = opts[:dup_on_deref] || opts[:dup]
+      @freeze_on_deref = opts[:freeze_on_deref] || opts[:freeze]
+      @copy_on_deref = opts[:copy_on_deref] || opts[:copy]
+      @do_nothing_on_deref = !(@dup_on_deref || @freeze_on_deref || @copy_on_deref)
+      mutex.unlock
+      nil
     end
 
     # @!visibility private

lib/concurrent/obligation.rb

@@ -48,11 +48,17 @@ def value(timeout = nil)
     end
 
     def state
-      mutex.synchronize { @state }
+      mutex.lock
+      result = @state
+      mutex.unlock
+      result
     end
 
     def reason
-      mutex.synchronize { @reason }
+      mutex.lock
+      result = @reason
+      mutex.unlock
+      result
     end
 
     protected

lib/concurrent/promise.rb

@@ -30,14 +30,14 @@ class Promise
     # @see http://wiki.commonjs.org/wiki/Promises/A
     # @see http://promises-aplus.github.io/promises-spec/
     def initialize(opts = {}, &block)
-      opts.delete_if {|k, v| v.nil?}
+      opts.delete_if { |k, v| v.nil? }
 
       @executor = OptionsParser::get_executor_from(opts)
       @parent = opts.fetch(:parent) { nil }
-      @on_fulfill = opts.fetch(:on_fulfill) { Proc.new{ |result| result } }
-      @on_reject = opts.fetch(:on_reject) { Proc.new{ |reason| raise reason } }
+      @on_fulfill = opts.fetch(:on_fulfill) { Proc.new { |result| result } }
+      @on_reject = opts.fetch(:on_reject) { Proc.new { |reason| raise reason } }
 
-      @promise_body = block || Proc.new{|result| result }
+      @promise_body = block || Proc.new { |result| result }
       @state = :unscheduled
       @children = []
 
@@ -46,13 +46,13 @@ def initialize(opts = {}, &block)
 
     # @return [Promise]
     def self.fulfill(value, opts = {})
-      Promise.new(opts).tap{ |p| p.send(:synchronized_set_state!, true, value, nil) }
+      Promise.new(opts).tap { |p| p.send(:synchronized_set_state!, true, value, nil) }
     end
 
 
     # @return [Promise]
     def self.reject(reason, opts = {})
-      Promise.new(opts).tap{ |p| p.send(:synchronized_set_state!, false, nil, reason) }
+      Promise.new(opts).tap { |p| p.send(:synchronized_set_state!, false, nil, reason) }
     end
 
     # @return [Promise]
@@ -77,7 +77,7 @@ def self.execute(opts = {}, &block)
     # @return [Promise] the new promise
     def then(rescuer = nil, &block)
       raise ArgumentError.new('rescuers and block are both missing') if rescuer.nil? && !block_given?
-      block = Proc.new{ |result| result } if block.nil?
+      block = Proc.new { |result| result } if block.nil?
       child = Promise.new(
         parent: self,
         executor: @executor,
@@ -105,6 +105,7 @@ def on_success(&block)
     def rescue(&block)
       self.then(block)
     end
+
     alias_method :catch, :rescue
     alias_method :on_error, :rescue
 
@@ -124,13 +125,13 @@ def root? # :nodoc:
 
     # @!visibility private
     def on_fulfill(result)
-      realize Proc.new{ @on_fulfill.call(result) }
+      realize Proc.new { @on_fulfill.call(result) }
       nil
     end
 
     # @!visibility private
     def on_reject(reason)
-      realize Proc.new{ @on_reject.call(reason) }
+      realize Proc.new { @on_reject.call(reason) }
       nil
     end
 
@@ -142,14 +143,14 @@ def notify_child(child)
     # @!visibility private
     def realize(task)
       @executor.post do
-        success, value, reason = SafeTaskExecutor.new( task ).execute
+        success, value, reason = SafeTaskExecutor.new(task).execute
 
         children_to_notify = mutex.synchronize do
           set_state!(success, value, reason)
           @children.dup
         end
 
-        children_to_notify.each{ |child| notify_child(child) }
+        children_to_notify.each { |child| notify_child(child) }
       end
     end
 
@@ -159,9 +160,9 @@ def set_state!(success, value, reason)
     end
 
     def synchronized_set_state!(success, value, reason)
-      mutex.synchronize do
-        set_state!(success, value, reason)
-      end
+      mutex.lock
+      set_state!(success, value, reason)
+      mutex.unlock
     end
   end
 end

lib/concurrent/timer_task.rb

@@ -247,7 +247,10 @@ def self.execute(opts = {}, &task)
     # @return [Fixnum] Number of seconds after the task completes before the
     #   task is performed again.
     def execution_interval
-      mutex.synchronize{ @execution_interval }
+      mutex.lock
+      result = @execution_interval
+      mutex.unlock
+      result
     end
 
     # @!attribute [rw] execution_interval
@@ -257,15 +260,21 @@ def execution_interval=(value)
       if (value = value.to_f) <= 0.0
         raise ArgumentError.new('must be greater than zero')
       else
-        mutex.synchronize{ @execution_interval = value }
+        mutex.lock
+        result = @execution_interval = value
+        mutex.unlock
+        result
       end
     end
 
     # @!attribute [rw] timeout_interval
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
     def timeout_interval
-      mutex.synchronize{ @timeout_interval }
+      mutex.lock
+      result = @timeout_interval
+      mutex.unlock
+      result
     end
 
     # @!attribute [rw] timeout_interval
@@ -275,7 +284,10 @@ def timeout_interval=(value)
       if (value = value.to_f) <= 0.0
         raise ArgumentError.new('must be greater than zero')
       else
-        mutex.synchronize{ @timeout_interval = value }
+        mutex.lock
+        result = @timeout_interval = value
+        mutex.unlock
+        result
       end
     end
 

spec/concurrent/dereferenceable_shared.rb

@@ -121,7 +121,8 @@
     subject = dereferenceable_subject(0)
     mutex = double('mutex')
     subject.stub(:mutex).and_return(mutex)
-    mutex.should_receive(:synchronize).at_least(:once)
+    mutex.should_receive(:lock).at_least(:once)
+    mutex.should_receive(:unlock).at_least(:once)
     subject.value
   end