concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/lib/concurrent/channel.rb

@@ -1,63 +0,0 @@
-require 'concurrent/actor'
-require 'concurrent/stoppable'
-
-module Concurrent
-
-  # +Channel+ is a functional programming variation of +Actor+, based very loosely on the
-  # *MailboxProcessor* agent in F#. +Actor+ is used to create objects that receive messages
-  # from other threads then processes those messages based on the behavior of the class.
-  # +Channel+ creates objects that receive messages and processe them using the block
-  # given at construction. +Channel+ is implemented as a subclass of +Actor+ and supports
-  # all message-passing methods of that class. +Channel+ also supports pools with a shared
-  # mailbox.
-  #
-  # @example Basic usage
-  #   channel = Concurrent::Channel.new do |msg|
-  #     sleep(1)
-  #     puts "#{msg}\n"
-  #   end
-  #   
-  #   channel.run! => #<Thread:0x007fa123d95fc8 sleep>
-  #   
-  #   channel.post("Hello, World!") => 1
-  #   # wait...
-  #   => Hello, World!
-  #   
-  #   future = channel.post? "Don't Panic." => #<Concurrent::IVar:0x007fa123d6d9d8 @state=:pending...
-  #   future.pending? => true
-  #   # wait...
-  #   => "Don't Panic."
-  #   future.fulfilled? => true
-  #   
-  #   channel.stop => true  
-  #   
-  # @see http://blogs.msdn.com/b/dsyme/archive/2010/02/15/async-and-parallel-design-patterns-in-f-part-3-agents.aspx Async and Parallel Design Patterns in F#: Agents
-  # @see http://msdn.microsoft.com/en-us/library/ee370357.aspx Control.MailboxProcessor<'Msg> Class (F#)
-  class Channel < Actor
-    include Stoppable
-
-    # Initialize a new object with a block operation to be performed in response
-    # to every received message.
-    #
-    # @yield [message] Removes the next message from the queue and processes it
-    # @yieldparam [Array] msg The next message post to the channel
-    def initialize(&block)
-      raise ArgumentError.new('no block given') unless block_given?
-      super()
-      @task = block
-    end
-
-    protected
-
-    def on_stop # :nodoc:
-      before_stop_proc.call if before_stop_proc
-      super
-    end
-
-    private
-
-    def act(*message) # :nodoc:
-      return @task.call(*message)
-    end
-  end
-end

data/lib/concurrent/fixed_thread_pool/worker.rb

@@ -1,54 +0,0 @@
-require 'thread'
-
-module Concurrent
-
-  class FixedThreadPool
-
-    class Worker
-
-      def initialize(queue, parent)
-        @queue = queue
-        @parent = parent
-        @mutex = Mutex.new
-      end
-
-      def dead?
-        return @mutex.synchronize do
-          @thread.nil? ? false : ! @thread.alive?
-        end
-      end
-
-      def kill
-        @mutex.synchronize do
-          Thread.kill(@thread) unless @thread.nil?
-          @thread = nil
-        end
-      end
-
-      def run(thread = Thread.current)
-        @mutex.synchronize do
-          raise StandardError.new('already running') unless @thread.nil?
-          @thread = thread
-        end
-
-        loop do
-          task = @queue.pop
-          if task == :stop
-            @thread = nil
-            @parent.on_worker_exit(self)
-            break
-          end
-
-          @parent.on_start_task(self)
-          begin
-            task.last.call(*task.first)
-          rescue
-            # let it fail
-          ensure
-            @parent.on_end_task(self)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/global_thread_pool.rb

@@ -1,42 +0,0 @@
-module Concurrent
-
-  class NullThreadPool
-
-    def self.post(*args)
-      Thread.new(*args) do
-        Thread.current.abort_on_exception = false
-        yield(*args)
-      end
-      return true
-    end
-
-    def post(*args, &block)
-      return NullThreadPool.post(*args, &block)
-    end
-
-    def <<(block)
-      NullThreadPool.post(&block)
-      return self
-    end
-  end
-
-  module UsesGlobalThreadPool
-
-    def self.included(base)
-      class << base
-        def thread_pool
-          @thread_pool || $GLOBAL_THREAD_POOL
-        end
-        def thread_pool=(pool)
-          if pool == $GLOBAL_THREAD_POOL
-            @thread_pool = nil
-          else
-            @thread_pool = pool
-          end
-        end
-      end
-    end
-  end
-end
-
-$GLOBAL_THREAD_POOL ||= Concurrent::NullThreadPool.new

data/spec/concurrent/cached_thread_pool_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-require_relative 'thread_pool_shared'
-
-module Concurrent
-
-  describe CachedThreadPool do
-
-    subject { CachedThreadPool.new(max_threads: 5) }
-
-    after(:each) do
-      subject.kill
-      sleep(0.1)
-    end
-
-    it_should_behave_like :thread_pool
-
-    context '#initialize' do
-
-      it 'raises an exception when the pool size is less than one' do
-        lambda {
-          CachedThreadPool.new(max: 0)
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'raises an exception when the pool size is greater than MAX_POOL_SIZE' do
-        lambda {
-          CachedThreadPool.new(max: CachedThreadPool::MAX_POOL_SIZE + 1)
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    context '#length' do
-
-      it 'returns zero for a new thread pool' do
-        subject.length.should eq 0
-      end
-
-      it 'returns the length of the subject when running' do
-        5.times{ sleep(0.1); subject << proc{ sleep(1) } }
-        subject.length.should eq 5
-      end
-
-      it 'returns zero once shut down' do
-        subject.shutdown
-        subject.length.should eq 0
-      end
-    end
-
-    context 'worker creation and caching' do
-
-      it 'creates new workers when there are none available' do
-        subject.length.should eq 0
-        5.times{ sleep(0.1); subject << proc{ sleep } }
-        sleep(1)
-        subject.length.should eq 5
-      end
-
-      it 'uses existing idle threads' do
-        5.times{ subject << proc{ sleep(0.1) } }
-        sleep(1)
-        subject.length.should >= 5
-        3.times{ subject << proc{ sleep } }
-        sleep(0.1)
-        subject.length.should >= 5
-      end
-
-      it 'never creates more than :max_threads threads' do
-        pool = CachedThreadPool.new(max: 5)
-        100.times{ sleep(0.01); pool << proc{ sleep } }
-        sleep(0.1)
-        pool.length.should eq 5
-        pool.kill
-      end
-
-      it 'sets :max_threads to MAX_POOL_SIZE when not given' do
-        CachedThreadPool.new.max_threads.should eq CachedThreadPool::MAX_POOL_SIZE
-      end
-    end
-
-    context 'garbage collection' do
-
-      subject{ CachedThreadPool.new(gc_interval: 1, idletime: 1) }
-
-      it 'removes from pool any thread that has been idle too long' do
-        3.times { subject << proc{ sleep(0.1) } }
-        subject.length.should eq 3
-        sleep(2)
-        subject << proc{ nil }
-        subject.length.should < 3
-      end
-
-      it 'removed from pool any dead thread' do
-        3.times { subject << proc{ sleep(0.1); raise Exception } }
-        subject.length.should == 3
-        sleep(2)
-        subject << proc{ nil }
-        subject.length.should < 3
-      end
-    end
-  end
-end

data/spec/concurrent/channel_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-require_relative 'postable_shared'
-require_relative 'runnable_shared'
-require_relative 'stoppable_shared'
-
-module Concurrent
-
-  describe Channel do
-
-    context :runnable do
-      subject{ Channel.new{ nil } }
-      it_should_behave_like :runnable
-    end
-
-    context :stoppable do
-      subject do
-        task = Channel.new{ nil }
-        task.run!
-        task
-      end
-      it_should_behave_like :stoppable
-    end
-
-    context :postable do
-
-      let!(:postable_class){ Channel }
-
-      let(:sender) do
-        Channel.new do |*message|
-          if message.first.is_a?(Exception)
-            raise message.first
-          else
-            message.first
-          end
-        end
-      end
-
-      let(:receiver){ Channel.new{|*message| message.first } }
-
-      it_should_behave_like :postable
-    end
-
-    subject{ Channel.new{ nil } }
-
-    context '#initialize' do
-
-      it 'raises an exception if no block is given' do
-        expect {
-          Channel.new
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    context '#behavior' do
-
-      it 'calls the block once for each message' do
-        @expected = false
-        channel = Channel.new{ @expected = true }
-        channel.run!
-        channel << 42
-        sleep(0.1)
-        channel.stop
-        @expected.should be_true
-      end
-
-      it 'passes all arguments to the block' do
-        @expected = []
-        channel = Channel.new{|*message| @expected = message }
-        channel.run!
-        channel.post(1,2,3,4,5)
-        sleep(0.1)
-        channel.stop
-        @expected.should eq [1,2,3,4,5]
-      end
-    end
-
-    context '#pool' do
-
-      it 'passes a duplicate of the block to each channel in the pool' do
-        block = proc{ nil }
-        block.should_receive(:dup).exactly(5).times.and_return(proc{ nil })
-        mbox, pool = Channel.pool(5, &block)
-      end
-    end
-  end
-end

data/spec/concurrent/fixed_thread_pool_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-require_relative 'thread_pool_shared'
-
-module Concurrent
-
-  describe FixedThreadPool do
-
-    subject { FixedThreadPool.new(5) }
-
-    after(:each) do
-      subject.kill
-      sleep(0.1)
-    end
-
-    it_should_behave_like :thread_pool
-
-    context '#initialize' do
-
-      it 'raises an exception when the pool length is less than one' do
-        lambda {
-          FixedThreadPool.new(0)
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'raises an exception when the pool length is greater than MAX_POOL_SIZE' do
-        lambda {
-          FixedThreadPool.new(FixedThreadPool::MAX_POOL_SIZE + 1)
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    context '#length' do
-
-      let(:pool_length) { 3 }
-      subject { FixedThreadPool.new(pool_length) }
-
-      it 'returns zero on start' do
-        subject.shutdown
-        subject.length.should eq 0
-      end
-
-      it 'returns the length of the pool when running' do
-        pool_length.times do |i|
-          subject.post{ sleep }
-          sleep(0.1)
-          subject.length.should eq pool_length
-        end
-      end
-
-      it 'returns zero while shutting down' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.length.should eq 0
-      end
-
-      it 'returns zero once shut down' do
-        subject.shutdown
-        subject.length.should eq 0
-      end
-    end
-
-    context 'worker creation and caching' do
-
-      it 'creates new workers when there are none available' do
-        pool = FixedThreadPool.new(5)
-        pool.length.should eq 0
-        5.times{ pool << proc{ sleep } }
-        sleep(0.1)
-        pool.length.should eq 5
-        pool.kill
-      end
-
-      it 'never creates more than :max_threads threads' do
-        pool = FixedThreadPool.new(5)
-        100.times{ pool << proc{ sleep } }
-        sleep(0.1)
-        pool.length.should eq 5
-        pool.kill
-      end
-    end
-
-    context 'exception handling' do
-
-      it 'restarts threads that experience exception' do
-        pool = FixedThreadPool.new(5)
-        5.times{ pool << proc{ raise StandardError } }
-        sleep(1)
-        pool.length.should eq 5
-      end
-    end
-  end
-end

data/spec/concurrent/uses_global_thread_pool_shared.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-share_examples_for Concurrent::UsesGlobalThreadPool do
-
-  before(:each) do
-    $GLOBAL_THREAD_POOL = Concurrent::FixedThreadPool.new(1)
-  end
-
-  it 'defaults to the global thread pool' do
-    clazz = Class.new(thread_pool_user)
-    clazz.thread_pool.should eq $GLOBAL_THREAD_POOL
-  end
-
-  it 'sets and gets the thread pool for the class' do
-    pool = Concurrent::NullThreadPool.new
-    thread_pool_user.thread_pool = pool
-    thread_pool_user.thread_pool.should eq pool
-  end
-
-  it 'gives each class its own thread pool' do
-    subject1 = Class.new(thread_pool_user){ include Concurrent::UsesGlobalThreadPool }
-    subject2 = Class.new(thread_pool_user){ include Concurrent::UsesGlobalThreadPool }
-    subject3 = Class.new(thread_pool_user){ include Concurrent::UsesGlobalThreadPool }
-
-    subject1.thread_pool = Concurrent::FixedThreadPool.new(1)
-    subject2.thread_pool = Concurrent::CachedThreadPool.new
-    subject3.thread_pool = Concurrent::NullThreadPool.new
-
-    subject1.thread_pool.should_not eq subject2.thread_pool
-    subject2.thread_pool.should_not eq subject3.thread_pool
-    subject3.thread_pool.should_not eq subject1.thread_pool
-  end
-
-  it 'uses the new global thread pool after the global thread pool is changed' do
-    null_thread_pool = Concurrent::NullThreadPool.new
-    thread_pool_user.thread_pool = $GLOBAL_THREAD_POOL
-
-    thread_pool_user.thread_pool.should eq $GLOBAL_THREAD_POOL
-    thread_pool_user.thread_pool.should_not eq null_thread_pool
-
-    $GLOBAL_THREAD_POOL = null_thread_pool
-
-    thread_pool_user.thread_pool.should eq $GLOBAL_THREAD_POOL
-    thread_pool_user.thread_pool.should eq null_thread_pool
-  end
-
-  it 'responds to multiple changes in the global thread pool' do
-    thread_pool_user.thread_pool = $GLOBAL_THREAD_POOL
-    thread_pool_user.thread_pool.should eq $GLOBAL_THREAD_POOL
-
-    thread_pool_user.thread_pool = Concurrent::NullThreadPool.new
-    thread_pool_user.thread_pool.should_not eq $GLOBAL_THREAD_POOL
-
-    $GLOBAL_THREAD_POOL = Concurrent::FixedThreadPool.new(1)
-    thread_pool_user.thread_pool = $GLOBAL_THREAD_POOL
-    thread_pool_user.thread_pool.should eq $GLOBAL_THREAD_POOL
-
-    $GLOBAL_THREAD_POOL = Concurrent::CachedThreadPool.new
-    thread_pool_user.thread_pool.should eq $GLOBAL_THREAD_POOL
-
-    $GLOBAL_THREAD_POOL = Concurrent::NullThreadPool.new
-    thread_pool_user.thread_pool.should eq $GLOBAL_THREAD_POOL
-  end
-end