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

data/lib/concurrent/event.rb

@@ -1,5 +1,5 @@
 require 'thread'
-require 'timeout'
+require 'concurrent/utilities'
 
 module Concurrent
 
@@ -7,9 +7,8 @@ module Concurrent
 
     def initialize
       @set = false
-      @notifier = Queue.new
       @mutex = Mutex.new
-      @waiting = 0
+      @waiters = []
     end
 
     def set?
@@ -20,32 +19,32 @@ module Concurrent
       return true if set?
       @mutex.synchronize do
         @set = true
-        @waiting.times { @notifier << :set }
-        @waiting = 0
+        @waiters.each {|waiter| waiter.run if waiter.status == 'sleep'}
       end
       return true
     end
 
     def reset
-      @mutex.synchronize { @set = false }
+      @mutex.synchronize { @set = false; @waiters.clear }
       return true
     end
 
     def wait(timeout = nil)
       return true if set?
 
-      @mutex.synchronize { @waiting += 1 }
+      @mutex.synchronize { @waiters << Thread.current }
+      return true if set? # if event was set while waiting for mutex
 
       if timeout.nil?
-        @notifier.pop
+        slept = sleep
       else
-        Timeout::timeout(timeout) do
-          @notifier.pop
-        end
+        slept = sleep(timeout)
       end
-      return true
-    rescue Timeout::Error
-      return false
+    rescue
+      # let it fail
+    ensure
+      @mutex.synchronize { @waiters.delete(Thread.current) }
+      return set?
     end
   end
 end

data/lib/concurrent/event_machine_defer_proxy.rb

@@ -3,7 +3,6 @@ require 'concurrent/global_thread_pool'
 module Concurrent
 
   class EventMachineDeferProxy
-    behavior(:global_thread_pool)
 
     def post(*args, &block)
       if args.empty?

data/lib/concurrent/executor.rb

@@ -5,7 +5,6 @@ module Concurrent
 
   class Executor
     include Runnable
-    behavior(:runnable)
 
     EXECUTION_INTERVAL = 60
     TIMEOUT_INTERVAL = 30

data/lib/concurrent/fixed_thread_pool.rb

@@ -1,31 +1,128 @@
-require 'concurrent/thread_pool'
+require 'thread'
+
+require 'concurrent/event'
+require 'concurrent/fixed_thread_pool/worker'
 
 module Concurrent
 
-  class FixedThreadPool < AbstractThreadPool
-    behavior(:global_thread_pool)
+  class FixedThreadPool
+
+    MIN_POOL_SIZE = 1
+    MAX_POOL_SIZE = 256
+
+    attr_accessor :max_threads
 
     def initialize(size, opts = {})
-      super(opts.merge(max_threads: size))
+      @max_threads = size || MAX_POOL_SIZE
+      if @max_threads < MIN_POOL_SIZE || @max_threads > MAX_POOL_SIZE
+        raise ArgumentError.new("size must be from #{MIN_POOL_SIZE} to #{MAX_POOL_SIZE}")
+      end
+
+      @state = :running
+      @pool = []
+      @terminator = Event.new
+      @queue = Queue.new
+      @mutex = Mutex.new
+    end
+
+    def running?
+      return @state == :running
+    end
+
+    def wait_for_termination(timeout = nil)
+      return @terminator.wait(timeout)
     end
 
     def post(*args, &block)
-      raise ArgumentError.new('no block given') unless block_given?
-      return @mutex.synchronize do
-        if @state == :running
-          @queue << [args, block]
-          @pool << create_worker_thread if @pool.size < @max_threads
-          true
+      raise ArgumentError.new('no block given') if block.nil?
+      @mutex.synchronize do
+        break false unless @state == :running
+        @queue << [args, block]
+        clean_pool
+        fill_pool
+        true
+      end
+    end
+
+    def <<(block)
+      self.post(&block)
+      return self
+    end
+
+    def shutdown
+      @mutex.synchronize do
+        break unless @state == :running
+        if @pool.empty?
+          @state = :shutdown
+          @terminator.set
         else
-          false
+          @state = :shuttingdown
+          @pool.length.times{ @queue << :stop }
         end
       end
     end
 
-    protected
+    def kill
+      @mutex.synchronize do
+        break if @state == :shutdown
+        @state = :shutdown
+        @queue.clear
+        drain_pool
+        @terminator.set
+      end
+    end
+
+    def length
+      @mutex.synchronize do
+        @state == :running ? @pool.length : 0
+      end
+    end
+
+    def create_worker_thread
+      wrkr = Worker.new(@queue, self)
+      Thread.new(wrkr, self) do |worker, parent|
+        Thread.current.abort_on_exception = false
+        worker.run
+        parent.on_worker_exit(worker)
+      end
+      return wrkr
+    end
+
+    def fill_pool
+      return unless @state == :running
+      while @pool.length < @max_threads
+        @pool << create_worker_thread
+      end
+    end
+
+    def clean_pool
+      @pool.reject! {|worker| worker.dead? } 
+    end
+
+    def drain_pool
+      @pool.each {|worker| worker.kill }
+      @pool.clear
+    end
 
-    def collect_garbage
-      @pool.reject! {|context| ! context.status }
+    def on_start_task(worker)
+    end
+
+    def on_end_task(worker)
+      @mutex.synchronize do
+        break unless @state == :running
+        clean_pool
+        fill_pool
+      end
+    end
+
+    def on_worker_exit(worker)
+      @mutex.synchronize do
+        @pool.delete(worker)
+        if @pool.empty? && @state != :running
+          @state = :shutdown
+          @terminator.set
+        end
+      end
     end
   end
 end

data/lib/concurrent/fixed_thread_pool/worker.rb

@@ -0,0 +1,54 @@
+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/future.rb

@@ -11,8 +11,6 @@ module Concurrent
     include Observable
     include UsesGlobalThreadPool
 
-    behavior(:future)
-
     def initialize(*args, &block)
       @mutex = Mutex.new
       unless block_given?

data/lib/concurrent/global_thread_pool.rb

@@ -1,8 +1,24 @@
-require 'concurrent/cached_thread_pool'
+module Concurrent
 
-$GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new
+  class NullThreadPool
 
-module Concurrent
+    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
 
@@ -22,3 +38,5 @@ module Concurrent
     end
   end
 end
+
+$GLOBAL_THREAD_POOL ||= Concurrent::NullThreadPool.new

data/lib/concurrent/goroutine.rb

@@ -19,11 +19,7 @@ module Kernel
   # @see https://gobyexample.com/goroutines
   def go(*args, &block)
     return false unless block_given?
-    if args.first.behaves_as?(:global_thread_pool)
-      args.first.post(*args.slice(1, args.length), &block)
-    else
-      $GLOBAL_THREAD_POOL.post(*args, &block)
-    end
+    $GLOBAL_THREAD_POOL.post(*args, &block)
   end
   module_function :go
 end

data/lib/concurrent/obligation.rb

@@ -1,27 +1,8 @@
 require 'thread'
 require 'timeout'
-require 'functional'
 
 require 'concurrent/event'
 
-behavior_info(:future,
-              state: 0,
-              value: -1,
-              reason: 0,
-              pending?: 0,
-              fulfilled?: 0,
-              rejected?: 0)
-
-behavior_info(:promise,
-              state: 0,
-              value: -1,
-              reason: 0,
-              pending?: 0,
-              fulfilled?: 0,
-              rejected?: 0,
-              then: 0,
-              rescue: -1)
-
 module Concurrent
 
   module Obligation

data/lib/concurrent/promise.rb

@@ -9,9 +9,6 @@ module Concurrent
     include Obligation
     include UsesGlobalThreadPool
 
-    behavior(:future)
-    behavior(:promise)
-
     # Creates a new promise object. "A promise represents the eventual
     # value returned from the single completion of an operation."
     # Promises can be chained in a tree structure where each promise
@@ -60,7 +57,7 @@ module Concurrent
     # @return [Promise] the new promise
     def then(&block)
       child = @lock.synchronize do
-        block = Proc.new{|result| result } unless block_given?
+        block = Proc.new{|result| result } if block.nil?
         @children << Promise.new(self, &block)
         @children.last.on_reject(@reason) if rejected?
         push(@children.last)
@@ -80,7 +77,7 @@ module Concurrent
     #
     # @return [self] so that additional chaining can occur
     def rescue(clazz = nil, &block)
-      return self if fulfilled? || rescued? || ! block_given?
+      return self if fulfilled? || rescued? || block.nil?
       @lock.synchronize do
         rescuer = Rescuer.new(clazz, block)
         if pending?

data/lib/concurrent/runnable.rb

@@ -1,10 +1,4 @@
 require 'thread'
-require 'functional'
-
-behavior_info(:runnable,
-              run: 0,
-              stop: 0,
-              running?: 0)
 
 module Concurrent
 
@@ -18,6 +12,8 @@ module Concurrent
           Thread.abort_on_exception = false
           runner.run
         end
+        #HACK: more consistent on JRuby and Rbx
+        sleep(0.1)
       end
     end
 
@@ -52,8 +48,6 @@ module Concurrent
 
   module Runnable
 
-    behavior(:runnable)
-
     LifecycleError = Class.new(StandardError)
 
     def self.included(base)

data/lib/concurrent/supervisor.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'functional'
 
 require 'concurrent/runnable'
 
@@ -7,12 +6,11 @@ module Concurrent
 
   class Supervisor
 
-    behavior(:runnable)
-
     DEFAULT_MONITOR_INTERVAL = 1
     RESTART_STRATEGIES = [:one_for_one, :one_for_all, :rest_for_one]
     DEFAULT_MAX_RESTART = 5
     DEFAULT_MAX_TIME = 60
+    WORKER_API = {run: 0, stop: 0, running?: 0}
 
     CHILD_TYPES = [:worker, :supervisor]
     CHILD_RESTART_OPTIONS = [:permanent, :transient, :temporary]
@@ -148,7 +146,7 @@ module Concurrent
     end
 
     def add_worker(worker, opts = {})
-      return nil if worker.nil? || ! worker.behaves_as?(:runnable)
+      return nil if worker.nil? || ! behaves_as_worker?(worker)
       return @mutex.synchronize {
         restart = opts[:restart] || :permanent
         type = opts[:type] || (worker.is_a?(Supervisor) ? :supervisor : nil) || :worker
@@ -222,6 +220,13 @@ module Concurrent
 
     private
 
+    def behaves_as_worker?(obj)
+      return WORKER_API.each do |method, arity|
+        break(false) unless obj.respond_to?(method) && obj.method(method).arity == arity
+        true
+      end
+    end
+
     def monitor
       @workers.each{|context| run_worker(context)}
       loop do