concurrent-ruby 0.2.2 → 0.3.0.pre.1

data/lib/concurrent/event.rb

@@ -16,39 +16,30 @@ module Concurrent
       return @set == true
     end
 
-    def set(pulse = false)
+    def set
       return true if set?
-      @mutex.synchronize {
+      @mutex.synchronize do
         @set = true
-        while @waiting > 0
-          @notifier << :set
-          @waiting -= 1
-        end
-        @set = ! pulse
-      }
+        @waiting.times { @notifier << :set }
+        @waiting = 0
+      end
       return true
     end
 
     def reset
-      @mutex.synchronize {
-        @set = false
-      }
+      @mutex.synchronize { @set = false }
       return true
     end
 
-    def pulse
-      return set(true)
-    end
-
     def wait(timeout = nil)
       return true if set?
 
+      @mutex.synchronize { @waiting += 1 }
+
       if timeout.nil?
-        @waiting += 1
         @notifier.pop
       else
         Timeout::timeout(timeout) do
-          @waiting += 1
           @notifier.pop
         end
       end

data/lib/concurrent/executor.rb

@@ -1,96 +1,92 @@
 require 'thread'
+require 'concurrent/runnable'
 
 module Concurrent
 
-  module Executor
-    extend self
+  class Executor
+    include Runnable
+    behavior(:runnable)
 
-    class ExecutionContext
-      attr_reader :name
-      attr_reader :execution_interval
-      attr_reader :timeout_interval
+    EXECUTION_INTERVAL = 60
+    TIMEOUT_INTERVAL = 30
 
-      protected
+    STDOUT_LOGGER = proc do |name, level, msg|
+      print "%5s (%s) %s: %s\n" % [level.upcase, Time.now.strftime("%F %T"), name, msg]
+    end
 
-      def initialize(name, execution_interval, timeout_interval, thread)
-        @name = name
-        @execution_interval = execution_interval
-        @timeout_interval = timeout_interval
-        @thread = thread
-        @thread[:stop] = false
-      end
+    attr_reader :name
+    attr_reader :execution_interval
+    attr_reader :timeout_interval
 
-      public
+    def initialize(name, opts = {}, &block)
+      raise ArgumentError.new('no block given') unless block_given?
 
-      def status
-        return @thread.status unless @thread.nil?
-      end
+      @name = name
+      @execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
+      @timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
+      @run_now = opts[:now] || opts[:run_now] || false
+      @logger = opts[:logger] || STDOUT_LOGGER
+      @block_args = opts[:args] || opts [:arguments] || []
 
-      def join(limit = nil)
-        if @thread.nil?
-          return nil
-        elsif limit.nil?
-          return @thread.join
-        else
-          return @thread.join(limit)
-        end
-      end
+      @task = block
+    end
 
-      def stop
-        @thread[:stop] = true
+    def kill
+      return true unless running?
+      mutex.synchronize do
+        @running = false
+        Thread.kill(@worker) unless @worker.nil?
+        Thread.kill(@monitor) unless @monitor.nil?
       end
+      return true
+    rescue
+      return false
+    ensure
+      @worker = @monitor = nil
+    end
+    alias_method :terminate, :kill
 
-      def kill
-        unless @thread.nil?
-          stop
-          Thread.kill(@thread)
-          @thread = nil
-        end
-      end
-      alias_method :terminate, :kill
+    def status
+      return @monitor.status unless @monitor.nil?
     end
 
-    EXECUTION_INTERVAL = 60
-    TIMEOUT_INTERVAL = 30
+    protected
 
-    STDOUT_LOGGER = proc do |name, level, msg|
-      print "%5s (%s) %s: %s\n" % [level.upcase, Time.now.strftime("%F %T"), name, msg]
+    def on_run
+      @monitor = Thread.current
     end
 
-    def run(name, opts = {})
-      raise ArgumentError.new('no block given') unless block_given?
-
-      execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
-      timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
-      run_now = opts[:now] || opts[:run_now] || false
-      logger = opts[:logger] || STDOUT_LOGGER
-      block_args = opts[:args] || opts [:arguments] || []
+    def on_stop
+      @monitor.wakeup if @monitor.alive?
+      Thread.pass
+    end
 
-      executor = Thread.new(*block_args) do |*args|
-        sleep(execution_interval) unless run_now == true
-        loop do
-          break if Thread.current[:stop]
-          begin
-            worker = Thread.new{ yield(*args) }
-            worker.abort_on_exception = false
-            if worker.join(timeout_interval).nil?
-              logger.call(name, :warn, "execution timed out after #{timeout_interval} seconds")
-            else
-              logger.call(name, :info, 'execution completed successfully')
-            end
-          rescue Exception => ex
-            logger.call(name, :error, "execution failed with error '#{ex}'")
-          ensure
-            Thread.kill(worker)
-            worker = nil
-          end
-          break if Thread.current[:stop]
-          sleep(execution_interval)
-        end
+    def on_task
+      if @run_now
+        @run_now = false
+      else
+        sleep(@execution_interval)
       end
+      execute_task
+    end
 
-      executor.abort_on_exception = false
-      return ExecutionContext.new(name, execution_interval, timeout_interval, executor)
+    def execute_task
+      @worker = Thread.new do
+        Thread.current.abort_on_exception = false
+        @task.call(*@block_args)
+      end
+      if @worker.join(@timeout_interval).nil?
+        @logger.call(@name, :warn, "execution timed out after #{@timeout_interval} seconds")
+      else
+        @logger.call(@name, :info, 'execution completed successfully')
+      end
+    rescue Exception => ex
+      @logger.call(@name, :error, "execution failed with error '#{ex}'")
+    ensure
+      unless @worker.nil?
+        Thread.kill(@worker)
+        @worker = nil
+      end
     end
   end
 end

data/lib/concurrent/fixed_thread_pool.rb

@@ -1,99 +1,31 @@
-require 'thread'
-
 require 'concurrent/thread_pool'
-require 'concurrent/event'
 
 module Concurrent
 
-  def self.new_fixed_thread_pool(size)
-    return FixedThreadPool.new(size)
-  end
-
-  class FixedThreadPool < ThreadPool
-    behavior(:thread_pool)
-
-    MIN_POOL_SIZE = 1
-    MAX_POOL_SIZE = 1024
-
-    def initialize(size)
-      super()
-      if size < MIN_POOL_SIZE || size > MAX_POOL_SIZE
-        raise ArgumentError.new("size must be between #{MIN_POOL_SIZE} and #{MAX_POOL_SIZE}")
-      end
-
-      @pool = size.times.collect{ create_worker_thread }
-      collect_garbage
-    end
-
-    def kill
-      mutex.synchronize do
-        @status = :killed
-        @pool.each{|t| Thread.kill(t) }
-      end
-    end
+  class FixedThreadPool < AbstractThreadPool
+    behavior(:global_thread_pool)
 
-    def size
-      if running?
-        return @pool.length
-      else
-        return 0
-      end
+    def initialize(size, opts = {})
+      super(opts.merge(max_threads: size))
     end
 
     def post(*args, &block)
       raise ArgumentError.new('no block given') unless block_given?
-      if running?
-        @queue << [args, block]
-        return true
-      else
-        return false
-      end
-    end
-
-    # @private
-    def status # :nodoc:
-      mutex.synchronize do
-        @pool.collect{|t| t.status }
-      end
-    end
-
-    private
-
-    # @private
-    def create_worker_thread # :nodoc:
-      thread = Thread.new do
-        loop do
-          task = @queue.pop
-          if task == :stop
-            break
-          else
-            task.last.call(*task.first)
-          end
-        end
-        @pool.delete(Thread.current)
-        if @pool.empty?
-          @termination.set
-          @status = :shutdown unless killed?
+      return @mutex.synchronize do
+        if @state == :running
+          @queue << [args, block]
+          @pool << create_worker_thread if @pool.size < @max_threads
+          true
+        else
+          false
         end
       end
-
-      thread.abort_on_exception = false
-      return thread
     end
 
-    # @private
-    def collect_garbage # :nodoc:
-      @collector = Thread.new do
-        sleep(1)
-        mutex.synchronize do
-          @pool.size.times do |i|
-            if @pool[i].status.nil?
-              @pool[i] = create_worker_thread
-            end
-          end
-        end
-      end
-      @collector.abort_on_exception = false
+    protected
+
+    def collect_garbage
+      @pool.reject! {|context| ! context.status }
     end
   end
 end

data/lib/concurrent/functions.rb

@@ -1,5 +1,4 @@
 require 'concurrent/agent'
-require 'concurrent/defer'
 require 'concurrent/future'
 require 'concurrent/promise'
 
@@ -7,34 +6,20 @@ module Kernel
 
   ## agent
 
-  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
-    return Concurrent::Agent.new(initial, timeout)
+  def agent(*args, &block)
+    return Concurrent::Agent.new(*args, &block)
   end
   module_function :agent
 
-  def post(object, &block)
+  def post(object, *args, &block)
     if object.respond_to?(:post)
-      return object.post(&block)
+      return object.post(*args, &block)
     else
       raise ArgumentError.new('object does not support #post')
     end
   end
   module_function :post
 
-  ## defer
-
-  def defer(*args, &block)
-    return Concurrent::Defer.new(*args, &block)
-  end
-  module_function :defer
-
-  ## executor
-
-  def executor(*args, &block)
-    return Concurrent::Executor.run(*args, &block)
-  end
-  module_function :executor
-
   ## future
 
   def future(*args, &block)
@@ -44,11 +29,11 @@ module Kernel
 
   ## obligation
 
-  def deref(object, timeout = nil)
+  def deref(object, *args, &block)
     if object.respond_to?(:deref)
-      return object.deref(timeout)
+      return object.deref(*args, &block)
     elsif object.respond_to?(:value)
-      return object.value(timeout)
+      return object.value(*args, &block)
     else
       raise ArgumentError.new('object does not support #deref')
     end

data/lib/concurrent/future.rb

@@ -1,18 +1,20 @@
 require 'thread'
+require 'observer'
 
 require 'concurrent/global_thread_pool'
 require 'concurrent/obligation'
-require 'concurrent/utilities'
 
 module Concurrent
 
   class Future
     include Obligation
+    include Observable
     include UsesGlobalThreadPool
 
     behavior(:future)
 
     def initialize(*args, &block)
+      @mutex = Mutex.new
       unless block_given?
         @state = :fulfilled
       else
@@ -24,18 +26,36 @@ module Concurrent
       end
     end
 
+    def add_observer(observer, func = :update)
+      @mutex.synchronize do
+        if event.set?
+          Future.thread_pool.post(func, Time.now, @value, @reason) do |f, *args|
+            observer.send(f, *args)
+          end
+        else
+          super
+        end
+      end
+      return func
+    end
+
     private
 
     # @private
     def work(*args) # :nodoc:
-      mutex.synchronize do
-        begin
-          @value = yield(*args)
-          @state = :fulfilled
-        rescue Exception => ex
-          @state = :rejected
-          @reason = ex
-        end
+      begin
+        @value = yield(*args)
+        @state = :fulfilled
+      rescue Exception => ex
+        @reason = ex
+        @state = :rejected
+      ensure
+        @mutex.synchronize {
+          event.set
+          changed
+          notify_observers(Time.now, @value, @reason)
+          delete_observers
+        }
       end
     end
   end