concurrent-ruby 0.6.0.pre.1 → 0.6.0.pre.2

data/lib/concurrent/simple_actor_ref.rb

@@ -1,124 +0,0 @@
-require 'thread'
-
-require 'concurrent/actor_ref'
-require 'concurrent/event'
-require 'concurrent/ivar'
-
-module Concurrent
-
-  class SimpleActorRef
-    include ActorRef
-
-    def initialize(actor, opts = {})
-      @actor = actor
-      @mutex = Mutex.new
-      @queue = Queue.new
-      @thread = nil
-      @stop_event = Event.new
-      @abort_on_exception = opts.fetch(:abort_on_exception, true)
-      @reset_on_error = opts.fetch(:reset_on_error, true)
-      @exception_class = opts.fetch(:rescue_exception, false) ? Exception : StandardError
-      @observers = CopyOnNotifyObserverSet.new
-
-      @actor.define_singleton_method(:shutdown, &method(:set_stop_event))
-    end
-
-    def running?
-      ! @stop_event.set?
-    end
-
-    def shutdown?
-      @stop_event.set?
-    end
-
-    def post(*msg, &block)
-      raise ArgumentError.new('message cannot be empty') if msg.empty?
-      @mutex.synchronize do
-        supervise unless shutdown?
-      end
-      ivar = IVar.new
-      @queue.push(Message.new(msg, ivar, block))
-      ivar
-    end
-
-    def post!(seconds, *msg)
-      raise Concurrent::TimeoutError if seconds == 0
-      ivar = self.post(*msg)
-      ivar.value(seconds)
-      if ivar.incomplete?
-        raise Concurrent::TimeoutError
-      elsif ivar.reason
-        raise ivar.reason
-      end
-      ivar.value
-    end
-
-    def shutdown
-      @mutex.synchronize do
-        return if shutdown?
-        if @thread && @thread.alive?
-          @thread.kill 
-          @actor.on_shutdown
-        end
-        @stop_event.set
-      end
-    end
-
-    def join(timeout = nil)
-      @stop_event.wait(timeout)
-    end
-
-    private
-
-    Message = Struct.new(:payload, :ivar, :callback)
-
-    def set_stop_event
-      @stop_event.set
-    end
-
-    def supervise
-      if @thread.nil?
-        @actor.on_start
-        @thread = new_worker_thread
-      elsif ! @thread.alive?
-        @actor.on_reset
-        @thread = new_worker_thread
-      end
-    end
-
-    def new_worker_thread
-      Thread.new do
-        Thread.current.abort_on_exception = @abort_on_exception
-        run_message_loop
-      end
-    end
-
-    def run_message_loop
-      loop do
-        message = @queue.pop
-        result = ex = nil
-
-        begin
-          result = @actor.receive(*message.payload)
-        rescue @exception_class => ex
-          @actor.on_error(Time.now, message.payload, ex)
-          @actor.on_reset if @reset_on_error
-        ensure
-          now = Time.now
-          message.ivar.complete(ex.nil?, result, ex)
-
-          begin
-            message.callback.call(now, result, ex) if message.callback
-          rescue @exception_class => ex
-            # suppress
-          end
-
-          observers.notify_observers(now, message.payload, result, ex)
-        end
-
-        break if @stop_event.set?
-      end
-      @actor.on_shutdown
-    end
-  end
-end

data/lib/concurrent/thread_pool_executor.rb

@@ -1,30 +0,0 @@
-require 'concurrent/ruby_thread_pool_executor'
-
-module Concurrent
-
-  if RUBY_PLATFORM == 'java'
-    require 'concurrent/java_thread_pool_executor'
-    # @!macro [attach] thread_pool_executor
-    #
-    #   A thread pool...
-    #
-    #   The API and behavior of this class are based on Java's +ThreadPoolExecutor+
-    #
-    #   @note When running on the JVM (JRuby) this class will inherit from +JavaThreadPoolExecutor+.
-    #     On all other platforms it will inherit from +RubyThreadPoolExecutor+.
-    #
-    #   @see Concurrent::RubyThreadPoolExecutor
-    #   @see Concurrent::JavaThreadPoolExecutor
-    #
-    #   @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html
-    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html
-    #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html
-    #   @see http://stackoverflow.com/questions/17957382/fixedthreadpool-vs-fixedthreadpool-the-lesser-of-two-evils
-    class ThreadPoolExecutor < JavaThreadPoolExecutor
-    end
-  else
-    # @!macro thread_pool_executor
-    class ThreadPoolExecutor < RubyThreadPoolExecutor
-    end
-  end
-end

data/spec/concurrent/atomic_spec.rb

@@ -1,201 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe AtomicFixnum do
-
-    context 'construction' do
-
-      it 'sets the initial value' do
-        AtomicFixnum.new(10).value.should eq 10
-      end
-
-      it 'defaults the initial value to zero' do
-        AtomicFixnum.new.value.should eq 0
-      end
-
-      it 'raises en exception if the initial value is not a Fixnum' do
-        lambda {
-          AtomicFixnum.new(10.01)
-        }.should raise_error(ArgumentError)
-      end
-
-      if jruby?
-
-        it 'uses Java AtomicLong' do
-          mutex = double('mutex')
-          Mutex.stub(:new).with(no_args).and_return(mutex)
-          mutex.should_not_receive(:synchronize)
-          AtomicFixnum.new.value
-        end
-
-      else
-
-        it 'is synchronized' do
-          mutex = double('mutex')
-          Mutex.stub(:new).with(no_args).and_return(mutex)
-          mutex.should_receive(:synchronize)
-          AtomicFixnum.new.value
-        end
-
-      end
-
-    end
-
-    context '#value' do
-
-      it 'returns the current value' do
-        counter = AtomicFixnum.new(10)
-        counter.value.should eq 10
-        counter.increment
-        counter.value.should eq 11
-        counter.decrement
-        counter.value.should eq 10
-      end
-    end
-
-    context '#value=' do
-
-      it 'sets the #value to the given `Fixnum`' do
-        atomic = AtomicFixnum.new(0)
-        atomic.value = 10
-        atomic.value.should eq 10
-      end
-
-      it 'returns the new value' do
-        atomic = AtomicFixnum.new(0)
-        (atomic.value = 10).should eq 10
-      end
-
-      it 'raises and exception if the value is not a `Fixnum`' do
-        atomic = AtomicFixnum.new(0)
-        expect {
-          atomic.value = 'foo'
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    context '#increment' do
-
-      it 'increases the value by one' do
-        counter = AtomicFixnum.new(10)
-        3.times{ counter.increment }
-        counter.value.should eq 13
-      end
-
-      it 'returns the new value' do
-        counter = AtomicFixnum.new(10)
-        counter.increment.should eq 11
-      end
-
-      it 'is aliased as #up' do
-        AtomicFixnum.new(10).up.should eq 11
-      end
-
-      if jruby?
-
-        it 'does not use Mutex class' do
-          mutex = double('mutex')
-          Mutex.stub(:new).with(no_args).and_return(mutex)
-          mutex.should_not_receive(:synchronize)
-          AtomicFixnum.new.increment
-        end
-
-      else
-
-        it 'is synchronized' do
-          mutex = double('mutex')
-          Mutex.stub(:new).with(no_args).and_return(mutex)
-          mutex.should_receive(:synchronize)
-          AtomicFixnum.new.increment
-        end
-
-      end
-
-    end
-
-    context '#decrement' do
-
-      it 'decreases the value by one' do
-        counter = AtomicFixnum.new(10)
-        3.times{ counter.decrement }
-        counter.value.should eq 7
-      end
-
-      it 'returns the new value' do
-        counter = AtomicFixnum.new(10)
-        counter.decrement.should eq 9
-      end
-
-      it 'is aliased as #down' do
-        AtomicFixnum.new(10).down.should eq 9
-      end
-
-      if jruby?
-
-        it 'does not use Mutex class' do
-          mutex = double('mutex')
-          Mutex.stub(:new).with(no_args).and_return(mutex)
-          mutex.should_not_receive(:synchronize)
-          AtomicFixnum.new.decrement
-        end
-
-      else
-
-        it 'is synchronized' do
-          mutex = double('mutex')
-          Mutex.stub(:new).with(no_args).and_return(mutex)
-          mutex.should_receive(:synchronize)
-          AtomicFixnum.new.decrement
-        end
-
-      end
-
-    end
-
-    context '#compare_and_set' do
-
-      it 'returns false if the value is not found' do
-        AtomicFixnum.new(14).compare_and_set(2, 14).should eq false
-      end
-
-      it 'returns true if the value is found' do
-        AtomicFixnum.new(14).compare_and_set(14, 2).should eq true
-      end
-
-      it 'sets if the value is found' do
-        f = AtomicFixnum.new(14)
-        f.compare_and_set(14, 2)
-        f.value.should eq 2
-      end
-
-      it 'does not set if the value is not found' do
-        f = AtomicFixnum.new(14)
-        f.compare_and_set(2, 12)
-        f.value.should eq 14
-      end
-
-      if jruby?
-
-        it 'does not use Mutex class' do
-          mutex = double('mutex')
-          Mutex.stub(:new).with(no_args).and_return(mutex)
-          mutex.should_not_receive(:synchronize)
-          AtomicFixnum.new(14).compare_and_set(14, 2)
-        end
-
-      else
-
-        it 'is synchronized' do
-          mutex = double('mutex')
-          Mutex.stub(:new).with(no_args).and_return(mutex)
-          mutex.should_receive(:synchronize)
-          AtomicFixnum.new(14).compare_and_set(14, 2)
-        end
-
-      end
-
-    end
-
-  end
-end

data/spec/concurrent/count_down_latch_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe CountDownLatch do
-
-    let(:latch) { CountDownLatch.new(3) }
-    let(:zero_count_latch) { CountDownLatch.new(0) }
-
-    context '#initialize' do
-
-      it 'raises an exception if the initial count is less than zero' do
-        expect {
-          CountDownLatch.new(-1)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'raises an exception if the initial count is not an integer' do
-        expect {
-          CountDownLatch.new('foo')
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    describe '#count' do
-
-      it 'should be the value passed to the constructor' do
-        latch.count.should eq 3
-      end
-
-      it 'should be decreased after every count down' do
-        latch.count_down
-        latch.count.should eq 2
-      end
-
-      it 'should not go below zero' do
-        5.times { latch.count_down }
-        latch.count.should eq 0
-      end
-    end
-
-    describe '#wait' do
-
-      context 'count set to zero' do
-        it 'should return true immediately' do
-          result = zero_count_latch.wait
-          result.should be_true
-        end
-
-        it 'should return true immediately with timeout' do
-          result = zero_count_latch.wait(5)
-          result.should be_true
-        end
-      end
-
-      context 'non zero count' do
-
-        it 'should block thread until counter is set to zero' do
-          3.times do
-            Thread.new { sleep(0.1); latch.count_down }
-          end
-
-          result = latch.wait
-          result.should be_true
-          latch.count.should eq 0
-        end
-
-        it 'should block until counter is set to zero with timeout' do
-          3.times do
-            Thread.new { sleep(0.1); latch.count_down }
-          end
-
-          result = latch.wait(1)
-          result.should be_true
-          latch.count.should eq 0
-
-        end
-
-        it 'should block until timeout and return false when counter is not set to zero' do
-          result = latch.wait(0.1)
-          result.should be_false
-          latch.count.should eq 3
-        end
-      end
-    end
-
-    context 'spurious wake ups' do
-
-      before(:each) do
-        def latch.simulate_spurious_wake_up
-          @mutex.synchronize do
-            @condition.signal
-            @condition.broadcast
-          end
-        end
-      end
-
-      it 'should resist to spurious wake ups without timeout' do
-        @expected = false
-        Thread.new { latch.wait; @expected = true }
-
-        sleep(0.1)
-        latch.simulate_spurious_wake_up
-
-        sleep(0.1)
-        @expected.should be_false
-      end
-
-      it 'should resist to spurious wake ups with timeout' do
-        @expected = false
-        Thread.new { latch.wait(0.5); @expected = true }
-
-        sleep(0.1)
-        latch.simulate_spurious_wake_up
-
-        sleep(0.1)
-        @expected.should be_false
-
-        sleep(0.4)
-        @expected.should be_true
-      end
-    end
-
-  end
-end