concurrent-ruby 0.1.1.pre.3 → 0.1.1.pre.4

data/lib/concurrent.rb

@@ -1,28 +1,27 @@
-require 'thread'
-
-require 'concurrent/version'
-
-require 'concurrent/event'
-
-require 'concurrent/agent'
-require 'concurrent/defer'
-require 'concurrent/executor'
-require 'concurrent/future'
-require 'concurrent/goroutine'
-require 'concurrent/promise'
-require 'concurrent/obligation'
-require 'concurrent/smart_mutex'
-require 'concurrent/utilities'
-
-require 'concurrent/reactor'
-require 'concurrent/reactor/drb_async_demux'
-require 'concurrent/reactor/tcp_sync_demux'
-
-require 'concurrent/thread_pool'
-require 'concurrent/cached_thread_pool'
-require 'concurrent/fixed_thread_pool'
-require 'concurrent/null_thread_pool'
-
-require 'concurrent/global_thread_pool'
-
-require 'concurrent/event_machine_defer_proxy' if defined?(EventMachine)
+require 'thread'
+
+require 'concurrent/version'
+
+require 'concurrent/event'
+
+require 'concurrent/agent'
+require 'concurrent/defer'
+require 'concurrent/executor'
+require 'concurrent/future'
+require 'concurrent/goroutine'
+require 'concurrent/promise'
+require 'concurrent/obligation'
+require 'concurrent/utilities'
+
+require 'concurrent/reactor'
+require 'concurrent/reactor/drb_async_demux'
+require 'concurrent/reactor/tcp_sync_demux'
+
+require 'concurrent/thread_pool'
+require 'concurrent/cached_thread_pool'
+require 'concurrent/fixed_thread_pool'
+require 'concurrent/null_thread_pool'
+
+require 'concurrent/global_thread_pool'
+
+require 'concurrent/event_machine_defer_proxy' if defined?(EventMachine)

data/lib/concurrent/agent.rb

@@ -1,108 +1,114 @@
-require 'observer'
-require 'thread'
-
-require 'concurrent/global_thread_pool'
-require 'concurrent/utilities'
-
-module Concurrent
-
-  # An agent is a single atomic value that represents an identity. The current value
-  # of the agent can be requested at any time (#deref). Each agent has a work queue and operates on
-  # the global thread pool. Consumers can #post code blocks to the agent. The code block (function)
-  # will receive the current value of the agent as its sole parameter. The return value of the block
-  # will become the new value of the agent. Agents support two error handling modes: fail and continue.
-  # A good example of an agent is a shared incrementing counter, such as the score in a video game.
-  class Agent
-    include Observable
-    include UsesGlobalThreadPool
-
-    TIMEOUT = 5
-
-    attr_reader :initial
-    attr_reader :timeout
-
-    def initialize(initial, timeout = TIMEOUT)
-      @value = initial
-      @timeout = timeout
-      @rescuers = []
-      @validator = nil
-      @queue = Queue.new
-
-      Agent.thread_pool.post{ work }
-    end
-
-    def value(timeout = 0) return @value; end
-    alias_method :deref, :value
-
-    def rescue(clazz = Exception, &block)
-      @rescuers << Rescuer.new(clazz, block) if block_given?
-      return self
-    end
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
-
-    def validate(&block)
-      @validator = block if block_given?
-      return self
-    end
-    alias_method :validates, :validate
-    alias_method :validate_with, :validate
-    alias_method :validates_with, :validate
-
-    def post(&block)
-      return @queue.length unless block_given?
-      return atomic {
-        @queue << block
-        @queue.length
-      }
-    end
-
-    def <<(block)
-      self.post(&block)
-      return self
-    end
-
-    def length
-      @queue.length
-    end
-    alias_method :size, :length
-    alias_method :count, :length
-
-    alias_method :add_watch, :add_observer
-
-    private
-
-    # @private
-    Rescuer = Struct.new(:clazz, :block)
-
-    # @private
-    def try_rescue(ex) # :nodoc:
-      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
-      rescuer.block.call(ex) if rescuer
-    rescue Exception => e
-      # supress
-    end
-
-    # @private
-    def work # :nodoc:
-      loop do
-        Thread.pass
-        handler = @queue.pop
-        begin
-          result = Timeout.timeout(@timeout){
-            handler.call(@value)
-          }
-          if @validator.nil? || @validator.call(result)
-            atomic {
-              @value = result
-              changed
-            }
-            notify_observers(Time.now, @value)
-          end
-        rescue Exception => ex
-          try_rescue(ex)
-        end
-      end
-    end
-  end
-end
+require 'observer'
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+require 'concurrent/utilities'
+
+module Concurrent
+
+  # An agent is a single atomic value that represents an identity. The current value
+  # of the agent can be requested at any time (#deref). Each agent has a work queue and operates on
+  # the global thread pool. Consumers can #post code blocks to the agent. The code block (function)
+  # will receive the current value of the agent as its sole parameter. The return value of the block
+  # will become the new value of the agent. Agents support two error handling modes: fail and continue.
+  # A good example of an agent is a shared incrementing counter, such as the score in a video game.
+  class Agent
+    include Observable
+    include UsesGlobalThreadPool
+
+    TIMEOUT = 5
+
+    attr_reader :initial
+    attr_reader :timeout
+
+    def initialize(initial, timeout = TIMEOUT)
+      @value = initial
+      @timeout = timeout
+      @rescuers = []
+      @validator = nil
+      @queue = Queue.new
+      @mutex = Mutex.new
+
+      Agent.thread_pool.post{ work }
+    end
+
+    def value(timeout = 0) return @value; end
+    alias_method :deref, :value
+
+    def rescue(clazz = Exception, &block)
+      if block_given?
+        @mutex.synchronize do
+          @rescuers << Rescuer.new(clazz, block)
+        end
+      end
+      return self
+    end
+    alias_method :catch, :rescue
+    alias_method :on_error, :rescue
+
+    def validate(&block)
+      @validator = block if block_given?
+      return self
+    end
+    alias_method :validates, :validate
+    alias_method :validate_with, :validate
+    alias_method :validates_with, :validate
+
+    def post(&block)
+      return @queue.length unless block_given?
+      return @mutex.synchronize do
+        @queue << block
+        @queue.length
+      end
+    end
+
+    def <<(block)
+      self.post(&block)
+      return self
+    end
+
+    def length
+      return @queue.length
+    end
+    alias_method :size, :length
+    alias_method :count, :length
+
+    alias_method :add_watch, :add_observer
+
+    private
+
+    # @private
+    Rescuer = Struct.new(:clazz, :block)
+
+    # @private
+    def try_rescue(ex) # :nodoc:
+      rescuer = @mutex.synchronize do
+        @rescuers.find{|r| ex.is_a?(r.clazz) }
+      end
+      rescuer.block.call(ex) if rescuer
+    rescue Exception => e
+      # supress
+    end
+
+    # @private
+    def work # :nodoc:
+      loop do
+        handler = @queue.pop
+        begin
+          result = Timeout.timeout(@timeout) do
+            handler.call(@value)
+          end
+          if @validator.nil? || @validator.call(result)
+            @mutex.synchronize do
+              @value = result
+              changed
+              notify_observers(Time.now, @value)
+            end
+          end
+        rescue Exception => ex
+          try_rescue(ex)
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/cached_thread_pool.rb

@@ -1,130 +1,129 @@
-require 'thread'
-
-require 'concurrent/thread_pool'
-require 'concurrent/utilities'
-
-require 'functional/utilities'
-
-module Concurrent
-
-  def self.new_cached_thread_pool
-    return CachedThreadPool.new
-  end
-
-  class CachedThreadPool < ThreadPool
-    behavior(:thread_pool)
-
-    DEFAULT_GC_INTERVAL = 60
-    DEFAULT_THREAD_IDLETIME = 60
-
-    attr_reader :working
-
-    def initialize(opts = {})
-      @gc_interval = (opts[:gc_interval] || DEFAULT_GC_INTERVAL).freeze
-      @thread_idletime = (opts[:thread_idletime] || DEFAULT_THREAD_IDLETIME).freeze
-      super()
-      @working = 0
-      @mutex = Mutex.new
-    end
-
-    def kill
-      @status = :killed
-      @mutex.synchronize do
-        @pool.each{|t| Thread.kill(t.thread) }
-      end
-    end
-
-    def size
-      return @pool.length
-    end
-
-    def post(*args, &block)
-      raise ArgumentError.new('no block given') unless block_given?
-      if running?
-        collect_garbage if @pool.empty?
-        @mutex.synchronize do
-          if @working >= @pool.length
-            create_worker_thread
-          end
-          @queue << [args, block]
-        end
-        return true
-      else
-        return false
-      end
-    end
-
-    # @private
-    def status # :nodoc:
-      @mutex.synchronize do
-        @pool.collect do |worker|
-          [
-            worker.status,
-            worker.status == :idle ? delta(worker.idletime, timestamp) : nil,
-            worker.thread.status
-          ]
-        end
-      end
-    end
-
-    private
-
-    Worker = Struct.new(:status, :idletime, :thread)
-
-    # @private
-    def create_worker_thread # :nodoc:
-      worker = Worker.new(:idle, timestamp, nil)
-
-      worker.thread = Thread.new(worker) do |me|
-
-        loop do
-          task = @queue.pop
-
-          atomic {
-            @working += 1
-            me.status = :working
-          }
-
-          if task == :stop
-            me.status = :stopping
-            break
-          else
-            task.last.call(*task.first)
-            atomic {
-              @working -= 1
-              me.status = :idle
-              me.idletime = timestamp
-            }
-          end
-        end
-
-        atomic {
-          @pool.delete(me)
-          if @pool.empty?
-            @termination.set
-            @status = :shutdown unless killed?
-          end
-        }
-      end
-
-      @pool << worker
-    end
-
-    # @private
-    def collect_garbage # :nodoc:
-      @collector = Thread.new do
-        loop do
-          sleep(@gc_interval)
-          @mutex.synchronize do
-            @pool.reject! do |worker|
-              worker.thread.status.nil? ||
-                (worker.status == :idle && @thread_idletime >= delta(worker.idletime, timestamp))
-            end
-          end
-          @working = @pool.count{|worker| worker.status == :working}
-          break if @pool.empty?
-        end
-      end
-    end
-  end
-end
+require 'thread'
+
+require 'concurrent/thread_pool'
+require 'concurrent/utilities'
+
+require 'functional/utilities'
+
+module Concurrent
+
+  def self.new_cached_thread_pool
+    return CachedThreadPool.new
+  end
+
+  class CachedThreadPool < ThreadPool
+    behavior(:thread_pool)
+
+    DEFAULT_GC_INTERVAL = 60
+    DEFAULT_THREAD_IDLETIME = 60
+
+    attr_reader :working
+
+    def initialize(opts = {})
+      @gc_interval = (opts[:gc_interval] || DEFAULT_GC_INTERVAL).freeze
+      @thread_idletime = (opts[:thread_idletime] || DEFAULT_THREAD_IDLETIME).freeze
+      super()
+      @working = 0
+    end
+
+    def kill
+      @status = :killed
+      mutex.synchronize do
+        @pool.each{|t| Thread.kill(t.thread) }
+      end
+    end
+
+    def size
+      return @pool.length
+    end
+
+    def post(*args, &block)
+      raise ArgumentError.new('no block given') unless block_given?
+      if running?
+        collect_garbage if @pool.empty?
+        mutex.synchronize do
+          if @working >= @pool.length
+            create_worker_thread
+          end
+          @queue << [args, block]
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    # @private
+    def status # :nodoc:
+      mutex.synchronize do
+        @pool.collect do |worker|
+          [
+            worker.status,
+            worker.status == :idle ? delta(worker.idletime, timestamp) : nil,
+            worker.thread.status
+          ]
+        end
+      end
+    end
+
+    private
+
+    Worker = Struct.new(:status, :idletime, :thread)
+
+    # @private
+    def create_worker_thread # :nodoc:
+      worker = Worker.new(:idle, timestamp, nil)
+
+      worker.thread = Thread.new(worker) do |me|
+
+        loop do
+          task = @queue.pop
+
+          mutex.synchronize do
+            @working += 1
+            me.status = :working
+          end
+
+          if task == :stop
+            me.status = :stopping
+            break
+          else
+            task.last.call(*task.first)
+            mutex.synchronize do
+              @working -= 1
+              me.status = :idle
+              me.idletime = timestamp
+            end
+          end
+        end
+
+        mutex.synchronize do
+          @pool.delete(me)
+          if @pool.empty?
+            @termination.set
+            @status = :shutdown unless killed?
+          end
+        end
+      end
+
+      @pool << worker
+    end
+
+    # @private
+    def collect_garbage # :nodoc:
+      @collector = Thread.new do
+        loop do
+          sleep(@gc_interval)
+          mutex.synchronize do
+            @pool.reject! do |worker|
+              worker.thread.status.nil? ||
+                (worker.status == :idle && @thread_idletime >= delta(worker.idletime, timestamp))
+            end
+          end
+          @working = @pool.count{|worker| worker.status == :working}
+          break if @pool.empty?
+        end
+      end
+    end
+  end
+end