concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/lib/concurrent/ruby_thread_pool_worker.rb

@@ -0,0 +1,69 @@
+require 'thread'
+
+module Concurrent
+
+  # @!visibility private
+  class RubyThreadPoolWorker # :nodoc:
+
+    # @!visibility private
+    def initialize(queue, parent) # :nodoc:
+      @queue = queue
+      @parent = parent
+      @mutex = Mutex.new
+      @last_activity = Time.now.to_f
+    end
+
+    # @!visibility private
+    def dead? # :nodoc:
+      return @mutex.synchronize do
+        @thread.nil? ? false : ! @thread.alive?
+      end
+    end
+
+    # @!visibility private
+    def last_activity # :nodoc:
+      @mutex.synchronize { @last_activity }
+    end
+
+    def status
+      @mutex.synchronize do
+        return 'not running' if @thread.nil?
+        @thread.status
+      end
+    end
+
+    # @!visibility private
+    def kill # :nodoc:
+      @mutex.synchronize do
+        Thread.kill(@thread) unless @thread.nil?
+        @thread = nil
+      end
+    end
+
+    # @!visibility private
+    def run(thread = Thread.current) # :nodoc:
+      @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
+
+        begin
+          task.last.call(*task.first)
+        rescue => ex
+          # let it fail
+        ensure
+          @last_activity = Time.now.to_f
+          @parent.on_end_task
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/simple_actor_ref.rb

@@ -0,0 +1,124 @@
+require 'thread'
+
+require 'concurrent/actor_ref'
+require 'concurrent/event'
+require 'concurrent/ivar'
+
+module Concurrent
+
+  class SimpleActorRef
+    include ActorRef
+
+    def initialize(actor, opts = {})
+      @actor = actor
+      @mutex = Mutex.new
+      @queue = Queue.new
+      @thread = nil
+      @stop_event = Event.new
+      @abort_on_exception = opts.fetch(:abort_on_exception, true)
+      @reset_on_error = opts.fetch(:reset_on_error, true)
+      @exception_class = opts.fetch(:rescue_exception, false) ? Exception : StandardError
+      @observers = CopyOnNotifyObserverSet.new
+
+      @actor.define_singleton_method(:shutdown, &method(:set_stop_event))
+    end
+
+    def running?
+      ! @stop_event.set?
+    end
+
+    def shutdown?
+      @stop_event.set?
+    end
+
+    def post(*msg, &block)
+      raise ArgumentError.new('message cannot be empty') if msg.empty?
+      @mutex.synchronize do
+        supervise unless shutdown?
+      end
+      ivar = IVar.new
+      @queue.push(Message.new(msg, ivar, block))
+      ivar
+    end
+
+    def post!(seconds, *msg)
+      raise Concurrent::TimeoutError if seconds == 0
+      ivar = self.post(*msg)
+      ivar.value(seconds)
+      if ivar.incomplete?
+        raise Concurrent::TimeoutError
+      elsif ivar.reason
+        raise ivar.reason
+      end
+      ivar.value
+    end
+
+    def shutdown
+      @mutex.synchronize do
+        return if shutdown?
+        if @thread && @thread.alive?
+          @thread.kill 
+          @actor.on_shutdown
+        end
+        @stop_event.set
+      end
+    end
+
+    def join(timeout = nil)
+      @stop_event.wait(timeout)
+    end
+
+    private
+
+    Message = Struct.new(:payload, :ivar, :callback)
+
+    def set_stop_event
+      @stop_event.set
+    end
+
+    def supervise
+      if @thread.nil?
+        @actor.on_start
+        @thread = new_worker_thread
+      elsif ! @thread.alive?
+        @actor.on_reset
+        @thread = new_worker_thread
+      end
+    end
+
+    def new_worker_thread
+      Thread.new do
+        Thread.current.abort_on_exception = @abort_on_exception
+        run_message_loop
+      end
+    end
+
+    def run_message_loop
+      loop do
+        message = @queue.pop
+        result = ex = nil
+
+        begin
+          result = @actor.receive(*message.payload)
+        rescue @exception_class => ex
+          @actor.on_error(Time.now, message.payload, ex)
+          @actor.on_reset if @reset_on_error
+        ensure
+          now = Time.now
+          message.ivar.complete(ex.nil?, result, ex)
+
+          begin
+            message.callback.call(now, result, ex) if message.callback
+          rescue @exception_class => ex
+            # suppress
+          end
+
+          observers.notify_observers(now, message.payload, result, ex)
+        end
+
+        break if @stop_event.set?
+      end
+      @actor.on_shutdown
+    end
+  end
+end

data/lib/concurrent/thread_local_var.rb

@@ -75,7 +75,7 @@ module Concurrent
 
     NIL_SENTINEL = Object.new
 
-    if defined? java.lang
+    if RUBY_PLATFORM == 'java'
       include ThreadLocalJavaStorage
     elsif Thread.current.respond_to?(:thread_variable_set)
       include ThreadLocalNewStorage

data/lib/concurrent/thread_pool_executor.rb

@@ -0,0 +1,30 @@
+require 'concurrent/ruby_thread_pool_executor'
+
+module Concurrent
+
+  if RUBY_PLATFORM == 'java'
+    require 'concurrent/java_thread_pool_executor'
+    # @!macro [attach] thread_pool_executor
+    #
+    #   A thread pool...
+    #
+    #   The API and behavior of this class are based on Java's +ThreadPoolExecutor+
+    #
+    #   @note When running on the JVM (JRuby) this class will inherit from +JavaThreadPoolExecutor+.
+    #     On all other platforms it will inherit from +RubyThreadPoolExecutor+.
+    #
+    #   @see Concurrent::RubyThreadPoolExecutor
+    #   @see Concurrent::JavaThreadPoolExecutor
+    #
+    #   @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html
+    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html
+    #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html
+    #   @see http://stackoverflow.com/questions/17957382/fixedthreadpool-vs-fixedthreadpool-the-lesser-of-two-evils
+    class ThreadPoolExecutor < JavaThreadPoolExecutor
+    end
+  else
+    # @!macro thread_pool_executor
+    class ThreadPoolExecutor < RubyThreadPoolExecutor
+    end
+  end
+end

data/lib/concurrent/timer_task.rb

@@ -9,9 +9,9 @@ require 'concurrent/utilities'
 module Concurrent
 
   # A very common currency pattern is to run a thread that performs a task at regular
-  # intervals. The thread that peforms the task sleeps for the given interval then
+  # intervals. The thread that performs the task sleeps for the given interval then
   # wakes up and performs the task. Lather, rinse, repeat... This pattern causes two
-  # problems. First, it is difficult to test the business logic of the task becuse the
+  # problems. First, it is difficult to test the business logic of the task because the
   # task itself is tightly coupled with the concurrency logic. Second, an exception in
   # raised while performing the task can cause the entire thread to abend. In a
   # long-running application where the task thread is intended to run for days/weeks/years
@@ -25,7 +25,7 @@ module Concurrent
   # performing logging or ancillary operations. +TimerTask+ can also be configured with a
   # timeout value allowing it to kill a task that runs too long.
   # 
-  # One other advantage of +TimerTask+ is it forces the bsiness logic to be completely decoupled
+  # One other advantage of +TimerTask+ is it forces the business logic to be completely decoupled
   # from the concurrency logic. The business logic can be tested separately then passed to the
   # +TimerTask+ for scheduling and running.
   # 
@@ -147,7 +147,6 @@ module Concurrent
     include Dereferenceable
     include Runnable
     include Stoppable
-    include Observable
 
     # Default +:execution_interval+
     EXECUTION_INTERVAL = 60
@@ -171,7 +170,7 @@ module Concurrent
     # @option opts [Integer] :timeout_interval number of seconds a task can
     #   run before it is considered to have failed (default: TIMEOUT_INTERVAL)
     # @option opts [Boolean] :run_now Whether to run the task immediately
-    #   upon instanciation or to wait until the first #execution_interval
+    #   upon instantiation or to wait until the first #execution_interval
     #   has passed (default: false)
     #
     # @raise ArgumentError when no block is given.
@@ -193,9 +192,10 @@ module Concurrent
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
       self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
-      @run_now = opts[:now] || opts[:run_now] || false
+      @run_now = opts[:now] || opts[:run_now]
 
       @task = block
+      @observers = CopyOnWriteObserverSet.new
       init_mutex
       set_deref_options(opts)
     end
@@ -226,6 +226,10 @@ module Concurrent
       @timeout_interval = value
     end
 
+    def add_observer(observer, func = :update)
+      @observers.add_observer(observer, func)
+    end
+
     # Terminate with extreme prejudice. Useful in cases where +#stop+ doesn't
     # work because one of the threads becomes unresponsive.
     #
@@ -278,11 +282,10 @@ module Concurrent
       end
       raise TimeoutError if @worker.join(@timeout_interval).nil?
       mutex.synchronize { @value = @worker[:result] }
-    rescue Exception => ex
-      # suppress
+    rescue Exception => e
+      ex = e
     ensure
-      changed
-      notify_observers(Time.now, self.value, ex)
+      @observers.notify_observers(Time.now, self.value, ex)
       unless @worker.nil?
         Thread.kill(@worker)
         @worker = nil

data/lib/concurrent/tvar.rb

@@ -0,0 +1,212 @@
+require 'set'
+
+require 'concurrent/thread_local_var'
+
+module Concurrent
+
+  ABORTED = Object.new
+
+  CURRENT_TRANSACTION = ThreadLocalVar.new(nil)
+
+  ReadLogEntry = Struct.new(:tvar, :version)
+  UndoLogEntry = Struct.new(:tvar, :value)
+
+  class TVar
+
+    def initialize(value)
+      @value = value
+      @version = 0
+      @lock = Mutex.new
+    end
+
+    def value
+      Concurrent::atomically do
+        Transaction::current.read(self)
+      end
+    end
+
+    def value=(value)
+      Concurrent::atomically do
+        Transaction::current.write(self, value)
+      end
+    end
+
+    def unsafe_value
+      @value
+    end
+
+    def unsafe_value=(value)
+      @value = value
+    end
+
+    def unsafe_version
+      @version
+    end
+
+    def unsafe_increment_version
+      @version += 1
+    end
+
+    def unsafe_lock
+      @lock
+    end
+
+  end
+
+  class Transaction
+
+    def initialize
+      @write_set = Set.new
+      @read_log = []
+      @undo_log = []
+    end
+
+    def read(tvar)
+      Concurrent::abort_transaction unless valid?
+      @read_log.push(ReadLogEntry.new(tvar, tvar.unsafe_version))
+      tvar.unsafe_value
+    end
+
+    def write(tvar, value)
+      # Have we already written to this TVar?
+
+      unless @write_set.include? tvar
+        # Try to lock the TVar
+
+        unless tvar.unsafe_lock.try_lock
+          # Someone else is writing to this TVar - abort
+          Concurrent::abort_transaction
+        end
+
+        # We've locked it - add it to the write set
+
+        @write_set.add(tvar)
+
+        # If we previously wrote to it, check the version hasn't changed
+
+        @read_log.each do |log_entry|
+          if log_entry.tvar == tvar and tvar.unsafe_version > log_entry.version
+            Concurrent::abort_transaction
+          end
+        end
+      end
+
+      # Record the current value of the TVar so we can undo it later
+
+      @undo_log.push(UndoLogEntry.new(tvar, tvar.unsafe_value))
+
+      # Write the new value to the TVar
+
+      tvar.unsafe_value = value
+    end
+
+    def abort
+      @undo_log.each do |entry|
+        entry.tvar.unsafe_value = entry.value
+      end
+
+      unlock
+    end
+
+    def commit
+      return false unless valid?
+
+      @write_set.each do |tvar|
+        tvar.unsafe_increment_version
+      end
+
+      unlock
+      
+      true
+    end
+
+    def valid?
+      @read_log.each do |log_entry|
+        unless @write_set.include? log_entry.tvar
+          if log_entry.tvar.unsafe_version > log_entry.version
+            return false
+          end
+        end
+      end
+
+      true
+    end
+
+    def unlock
+      @write_set.each do |tvar|
+        tvar.unsafe_lock.unlock
+      end
+    end
+
+    def self.current
+      CURRENT_TRANSACTION.value
+    end
+
+    def self.current=(transaction)
+      CURRENT_TRANSACTION.value = transaction
+    end
+
+  end
+
+  AbortError = Class.new(StandardError)
+
+  def atomically
+    raise ArgumentError.new('no block given') unless block_given?
+
+    # Get the current transaction
+
+    transaction = Transaction::current
+
+    # Are we not already in a transaction (not nested)?
+
+    if transaction.nil?
+      # New transaction
+
+      begin
+        # Retry loop
+        
+        loop do
+
+          # Create a new transaction
+
+          transaction = Transaction.new
+          Transaction::current = transaction
+
+          # Run the block, aborting on exceptions
+
+          begin
+            result = yield
+          rescue AbortError => e
+            transaction.abort
+            result = ABORTED
+          rescue => e
+            transaction.abort
+            throw e
+          end
+          # If we can commit, break out of the loop
+
+          if result != ABORTED
+            if transaction.commit
+              break result
+            end
+          end
+        end
+      ensure
+        # Clear the current transaction
+
+        Transaction::current = nil
+      end
+    else
+      # Nested transaction - flatten it and just run the block
+
+      yield
+    end
+  end
+
+  def abort_transaction
+    raise AbortError.new
+  end
+
+  module_function :atomically, :abort_transaction
+
+end