concurrent-ruby 0.1.0 → 0.1.1.pre.1

data/lib/concurrent/fixed_thread_pool.rb

@@ -1,89 +1,89 @@
-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
-      @status = :killed
-      @pool.each{|t| Thread.kill(t) }
-    end
-
-    def size
-      if running?
-        return @pool.length
-      else
-        return 0
-      end
-    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:
-      @pool.collect{|t| t.status }
-    end
-
-    private
-
-    # @private
-    def create_worker_thread # :nodoc:
-      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?
-        end
-      end
-    end
-
-    # @private
-    def collect_garbage # :nodoc:
-      @collector = Thread.new do
-        sleep(1)
-        @pool.size.times do |i|
-          if @pool[i].status.nil?
-            @pool[i] = create_worker_thread
-          end
-        end
-      end
-    end
-  end
-end
+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
+      @status = :killed
+      @pool.each{|t| Thread.kill(t) }
+    end
+
+    def size
+      if running?
+        return @pool.length
+      else
+        return 0
+      end
+    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:
+      @pool.collect{|t| t.status }
+    end
+
+    private
+
+    # @private
+    def create_worker_thread # :nodoc:
+      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?
+        end
+      end
+    end
+
+    # @private
+    def collect_garbage # :nodoc:
+      @collector = Thread.new do
+        sleep(1)
+        @pool.size.times do |i|
+          if @pool[i].status.nil?
+            @pool[i] = create_worker_thread
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/functions.rb

@@ -0,0 +1,120 @@
+require 'concurrent/agent'
+require 'concurrent/defer'
+require 'concurrent/future'
+require 'concurrent/promise'
+
+module Kernel
+
+  ## agent
+
+  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
+    return Concurrent::Agent.new(initial, timeout)
+  end
+  module_function :agent
+
+  def post(agent, &block)
+    if agent.respond_to?(:post)
+      return agent.post(&block)
+    else
+      return nil
+    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)
+    return Concurrent::Future.new(*args, &block)
+  end
+  module_function :future
+
+  ## obligation
+
+  def deref(obligation, timeout = nil)
+    if obligation.respond_to?(:deref)
+      return obligation.deref(timeout)
+    elsif obligation.respond_to?(:value)
+      return obligation.deref(timeout)
+    else
+      return nil
+    end
+  end
+  module_function :deref
+
+  def pending?(obligation)
+    if obligation.respond_to?(:pending?)
+      return obligation.pending?
+    else
+      return false
+    end
+  end
+  module_function :pending?
+
+  def fulfilled?(obligation)
+    if obligation.respond_to?(:fulfilled?)
+      return obligation.fulfilled?
+    elsif obligation.respond_to?(:realized?)
+      return obligation.realized?
+    else
+      return false
+    end
+  end
+  module_function :fulfilled?
+
+  def realized?(obligation)
+    if obligation.respond_to?(:realized?)
+      return obligation.realized?
+    elsif obligation.respond_to?(:fulfilled?)
+      return obligation.fulfilled?
+    else
+      return false
+    end
+  end
+  module_function :realized?
+
+  def rejected?(obligation)
+    if obligation.respond_to?(:rejected?)
+      return obligation.rejected?
+    else
+      return false
+    end
+  end
+  module_function :rejected?
+
+  ## 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
+  # has zero or more children. Promises are resolved asynchronously
+  # in the order they are added to the tree. Parents are guaranteed
+  # to be resolved before their children. The result of each promise
+  # is passes to each of its children when the child resolves. When
+  # a promise is rejected all its children will be summarily rejected.
+  # A promise added to a rejected promise will immediately be rejected.
+  # A promise that is neither resolved or rejected is pending.
+  #
+  # @param args [Array] zero or more arguments for the block
+  # @param block [Proc] the block to call when attempting fulfillment
+  #
+  # @see Promise
+  # @see http://wiki.commonjs.org/wiki/Promises/A
+  def promise(*args, &block)
+    return Concurrent::Promise.new(*args, &block)
+  end
+  module_function :promise
+end

data/lib/concurrent/future.rb

@@ -1,42 +1,52 @@
-require 'thread'
-
-require 'concurrent/obligation'
-require 'concurrent/global_thread_pool'
-
-module Concurrent
-
-  class Future
-    include Obligation
-    behavior(:future)
-
-    def initialize(*args)
-
-      unless block_given?
-        @state = :fulfilled
-      else
-        @value = nil
-        @state = :pending
-        $GLOBAL_THREAD_POOL.post do
-          semaphore.synchronize do
-            Thread.pass
-            begin
-              @value = yield(*args)
-              @state = :fulfilled
-            rescue Exception => ex
-              @state = :rejected
-              @reason = ex
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-module Kernel
-
-  def future(*args, &block)
-    return Concurrent::Future.new(*args, &block)
-  end
-  module_function :future
-end
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+require 'concurrent/obligation'
+require 'concurrent/utilities'
+
+module Concurrent
+
+  class Future
+    include Obligation
+    behavior(:future)
+
+    def initialize(*args, &block)
+      if args.first.behaves_as?(:global_thread_pool)
+        thread_pool = args.first
+        args = args.slice(1, args.length)
+      else
+        thread_pool = $GLOBAL_THREAD_POOL
+      end
+
+      unless block_given?
+        @state = :fulfilled
+      else
+        @value = nil
+        @state = :pending
+        thread_pool.post do
+          Thread.pass
+          work(*args, &block)
+        end
+      end
+    end
+
+    private
+
+    # @private
+    def work(*args) # :nodoc:
+      semaphore.synchronize do
+        begin
+          atomic {
+            @value = yield(*args)
+            @state = :fulfilled
+          }
+        rescue Exception => ex
+          atomic {
+            @state = :rejected
+            @reason = ex
+          }
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/global_thread_pool.rb

@@ -1,3 +1,3 @@
-require 'concurrent/cached_thread_pool'
-
-$GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new
+require 'concurrent/cached_thread_pool'
+
+$GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new

data/lib/concurrent/goroutine.rb

@@ -1,25 +1,29 @@
-require 'thread'
-
-require 'concurrent/global_thread_pool'
-
-module Kernel
-
-  # Post the given agruments and block to the Global Thread Pool.
-  #
-  # @param args [Array] zero or more arguments for the block
-  # @param block [Proc] operation to be performed concurrently
-  #
-  # @return [true,false] success/failre of thread creation
-  #
-  # @note Althought based on Go's goroutines and Erlang's spawn/1,
-  # Ruby has a vastly different runtime. Threads aren't nearly as
-  # efficient in Ruby. Use this function appropriately.
-  #
-  # @see http://golang.org/doc/effective_go.html#goroutines
-  # @see https://gobyexample.com/goroutines
-  def go(*args, &block)
-    return false unless block_given?
-    $GLOBAL_THREAD_POOL.post(*args, &block)
-  end
-  module_function :go
-end
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+
+module Kernel
+
+  # Post the given agruments and block to the Global Thread Pool.
+  #
+  # @param args [Array] zero or more arguments for the block
+  # @param block [Proc] operation to be performed concurrently
+  #
+  # @return [true,false] success/failre of thread creation
+  #
+  # @note Althought based on Go's goroutines and Erlang's spawn/1,
+  # Ruby has a vastly different runtime. Threads aren't nearly as
+  # efficient in Ruby. Use this function appropriately.
+  #
+  # @see http://golang.org/doc/effective_go.html#goroutines
+  # @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
+  end
+  module_function :go
+end