Removed DCL from LazyReference.

Author: jdantonio

lib/concurrent/lazy_reference.rb

@@ -10,11 +10,14 @@ module Concurrent
   #
   # Because of its simplicity `LazyReference` is much faster than `Delay`:
   #
-  #            user     system      total        real
-  #     Benchmarking Delay...
-  #        0.730000   0.000000   0.730000 (  0.738434)
-  #     Benchmarking LazyReference...
-  #        0.040000   0.000000   0.040000 (  0.042322)
+  #     Rehearsal -------------------------------------------------
+  #     Delay           0.200000   0.000000   0.200000 (  0.201775)
+  #     LazyReference   0.150000   0.000000   0.150000 (  0.151327)
+  #     ---------------------------------------- total: 0.350000sec
+  #   
+  #                         user     system      total        real
+  #     Delay           0.200000   0.000000   0.200000 (  0.201151)
+  #     LazyReference   0.150000   0.000000   0.150000 (  0.152647)
   #
   # @see Concurrent::Delay
   class LazyReference
@@ -35,16 +38,7 @@ def initialize(default = nil, &block)
       @fulfilled = false
     end
 
-    # The calculated value of the object or the default value if one
-    # was given at construction. This first time this method is called
-    # it will block indefinitely while the block is processed.
-    # Subsequent calls will not block.
-    #
-    # @return [Object] the calculated value
     def value
-      # double-checked locking is safe because we only update once
-      return @value if @fulfilled
-
       @mutex.synchronize do
         unless @fulfilled
           begin
@@ -55,8 +49,8 @@ def value
             @fulfilled = true
           end
         end
-        return @value
       end
+      return @value
     end
   end
 end

spec/concurrent/lazy_reference_spec.rb

@@ -31,20 +31,6 @@ module Concurrent
         5.times{ lazy.value }
       end
 
-      it 'does not lock the mutex once the block has been called' do
-        mutex = Mutex.new
-        allow(Mutex).to receive(:new).and_return(mutex)
-
-        lazy = LazyReference.new(&task)
-        lazy.value
-
-        expect(mutex).to_not receive(:synchronize).with(any_args)
-        expect(mutex).to_not receive(:lock).with(any_args)
-        expect(mutex).to_not receive(:try_lock).with(any_args)
-
-        5.times{ lazy.value }
-      end
-
       context 'on exception' do
 
         it 'suppresses the error' do
@@ -62,20 +48,6 @@ module Concurrent
           lazy = LazyReference.new(100){ raise StandardError }
           expect(lazy.value).to eq 100
         end
-
-        it 'does not try to call the block again' do
-          mutex = Mutex.new
-          allow(Mutex).to receive(:new).and_return(mutex)
-
-          lazy = LazyReference.new{ raise StandardError }
-          lazy.value
-
-          expect(mutex).to_not receive(:synchronize).with(any_args)
-          expect(mutex).to_not receive(:lock).with(any_args)
-          expect(mutex).to_not receive(:try_lock).with(any_args)
-
-          5.times{ lazy.value }
-        end
       end
     end
   end