concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/lib/concurrent/safe_task_executor.rb

@@ -0,0 +1,28 @@
+module Concurrent
+
+  # A simple utility class that executes a callable and returns and array of three elements:
+  # success - indicating if the callable has been executed without errors
+  # value - filled by the callable result if it has been executed without errors, nil otherwise
+  # reason - the error risen by the callable if it has been executed with errors, nil otherwise
+  class SafeTaskExecutor
+    def initialize(task)
+      @task = task
+    end
+
+    # @return [Array]
+    def execute
+      success = false
+      value = reason = nil
+
+      begin
+        value = @task.call
+        success = true
+      rescue => ex
+        reason = ex
+        success = false
+      end
+
+      [success, value, reason]
+    end
+  end
+end

data/lib/concurrent/scheduled_task.rb

@@ -1,96 +1,102 @@
 require 'observer'
 require 'concurrent/obligation'
+require 'concurrent/safe_task_executor'
 
 module Concurrent
 
   class ScheduledTask
     include Obligation
-    include Observable
+
+    SchedulingError = Class.new(ArgumentError)
 
     attr_reader :schedule_time
 
     def initialize(schedule_time, opts = {}, &block)
-      now = Time.now
-
-      if ! block_given?
-        raise ArgumentError.new('no block given')
-      elsif schedule_time.is_a?(Time)
-        if schedule_time <= now
-          raise ArgumentError.new('schedule time must be in the future') 
-        else
-          @schedule_time = schedule_time.dup
-        end
-      elsif schedule_time.to_f <= 0.0
-        raise ArgumentError.new('seconds must be greater than zero')
-      else
-        @schedule_time = now + schedule_time.to_f
-      end
+      raise SchedulingError.new('no block given') unless block_given?
+      calculate_schedule_time!(schedule_time) # raise exception if in past
 
-      @state = :pending
-      @schedule_time.freeze
+      init_obligation
+      @observers = CopyOnWriteObserverSet.new
+      @state = :unscheduled
+      @intended_schedule_time = schedule_time
+      @schedule_time = nil
       @task = block
-      init_mutex
       set_deref_options(opts)
+    end
 
-      @thread = Thread.new{ work }
-      @thread.abort_on_exception = false
+    # @since 0.5.0
+    def execute
+      if compare_and_set_state(:pending, :unscheduled)
+        @schedule_time = calculate_schedule_time!(@intended_schedule_time).freeze
+        Thread.new { work }
+        self
+      end
+    end
+
+    # @since 0.5.0
+    def self.execute(schedule_time, opts = {}, &block)
+      return ScheduledTask.new(schedule_time, opts, &block).execute
     end
 
     def cancelled?
-      return @state == :cancelled
+      state == :cancelled
     end
 
     def in_progress?
-      return @state == :in_progress
+      state == :in_progress
     end
 
     def cancel
-      return false if mutex.locked?
-      return mutex.synchronize do
-        if @state == :pending
-          @state = :cancelled
-          event.set
-          true
-        else
-          false
-        end
+      if_state(:unscheduled, :pending) do
+        @state = :cancelled
+        event.set
+        true
       end
     end
+
     alias_method :stop, :cancel
 
     def add_observer(observer, func = :update)
-      return false unless [:pending, :in_progress].include?(@state)
-      super
+      if_state(:unscheduled, :pending, :in_progress) do
+        @observers.add_observer(observer, func)
+      end
     end
 
     protected
 
     def work
-      while (diff = @schedule_time.to_f - Time.now.to_f) > 0
-        sleep( diff > 60 ? 60 : diff )
-      end
-      
-      if @state == :pending
+      sleep_until_scheduled_time
+
+      if compare_and_set_state(:in_progress, :pending)
+        success, val, reason = SafeTaskExecutor.new(@task).execute
+
         mutex.synchronize do
-          @state = :in_progress
-          begin
-            @value = @task.call
-            @state = :fulfilled
-          rescue => ex
-            @reason = ex
-            @state = :rejected
-          ensure
-            changed
-          end
+          set_state(success, val, reason)
+          event.set
         end
+
+        time = Time.now
+        @observers.notify_and_delete_observers{ [time, self.value, reason] }
       end
 
-      if self.changed?
-        notify_observers(Time.now, self.value, @reason)
-        delete_observers
+    end
+
+    private
+
+    def sleep_until_scheduled_time
+      while (diff = @schedule_time.to_f - Time.now.to_f) > 0
+        sleep(diff > 60 ? 60 : diff)
+      end
+    end
+
+    def calculate_schedule_time!(schedule_time, now = Time.now)
+      if schedule_time.is_a?(Time)
+        raise SchedulingError.new('schedule time must be in the future') if schedule_time <= now
+        schedule_time.dup
+      else
+        raise SchedulingError.new('seconds must be greater than zero') if schedule_time.to_f <= 0.0
+        now + schedule_time.to_f
       end
-      event.set
-      self.stop
     end
   end
 end

data/lib/concurrent/stoppable.rb

@@ -8,13 +8,13 @@ module Concurrent
       raise ArgumentError.new('no block given') unless block_given?
       raise Runnable::LifecycleError.new('#before_stop already set') if @before_stop_proc
       @before_stop_proc = block
-      return self
+      self
     end
 
     protected
 
     def before_stop_proc
-      return @before_stop_proc
+      @before_stop_proc
     end
   end
 end

data/lib/concurrent/supervisor.rb

@@ -20,10 +20,12 @@ module Concurrent
     WorkerContext = Struct.new(:worker, :type, :restart) do
       attr_accessor :thread
       attr_accessor :terminated
+
       def alive?() return thread && thread.alive?; end
+
       def needs_restart?
         return false if thread && thread.alive?
-        return false if terminated == true
+        return false if terminated
         case self.restart
         when :permanent
           return true
@@ -42,12 +44,12 @@ module Concurrent
         self.supervisors += 1 if context.type == :supervisor
         self.workers += 1 if context.type == :worker
       end
-      def active() sleeping + running + aborting end;
-      def sleeping() @status.reduce(0){|x, s| x += (s == 'sleep' ? 1 : 0) } end;
-      def running() @status.reduce(0){|x, s| x += (s == 'run' ? 1 : 0) } end;
-      def aborting() @status.reduce(0){|x, s| x += (s == 'aborting' ? 1 : 0) } end;
-      def stopped() @status.reduce(0){|x, s| x += (s == false ? 1 : 0) } end;
-      def abend() @status.reduce(0){|x, s| x += (s.nil? ? 1 : 0) } end;
+      def active() sleeping + running + aborting end
+      def sleeping() @status.reduce(0){|x, s| x += (s == 'sleep' ? 1 : 0) } end
+      def running() @status.reduce(0){|x, s| x += (s == 'run' ? 1 : 0) } end
+      def aborting() @status.reduce(0){|x, s| x += (s == 'aborting' ? 1 : 0) } end
+      def stopped() @status.reduce(0){|x, s| x += (s == false ? 1 : 0) } end
+      def abend() @status.reduce(0){|x, s| x += (s.nil? ? 1 : 0) } end
     end
 
     attr_reader :monitor_interval
@@ -100,12 +102,13 @@ module Concurrent
         @running = true
       end
       monitor
-      return true
+      true
     end
 
     def stop
-      return true unless @running
       @mutex.synchronize do
+        return true unless @running
+
         @running = false
         unless @monitor.nil?
           @monitor.run if @monitor.status == 'sleep'
@@ -122,24 +125,25 @@ module Concurrent
         end
         prune_workers
       end
-      return true
+
+      true
     end
 
     def running?
-      return @running == true
+      @mutex.synchronize { @running }
     end
 
     def length
-      return @workers.length
+      @mutex.synchronize { @workers.length }
     end
     alias_method :size, :length
 
     def current_restart_count
-      return @restart_times.length
+      @restart_times.length
     end
 
     def count
-      return @mutex.synchronize do
+      @mutex.synchronize do
         @count.status = @workers.collect{|w| w.thread ? w.thread.status : false }
         @count.dup.freeze
       end
@@ -147,7 +151,7 @@ module Concurrent
 
     def add_worker(worker, opts = {})
       return nil if worker.nil? || ! behaves_as_worker?(worker)
-      return @mutex.synchronize {
+      @mutex.synchronize {
         restart = opts[:restart] || :permanent
         type = opts[:type] || (worker.is_a?(Supervisor) ? :supervisor : nil) || :worker
         raise ArgumentError.new(":#{restart} is not a valid restart option") unless CHILD_RESTART_OPTIONS.include?(restart)
@@ -155,21 +159,21 @@ module Concurrent
         context = WorkerContext.new(worker, type, restart)
         @workers << context
         @count.add(context)
-        worker.run if running?
+        worker.run if @running
         context.object_id
       }
     end
     alias_method :add_child, :add_worker
 
     def add_workers(workers, opts = {})
-      return workers.collect do |worker|
+      workers.collect do |worker|
         add_worker(worker, opts)
       end
     end
     alias_method :add_children, :add_workers
 
     def remove_worker(worker_id)
-      return @mutex.synchronize do
+      @mutex.synchronize do
         index, context = find_worker(worker_id)
         break(nil) if context.nil?
         break(false) if context.alive?
@@ -180,8 +184,9 @@ module Concurrent
     alias_method :remove_child, :remove_worker
 
     def stop_worker(worker_id)
-      return true unless running?
-      return @mutex.synchronize do
+      @mutex.synchronize do
+        return true unless @running
+
         index, context = find_worker(worker_id)
         break(nil) if index.nil?
         context.terminated = true
@@ -193,8 +198,9 @@ module Concurrent
     alias_method :stop_child, :stop_worker
 
     def start_worker(worker_id)
-      return false unless running?
-      return @mutex.synchronize do
+      @mutex.synchronize do
+        return false unless @running
+
         index, context = find_worker(worker_id)
         break(nil) if context.nil?
         context.terminated = false
@@ -205,8 +211,9 @@ module Concurrent
     alias_method :start_child, :start_worker
 
     def restart_worker(worker_id)
-      return false unless running?
-      return @mutex.synchronize do
+      @mutex.synchronize do
+        return false unless @running
+
         index, context = find_worker(worker_id)
         break(nil) if context.nil?
         break(false) if context.restart == :temporary
@@ -221,7 +228,7 @@ module Concurrent
     private
 
     def behaves_as_worker?(obj)
-      return WORKER_API.each do |method, arity|
+      WORKER_API.each do |method, arity|
         break(false) unless obj.respond_to?(method) && obj.method(method).arity == arity
         true
       end
@@ -247,7 +254,7 @@ module Concurrent
         Thread.current.abort_on_exception = false
         context.worker.run
       end
-      return context
+      context
     end
 
     def terminate_worker(context)
@@ -272,9 +279,9 @@ module Concurrent
     def find_worker(worker_id)
       index = @workers.find_index{|worker| worker.object_id == worker_id}
       if index.nil?
-        return [nil, nil]
+        [nil, nil]
       else
-        return [index, @workers[index]]
+        [index, @workers[index]]
       end
     end
 
@@ -286,7 +293,7 @@ module Concurrent
       elsif diff >= @max_time
         @restart_times.pop
       end
-      return false
+      false
     end
 
     #----------------------------------------------------------------

data/lib/concurrent/thread_local_var.rb

@@ -0,0 +1,117 @@
+module Concurrent
+
+  module ThreadLocalSymbolAllocator
+
+    COUNTER = AtomicFixnum.new
+
+    protected
+
+    def allocate_symbol
+      # Warning: this symbol may never be deallocated
+      @symbol = :"thread_local_symbol_#{COUNTER.increment}"
+    end
+
+  end
+
+  module ThreadLocalOldStorage
+
+    include ThreadLocalSymbolAllocator
+
+    protected
+
+    def allocate_storage
+      allocate_symbol
+    end
+
+    def get
+      Thread.current[@symbol]
+    end
+
+    def set(value)
+      Thread.current[@symbol] = value
+    end
+
+  end
+
+  module ThreadLocalNewStorage
+
+    include ThreadLocalSymbolAllocator
+
+    protected
+
+    def allocate_storage
+      allocate_symbol
+    end
+
+    def get
+      Thread.current.thread_variable_get(@symbol)
+    end
+
+    def set(value)
+      Thread.current.thread_variable_set(@symbol, value)
+    end
+
+  end
+
+  module ThreadLocalJavaStorage
+
+    protected
+
+    def allocate_storage
+      @var = java.lang.ThreadLocal.new
+    end
+
+    def get
+      @var.get
+    end
+
+    def set(value)
+      @var.set(value)
+    end
+
+  end
+
+  class ThreadLocalVar
+
+    NIL_SENTINEL = Object.new
+
+    if defined? java.lang
+      include ThreadLocalJavaStorage
+    elsif Thread.current.respond_to?(:thread_variable_set)
+      include ThreadLocalNewStorage
+    else
+      include ThreadLocalOldStorage
+    end
+
+    def initialize(default = nil)
+      @default = default
+      allocate_storage
+    end
+
+    def value
+      value = get
+
+      if value.nil?
+        @default
+      elsif value == NIL_SENTINEL
+        nil
+      else
+        value
+      end
+    end
+
+    def value=(value)
+      if value.nil?
+        stored_value = NIL_SENTINEL
+      else
+        stored_value = value
+      end
+
+      set stored_value
+
+      value
+    end
+
+  end
+
+end