concurrent-ruby 0.8.0.pre2-java → 0.9.0-java

data/lib/concurrent/scheduled_task.rb

@@ -1,79 +1,377 @@
+require 'concurrent/errors'
 require 'concurrent/ivar'
-require 'concurrent/utility/timer'
-require 'concurrent/executor/safe_task_executor'
+require 'concurrent/configuration'
+require 'concurrent/collection/copy_on_notify_observer_set'
+require 'concurrent/executor/executor'
+require 'concurrent/executor/timer_set'
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/concern/deprecation'
 
 module Concurrent
+  include Concern::Deprecation
 
-  # {include:file:doc/scheduled_task.md}
+  # `ScheduledTask` is a close relative of `Concurrent::Future` but with one
+  # important difference: A `Future` is set to execute as soon as possible
+  # whereas a `ScheduledTask` is set to execute after a specified delay. This
+  # implementation is loosely based on Java's
+  # [ScheduledExecutorService](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ScheduledExecutorService.html).
+  # It is a more feature-rich variant of {Concurrent.timer}.
+  #
+  # The *intended* schedule time of task execution is set on object construction
+  # with the `delay` argument. The delay is a numeric (floating point or integer)
+  # representing a number of seconds in the future. Any other value or a numeric
+  # equal to or less than zero will result in an exception. The *actual* schedule
+  # time of task execution is set when the `execute` method is called.
+  #
+  # The constructor can also be given zero or more processing options. Currently
+  # the only supported options are those recognized by the
+  # [Dereferenceable](Dereferenceable) module.
+  #
+  # The final constructor argument is a block representing the task to be performed.
+  # If no block is given an `ArgumentError` will be raised.
+  #
+  # **States**
+  #
+  # `ScheduledTask` mixes in the  [Obligation](Obligation) module thus giving it
+  # "future" behavior. This includes the expected lifecycle states. `ScheduledTask`
+  # has one additional state, however. While the task (block) is being executed the
+  # state of the object will be `:processing`. This additional state is necessary
+  # because it has implications for task cancellation.
+  #
+  # **Cancellation**
+  #
+  # A `:pending` task can be cancelled using the `#cancel` method. A task in any
+  # other state, including `:processing`, cannot be cancelled. The `#cancel`
+  # method returns a boolean indicating the success of the cancellation attempt.
+  # A cancelled `ScheduledTask` cannot be restarted. It is immutable.
+  #
+  # **Obligation and Observation**
+  #
+  # The result of a `ScheduledTask` can be obtained either synchronously or
+  # asynchronously. `ScheduledTask` mixes in both the [Obligation](Obligation)
+  # module and the
+  # [Observable](http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html)
+  # module from the Ruby standard library. With one exception `ScheduledTask`
+  # behaves identically to [Future](Observable) with regard to these modules.
+  #
+  # @!macro copy_options
+  #
+  # @example Basic usage
+  #
+  #   require 'concurrent'
+  #   require 'thread'   # for Queue
+  #   require 'open-uri' # for open(uri)
+  #
+  #   class Ticker
+  #     def get_year_end_closing(symbol, year)
+  #       uri = "http://ichart.finance.yahoo.com/table.csv?s=#{symbol}&a=11&b=01&c=#{year}&d=11&e=31&f=#{year}&g=m"
+  #       data = open(uri) {|f| f.collect{|line| line.strip } }
+  #       data[1].split(',')[4].to_f
+  #     end
+  #   end
+  #
+  #   # Future
+  #   price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013) }
+  #   price.state #=> :pending
+  #   sleep(1)    # do other stuff
+  #   price.value #=> 63.65
+  #   price.state #=> :fulfilled
+  #
+  #   # ScheduledTask
+  #   task = Concurrent::ScheduledTask.execute(2){ Ticker.new.get_year_end_closing('INTC', 2013) }
+  #   task.state #=> :pending
+  #   sleep(3)   # do other stuff
+  #   task.value #=> 25.96
+  #
+  # @example Successful task execution
+  #
+  #   task = Concurrent::ScheduledTask.new(2){ 'What does the fox say?' }
+  #   task.state         #=> :unscheduled
+  #   task.execute
+  #   task.state         #=> pending
+  #
+  #   # wait for it...
+  #   sleep(3)
+  #
+  #   task.unscheduled? #=> false
+  #   task.pending?     #=> false
+  #   task.fulfilled?   #=> true
+  #   task.rejected?    #=> false
+  #   task.value        #=> 'What does the fox say?'
+  #
+  # @example One line creation and execution
+  #
+  #   task = Concurrent::ScheduledTask.new(2){ 'What does the fox say?' }.execute
+  #   task.state         #=> pending
+  #
+  #   task = Concurrent::ScheduledTask.execute(2){ 'What do you get when you multiply 6 by 9?' }
+  #   task.state         #=> pending
+  #
+  # @example Failed task execution
+  #
+  #   task = Concurrent::ScheduledTask.execute(2){ raise StandardError.new('Call me maybe?') }
+  #   task.pending?      #=> true
+  #
+  #   # wait for it...
+  #   sleep(3)
+  #
+  #   task.unscheduled? #=> false
+  #   task.pending?     #=> false
+  #   task.fulfilled?   #=> false
+  #   task.rejected?    #=> true
+  #   task.value        #=> nil
+  #   task.reason       #=> #<StandardError: Call me maybe?>
+  #
+  # @example Task execution with observation
+  #
+  #   observer = Class.new{
+  #     def update(time, value, reason)
+  #       puts "The task completed at #{time} with value '#{value}'"
+  #     end
+  #   }.new
+  #
+  #   task = Concurrent::ScheduledTask.new(2){ 'What does the fox say?' }
+  #   task.add_observer(observer)
+  #   task.execute
+  #   task.pending?      #=> true
+  #
+  #   # wait for it...
+  #   sleep(3)
+  #
+  #   #>> The task completed at 2013-11-07 12:26:09 -0500 with value 'What does the fox say?'
+  #
+  # @!macro monotonic_clock_warning
+  #
+  # @see Concurrent.timer
   class ScheduledTask < IVar
+    include Comparable
 
-    attr_reader :schedule_time
+    # The executor on which to execute the task.
+    # @!visibility private
+    attr_reader :executor
 
-    def initialize(intended_time, opts = {}, &block)
+    # Schedule a task for execution at a specified future time.
+    #
+    # @param [Float] delay the number of seconds to wait for before executing the task
+    #
+    # @yield the task to be performed
+    #
+    # @!macro executor_and_deref_options
+    #
+    # @option opts [object, Array] :args zero or more arguments to be passed the task
+    #   block on execution
+    #
+    # @raise [ArgumentError] When no block is given
+    # @raise [ArgumentError] When given a time that is in the past
+    #
+    # @!macro [attach] deprecated_scheduling_by_clock_time
+    #
+    #   @note Scheduling is now based on a monotonic clock. This makes the timer much
+    #     more accurate, but only when scheduling based on a delay interval.
+    #     Scheduling a task based on a clock time is deprecated. It will still work
+    #     but will not be supported in the 1.0 release.
+    def initialize(delay, opts = {}, &task)
       raise ArgumentError.new('no block given') unless block_given?
-      TimerSet.calculate_schedule_time(intended_time) # raises exceptons
+      super(IVar::NO_VALUE, opts, &nil)
+      synchronize do
+        @delay = calculate_delay!(delay) # may raise exception
+        ns_set_state(:unscheduled)
+        @parent = opts.fetch(:timer_set, Concurrent.global_timer_set)
+        @args = get_arguments_from(opts)
+        @task = task
+        @time = nil
+        @executor = Executor.executor_from_options(opts) || Concurrent.global_io_executor
+        self.observers = Collection::CopyOnNotifyObserverSet.new
+      end
+    end
 
-      super(NO_VALUE, opts)
+    # The `delay` value given at instanciation.
+    #
+    # @return [Float] the initial delay.
+    def initial_delay
+      synchronize { @delay }
+    end
 
-      self.observers = CopyOnNotifyObserverSet.new
-      @intended_time = intended_time
-      @state         = :unscheduled
-      @task          = block
-      @executor      = OptionsParser::get_executor_from(opts) || Concurrent.configuration.global_operation_pool
+    # The `delay` value given at instanciation.
+    #
+    # @return [Float] the initial delay.
+    #
+    # @deprecated use {#initial_delay} instead
+    def delay
+      deprecated_method 'delay', 'initial_delay'
+      initial_delay
     end
 
-    # @since 0.5.0
-    def execute
-      if compare_and_set_state(:pending, :unscheduled)
-        @schedule_time = TimerSet.calculate_schedule_time(@intended_time)
-        Concurrent::timer(@schedule_time.to_f - Time.now.to_f) { @executor.post(&method(:process_task)) }
-        self
-      end
+    # The monotonic time at which the the task is scheduled to be executed.
+    #
+    # @return [Float] the schedule time or nil if `unscheduled`
+    def schedule_time
+      synchronize { @time }
     end
 
-    # @since 0.5.0
-    def self.execute(intended_time, opts = {}, &block)
-      return ScheduledTask.new(intended_time, opts, &block).execute
+    # Comparator which orders by schedule time.
+    #
+    # @!visibility private
+    def <=>(other)
+      schedule_time <=> other.schedule_time
     end
 
+    # Has the task been cancelled?
+    #
+    # @return [Boolean] true if the task is in the given state else false
     def cancelled?
-      state == :cancelled
+      synchronize { ns_check_state?(:cancelled) }
     end
 
+    # In the task execution in progress?
+    #
+    # @return [Boolean] true if the task is in the given state else false
+    def processing?
+      synchronize { ns_check_state?(:processing) }
+    end
+
+    # In the task execution in progress?
+    #
+    # @return [Boolean] true if the task is in the given state else false
+    #
+    # @deprecated Use {#processing?} instead.
     def in_progress?
-      state == :in_progress
+      deprecated_method 'in_progress?', 'processing?'
+      processing?
     end
 
+    # Cancel this task and prevent it from executing. A task can only be
+    # cancelled if it is pending or unscheduled.
+    #
+    # @return [Boolean] true if successfully cancelled else false
     def cancel
-      if_state(:unscheduled, :pending) do
-        @state = :cancelled
-        event.set
-        true
+      if compare_and_set_state(:cancelled, :pending, :unscheduled)
+        complete(false, nil, CancelledOperationError.new)
+        # To avoid deadlocks this call must occur outside of #synchronize
+        # Changing the state above should prevent redundant calls
+        @parent.send(:remove_task, self)
+      else
+        false
       end
     end
-    alias_method :stop, :cancel
 
-    def add_observer(*args, &block)
-      if_state(:unscheduled, :pending, :in_progress) do
-        observers.add_observer(*args, &block)
-      end
+    # Cancel this task and prevent it from executing. A task can only be
+    # cancelled if it is `:pending` or `:unscheduled`.
+    #
+    # @return [Boolean] true if successfully cancelled else false
+    #
+    # @deprecated Use {#cancel} instead.
+    def stop
+      deprecated_method 'stop', 'cancel'
+      cancel
+    end
+
+    # Reschedule the task using the original delay and the current time.
+    # A task can only be reset while it is `:pending`.
+    #
+    # @return [Boolean] true if successfully rescheduled else false
+    def reset
+      synchronize{ ns_reschedule(@delay) }
+    end
+
+    # Reschedule the task using the given delay and the current time.
+    # A task can only be reset while it is `:pending`.
+    #
+    # @param [Float] delay the number of seconds to wait for before executing the task
+    #
+    # @return [Boolean] true if successfully rescheduled else false
+    #
+    # @raise [ArgumentError] When given a time that is in the past
+    def reschedule(delay)
+      synchronize{ ns_reschedule(calculate_delay!(delay)) }
     end
 
-    protected :set, :fail, :complete
+    # Execute an `:unscheduled` `ScheduledTask`. Immediately sets the state to `:pending`
+    # and starts counting down toward execution. Does nothing if the `ScheduledTask` is
+    # in any state other than `:unscheduled`.
+    #
+    # @return [ScheduledTask] a reference to `self`
+    def execute
+      if compare_and_set_state(:pending, :unscheduled)
+        synchronize{ ns_schedule(@delay) }
+      end
+      self
+    end
 
-    private
+    # Create a new `ScheduledTask` object with the given block, execute it, and return the
+    # `:pending` object.
+    #
+    # @param [Float] delay the number of seconds to wait for before executing the task
+    #
+    # @!macro executor_and_deref_options
+    #
+    # @return [ScheduledTask] the newly created `ScheduledTask` in the `:pending` state
+    #
+    # @raise [ArgumentError] if no block is given
+    #
+    # @!macro deprecated_scheduling_by_clock_time
+    def self.execute(delay, opts = {}, &task)
+      new(delay, opts, &task).execute
+    end
 
+    # Execute the task.
+    #
+    # @!visibility private
     def process_task
-      if compare_and_set_state(:in_progress, :pending)
-        success, val, reason = SafeTaskExecutor.new(@task).execute
+      safe_execute(@task, @args)
+    end
+
+    protected :set, :try_set, :fail, :complete
+
+    protected
 
-        mutex.synchronize do
-          set_state(success, val, reason)
-          event.set
-        end
+    # Schedule the task using the given delay and the current time.
+    #
+    # @param [Float] delay the number of seconds to wait for before executing the task
+    #
+    # @return [Boolean] true if successfully rescheduled else false
+    #
+    # @!visibility private
+    def ns_schedule(delay)
+      @delay = delay
+      @time = Concurrent.monotonic_time + @delay
+      @parent.send(:post_task, self)
+    end
+
+    # Reschedule the task using the given delay and the current time.
+    # A task can only be reset while it is `:pending`.
+    #
+    # @param [Float] delay the number of seconds to wait for before executing the task
+    #
+    # @return [Boolean] true if successfully rescheduled else false
+    #
+    # @!visibility private
+    def ns_reschedule(delay)
+      return false unless ns_check_state?(:pending)
+      @parent.send(:remove_task, self) && ns_schedule(delay)
+    end
 
-        time = Time.now
-        observers.notify_and_delete_observers { [time, self.value, reason] }
+    # Calculate the actual delay in seconds based on the given delay.
+    #
+    # @param [Float] delay the number of seconds to wait for before executing the task
+    #
+    # @return [Float] the number of seconds to delay
+    #
+    # @raise [ArgumentError] if the intended execution time is not in the future
+    # @raise [ArgumentError] if no block is given
+    #
+    # @!macro deprecated_scheduling_by_clock_time
+    #
+    # @!visibility private
+    def calculate_delay!(delay)
+      if delay.is_a?(Time)
+        deprecated 'Use an interval not a clock time; schedule is now based on a monotonic clock'
+        now = Time.now
+        raise ArgumentError.new('schedule time must be in the future') if delay <= now
+        delay.to_f - now.to_f
+      else
+        raise ArgumentError.new('seconds must be greater than zero') if delay.to_f < 0.0
+        delay.to_f
       end
     end
   end

data/lib/concurrent/settable_struct.rb

@@ -0,0 +1,127 @@
+require 'concurrent/synchronization/abstract_struct'
+require 'concurrent/errors'
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  # An thread-safe, write-once variation of Ruby's standard `Struct`.
+  # Each member can have its value set at most once, either at construction
+  # or any time thereafter. Attempting to assign a value to a member
+  # that has already been set will result in a `Concurrent::ImmutabilityError`.
+  #
+  # @see http://ruby-doc.org/core-2.2.0/Struct.html Ruby standard library `Struct`
+  # @see http://en.wikipedia.org/wiki/Final_(Java) Java `final` keyword
+  module SettableStruct
+    include Synchronization::AbstractStruct
+
+    # @!macro struct_values
+    def values
+      synchronize { ns_values }
+    end
+    alias_method :to_a, :values
+
+    # @!macro struct_values_at
+    def values_at(*indexes)
+      synchronize { ns_values_at(indexes) }
+    end
+
+    # @!macro struct_inspect
+    def inspect
+      synchronize { ns_inspect }
+    end
+    alias_method :to_s, :inspect
+
+    # @!macro struct_merge
+    def merge(other, &block)
+      synchronize { ns_merge(other, &block) }
+    end
+
+    # @!macro struct_to_h
+    def to_h
+      synchronize { ns_to_h }
+    end
+
+    # @!macro struct_get
+    def [](member)
+      synchronize { ns_get(member) }
+    end
+
+    # @!macro struct_equality
+    def ==(other)
+      synchronize { ns_equality(other) }
+    end
+
+    # @!macro struct_each
+    def each(&block)
+      return enum_for(:each) unless block_given?
+      synchronize { ns_each(&block) }
+    end
+
+    # @!macro struct_each_pair
+    def each_pair(&block)
+      return enum_for(:each_pair) unless block_given?
+      synchronize { ns_each_pair(&block) }
+    end
+
+    # @!macro struct_select
+    def select(&block)
+      return enum_for(:select) unless block_given?
+      synchronize { ns_select(&block) }
+    end
+
+    # @!macro struct_set
+    #
+    # @raise [Concurrent::ImmutabilityError] if the given member has already been set
+    def []=(member, value)
+      if member.is_a? Integer
+        if member >= @values.length
+          raise IndexError.new("offset #{member} too large for struct(size:#{@values.length})")
+        end
+        synchronize do
+          unless @values[member].nil?
+            raise Concurrent::ImmutabilityError.new('struct member has already been set')
+          end
+          @values[member] = value
+        end
+      else
+        send("#{member}=", value)
+      end
+    rescue NoMethodError
+      raise NameError.new("no member '#{member}' in struct")
+    end
+
+    # @!macro struct_new
+    def self.new(*args, &block)
+      clazz_name = nil
+      if args.length == 0
+        raise ArgumentError.new('wrong number of arguments (0 for 1+)')
+      elsif args.length > 0 && args.first.is_a?(String)
+        clazz_name = args.shift
+      end
+      FACTORY.define_struct(clazz_name, args, &block)
+    end
+
+    FACTORY = Class.new(Synchronization::Object) do
+      def define_struct(name, members, &block)
+        synchronize do
+          clazz = Synchronization::AbstractStruct.define_struct_class(SettableStruct, Synchronization::Object, name, members, &block)
+          members.each_with_index do |member, index|
+            clazz.send(:define_method, member) do
+              synchronize { @values[index] }
+            end
+            clazz.send(:define_method, "#{member}=") do |value|
+              synchronize do
+                unless @values[index].nil?
+                  raise Concurrent::ImmutabilityError.new('struct member has already been set')
+                end
+                @values[index] = value
+              end
+            end
+          end
+          clazz
+        end
+      end
+    end.new
+    private_constant :FACTORY
+  end
+end