concurrent-ruby 0.1.0 → 0.1.1.pre.1

data/lib/concurrent.rb

@@ -1,20 +1,27 @@
-require 'thread'
-
-require 'concurrent/version'
-
-require 'concurrent/event'
-
-require 'concurrent/agent'
-require 'concurrent/defer'
-require 'concurrent/future'
-require 'concurrent/goroutine'
-require 'concurrent/promise'
-require 'concurrent/obligation'
-
-require 'concurrent/thread_pool'
-require 'concurrent/cached_thread_pool'
-require 'concurrent/fixed_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/reactor'
+require 'concurrent/smart_mutex'
+require 'concurrent/utilities'
+
+require 'concurrent/drb_async_demux'
+require 'concurrent/tcp_sync_demux'
+
+require 'concurrent/thread_pool'
+require 'concurrent/cached_thread_pool'
+require 'concurrent/fixed_thread_pool'
+
+require 'concurrent/global_thread_pool'
+
+require 'concurrent/event_machine_defer_proxy' if defined?(EventMachine)

data/lib/concurrent/agent.rb

@@ -1,130 +1,106 @@
-require 'observer'
-require 'thread'
-
-require 'concurrent/global_thread_pool'
-
-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
-
-    TIMEOUT = 5
-
-    attr_reader :initial
-    attr_reader :timeout
-
-    def initialize(initial, timeout = TIMEOUT)
-      @value = initial
-      @timeout = timeout
-      @rescuers = []
-      @validator = nil
-      @queue = Queue.new
-
-      $GLOBAL_THREAD_POOL << proc{ 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?
-      @queue << block
-      return @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)
-            @value = result
-            changed
-            notify_observers(Time.now, @value)
-          end
-        rescue Exception => ex
-          try_rescue(ex)
-        end
-      end
-    end
-  end
-end
-
-module Kernel
-
-  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
-    return Concurrent::Agent.new(initial, timeout)
-  end
-  module_function :agent
-
-  def deref(agent, timeout = nil)
-    if agent.respond_to?(:deref)
-      return agent.deref(timeout)
-    elsif agent.respond_to?(:value)
-      return agent.deref(timeout)
-    else
-      return nil
-    end
-  end
-  module_function :deref
-
-  def post(agent, &block)
-    if agent.respond_to?(:post)
-      return agent.post(&block)
-    else
-      return nil
-    end
-  end
-  module_function :deref
-end
+require 'observer'
+require 'thread'
+
+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
+
+    TIMEOUT = 5
+
+    attr_reader :initial
+    attr_reader :timeout
+
+    def initialize(initial, timeout = TIMEOUT)
+      @value = initial
+      @timeout = timeout
+      @rescuers = []
+      @validator = nil
+      @queue = Queue.new
+
+      @thread = Thread.new{ 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

data/lib/concurrent/cached_thread_pool.rb

@@ -1,122 +1,130 @@
-require 'thread'
-
-require 'concurrent/thread_pool'
-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
-      @thread_idletime = opts[:thread_idletime] || DEFAULT_THREAD_IDLETIME
-      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
-
-          @working += 1
-          me.status = :working
-
-          if task == :stop
-            me.status = :stopping
-            break
-          else
-            task.last.call(*task.first)
-            @working -= 1
-            me.status = :idle
-            me.idletime = timestamp
-          end
-        end
-
-        @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
+      @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