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

data/lib/concurrent/ivar.rb

@@ -1,7 +1,7 @@
 require 'thread'
 
 require 'concurrent/obligation'
-require 'concurrent/copy_on_write_observer_set'
+require 'concurrent/observable'
 
 module Concurrent
 
@@ -9,20 +9,21 @@ module Concurrent
 
   class IVar
     include Obligation
+    include Concurrent::Observable
 
     NO_VALUE = Object.new
 
-    # Create a new +Ivar+ in the +:pending+ state with the (optional) initial value.
+    # Create a new `Ivar` in the `:pending` state with the (optional) initial value.
     #
     # @param [Object] value the initial value
     # @param [Hash] opts the options to create a message with
-    # @option opts [String] :dup_on_deref (false) call +#dup+ before returning the data
-    # @option opts [String] :freeze_on_deref (false) call +#freeze+ before returning the data
-    # @option opts [String] :copy_on_deref (nil) call the given +Proc+ passing the internal value and
+    # @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
+    # @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
+    # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
     #   returning the value returned from the proc
     def initialize(value = NO_VALUE, opts = {})
       init_obligation
-      @observers = CopyOnWriteObserverSet.new
+      self.observers = CopyOnWriteObserverSet.new
       set_deref_options(opts)
 
       if value == NO_VALUE
@@ -34,26 +35,32 @@ module Concurrent
 
     # Add an observer on this object that will receive notification on update.
     #
-    # Upon completion the +IVar+ will notify all observers in a thread-say way. The +func+
-    # method of the observer will be called with three arguments: the +Time+ at which the
-    # +Future+ completed the asynchronous operation, the final +value+ (or +nil+ on rejection),
-    # and the final +reason+ (or +nil+ on fulfillment).
+    # Upon completion the `IVar` will notify all observers in a thread-say way. The `func`
+    # method of the observer will be called with three arguments: the `Time` at which the
+    # `Future` completed the asynchronous operation, the final `value` (or `nil` on rejection),
+    # and the final `reason` (or `nil` on fulfillment).
     #
     # @param [Object] observer the object that will be notified of changes
-    # @param [Symbol] func symbol naming the method to call when this +Observable+ has changes`
-    def add_observer(observer, func = :update)
+    # @param [Symbol] func symbol naming the method to call when this `Observable` has changes`
+    def add_observer(observer = nil, func = :update, &block)
+      raise ArgumentError.new('cannot provide both an observer and a block') if observer && block
       direct_notification = false
 
+      if block
+        observer = block
+        func = :call
+      end
+
       mutex.synchronize do
         if event.set?
           direct_notification = true
         else
-          @observers.add_observer(observer, func)
+          observers.add_observer(observer, func)
         end
       end
 
       observer.send(func, Time.now, self.value, reason) if direct_notification
-      func
+      observer
     end
 
     def set(value)
@@ -72,7 +79,7 @@ module Concurrent
       end
 
       time = Time.now
-      @observers.notify_and_delete_observers{ [time, self.value, reason] }
+      observers.notify_and_delete_observers{ [time, self.value, reason] }
       self
     end
   end

data/lib/concurrent/mvar.rb

@@ -1,5 +1,6 @@
 require 'concurrent/dereferenceable'
-require 'concurrent/event'
+require 'concurrent/atomic/condition'
+require 'concurrent/atomic/event'
 
 module Concurrent
 

data/lib/concurrent/obligation.rb

@@ -2,7 +2,7 @@ require 'thread'
 require 'timeout'
 
 require 'concurrent/dereferenceable'
-require 'concurrent/event'
+require 'concurrent/atomic/event'
 
 module Concurrent
 
@@ -48,11 +48,17 @@ module Concurrent
     end
 
     def state
-      mutex.synchronize { @state }
+      mutex.lock
+      result = @state
+      mutex.unlock
+      result
     end
 
     def reason
-      mutex.synchronize { @reason }
+      mutex.lock
+      result = @reason
+      mutex.unlock
+      result
     end
 
     protected

data/lib/concurrent/observable.rb

@@ -0,0 +1,33 @@
+require 'concurrent/atomic/copy_on_notify_observer_set'
+require 'concurrent/atomic/copy_on_write_observer_set'
+
+module Concurrent
+
+  module Observable
+
+    # @return [Object] the added observer
+    def add_observer(*args, &block)
+      observers.add_observer(*args, &block)
+    end
+
+    # @return [Object] the deleted observer
+    def delete_observer(*args)
+      observers.delete_observer(*args)
+    end
+
+    # @return [Observable] self
+    def delete_observers
+      observers.delete_observers
+      self
+    end
+
+    # @return [Integer] the observers count
+    def count_observers
+      observers.count_observers
+    end
+
+    protected
+
+    attr_accessor :observers
+  end
+end

data/lib/concurrent/options_parser.rb

@@ -0,0 +1,46 @@
+module Concurrent
+
+  # A mixin module for parsing options hashes related to gem-level configuration.
+  module OptionsParser
+
+    # Get the requested `Executor` based on the values set in the options hash.
+    #
+    # @param [Hash] opts the options defining the requested executor
+    # @option opts [Executor] :executor (`nil`) when set use the given `Executor` instance
+    # @option opts [Boolean] :operation (`false`) when true use the global operation pool
+    # @option opts [Boolean] :task (`true`) when true use the global task pool
+    #
+    # @return [Executor] the requested thread pool (default: global task pool)
+    def get_executor_from(opts = {})
+      if opts[:executor]
+        opts[:executor]
+      elsif opts[:operation] == true || opts[:task] == false
+        Concurrent.configuration.global_operation_pool
+      else
+        Concurrent.configuration.global_task_pool
+      end
+    end
+
+    # Get the requested `Executor` based on the values set in the options hash.
+    #
+    # @param [Hash] opts the options defining the requested executor
+    # @option opts [Executor] :task_executor (`nil`) when set use the given `Executor` instance
+    #
+    # @return [Executor] the requested thread pool (default: global task pool)
+    def get_task_executor_from(opts = {})
+      opts[:task_executor] || opts[:executor] || Concurrent.configuration.global_task_pool
+    end
+
+    # Get the requested `Executor` based on the values set in the options hash.
+    #
+    # @param [Hash] opts the options defining the requested executor
+    # @option opts [Executor] :task_executor (`nil`) when set use the given `Executor` instance
+    #
+    # @return [Executor] the requested thread pool (default: global operation pool)
+    def get_operation_executor_from(opts = {})
+      opts[:operation_executor] || opts[:executor] || Concurrent.configuration.global_operation_pool
+    end
+
+    extend self
+  end
+end

data/lib/concurrent/promise.rb

@@ -1,45 +1,43 @@
 require 'thread'
 
-require 'concurrent/configuration'
 require 'concurrent/obligation'
+require 'concurrent/options_parser'
 
 module Concurrent
 
   class Promise
     include Obligation
-    include OptionsParser
 
     # Initialize a new Promise with the provided options.
     #
-    # @param [Object] initial the initial value
     # @param [Hash] opts the options used to define the behavior at update and deref
     #
-    # @option opts [Promise] :parent the parent +Promise+ when building a chain/tree
+    # @option opts [Promise] :parent the parent `Promise` when building a chain/tree
     # @option opts [Proc] :on_fulfill fulfillment handler
     # @option opts [Proc] :on_reject rejection handler
     #
-    # @option opts [Boolean] :operation (false) when +true+ will execute the future on the global
-    #   operation pool (for long-running operations), when +false+ will execute the future on the
+    # @option opts [Boolean] :operation (false) when `true` will execute the future on the global
+    #   operation pool (for long-running operations), when `false` will execute the future on the
     #   global task pool (for short-running tasks)
     # @option opts [object] :executor when provided will run all operations on
     #   this executor rather than the global thread pool (overrides :operation)
     #
-    # @option opts [String] :dup_on_deref (false) call +#dup+ before returning the data
-    # @option opts [String] :freeze_on_deref (false) call +#freeze+ before returning the data
-    # @option opts [String] :copy_on_deref (nil) call the given +Proc+ passing the internal value and
+    # @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
+    # @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
+    # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
     #   returning the value returned from the proc
     #
     # @see http://wiki.commonjs.org/wiki/Promises/A
     # @see http://promises-aplus.github.io/promises-spec/
     def initialize(opts = {}, &block)
-      opts.delete_if {|k, v| v.nil?}
+      opts.delete_if { |k, v| v.nil? }
 
-      @executor = get_executor_from(opts)
+      @executor = OptionsParser::get_executor_from(opts)
       @parent = opts.fetch(:parent) { nil }
-      @on_fulfill = opts.fetch(:on_fulfill) { Proc.new{ |result| result } }
-      @on_reject = opts.fetch(:on_reject) { Proc.new{ |reason| raise reason } }
+      @on_fulfill = opts.fetch(:on_fulfill) { Proc.new { |result| result } }
+      @on_reject = opts.fetch(:on_reject) { Proc.new { |reason| raise reason } }
 
-      @promise_body = block || Proc.new{|result| result }
+      @promise_body = block || Proc.new { |result| result }
       @state = :unscheduled
       @children = []
 
@@ -48,13 +46,13 @@ module Concurrent
 
     # @return [Promise]
     def self.fulfill(value, opts = {})
-      Promise.new(opts).tap{ |p| p.send(:synchronized_set_state!, true, value, nil) }
+      Promise.new(opts).tap { |p| p.send(:synchronized_set_state!, true, value, nil) }
     end
 
 
     # @return [Promise]
     def self.reject(reason, opts = {})
-      Promise.new(opts).tap{ |p| p.send(:synchronized_set_state!, false, nil, reason) }
+      Promise.new(opts).tap { |p| p.send(:synchronized_set_state!, false, nil, reason) }
     end
 
     # @return [Promise]
@@ -79,7 +77,7 @@ module Concurrent
     # @return [Promise] the new promise
     def then(rescuer = nil, &block)
       raise ArgumentError.new('rescuers and block are both missing') if rescuer.nil? && !block_given?
-      block = Proc.new{ |result| result } if block.nil?
+      block = Proc.new { |result| result } if block.nil?
       child = Promise.new(
         parent: self,
         executor: @executor,
@@ -107,6 +105,7 @@ module Concurrent
     def rescue(&block)
       self.then(block)
     end
+
     alias_method :catch, :rescue
     alias_method :on_error, :rescue
 
@@ -126,13 +125,13 @@ module Concurrent
 
     # @!visibility private
     def on_fulfill(result)
-      realize Proc.new{ @on_fulfill.call(result) }
+      realize Proc.new { @on_fulfill.call(result) }
       nil
     end
 
     # @!visibility private
     def on_reject(reason)
-      realize Proc.new{ @on_reject.call(reason) }
+      realize Proc.new { @on_reject.call(reason) }
       nil
     end
 
@@ -144,14 +143,14 @@ module Concurrent
     # @!visibility private
     def realize(task)
       @executor.post do
-        success, value, reason = SafeTaskExecutor.new( task ).execute
+        success, value, reason = SafeTaskExecutor.new(task).execute
 
         children_to_notify = mutex.synchronize do
           set_state!(success, value, reason)
           @children.dup
         end
 
-        children_to_notify.each{ |child| notify_child(child) }
+        children_to_notify.each { |child| notify_child(child) }
       end
     end
 
@@ -161,9 +160,9 @@ module Concurrent
     end
 
     def synchronized_set_state!(success, value, reason)
-      mutex.synchronize do
-        set_state!(success, value, reason)
-      end
+      mutex.lock
+      set_state!(success, value, reason)
+      mutex.unlock
     end
   end
 end

data/lib/concurrent/scheduled_task.rb

@@ -1,41 +1,37 @@
-require 'observer'
-require 'concurrent/obligation'
-require 'concurrent/safe_task_executor'
+require 'concurrent/ivar'
+require 'concurrent/utility/timer'
+require 'concurrent/executor/safe_task_executor'
 
 module Concurrent
 
-  class ScheduledTask
-    include Obligation
-
-    SchedulingError = Class.new(ArgumentError)
+  class ScheduledTask < IVar
 
     attr_reader :schedule_time
 
-    def initialize(schedule_time, opts = {}, &block)
-      raise SchedulingError.new('no block given') unless block_given?
-      calculate_schedule_time!(schedule_time) # raise exception if in past
+    def initialize(intended_time, opts = {}, &block)
+      raise ArgumentError.new('no block given') unless block_given?
+      TimerSet.calculate_schedule_time(intended_time) # raises exceptons
+
+      super(NO_VALUE, opts)
 
-      init_obligation
-      @observers = CopyOnWriteObserverSet.new
+      self.observers = CopyOnNotifyObserverSet.new
+      @intended_time =  intended_time
       @state = :unscheduled
-      @intended_schedule_time = schedule_time
-      @schedule_time = nil
       @task = block
-      set_deref_options(opts)
     end
 
     # @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 }
+        @schedule_time = TimerSet.calculate_schedule_time(@intended_time)
+        Concurrent::timer(@schedule_time.to_f - Time.now.to_f, &method(:process_task))
         self
       end
     end
 
     # @since 0.5.0
-    def self.execute(schedule_time, opts = {}, &block)
-      return ScheduledTask.new(schedule_time, opts, &block).execute
+    def self.execute(intended_time, opts = {}, &block)
+      return ScheduledTask.new(intended_time, opts, &block).execute
     end
 
     def cancelled?
@@ -53,20 +49,19 @@ module Concurrent
         true
       end
     end
-
     alias_method :stop, :cancel
 
-    def add_observer(observer, func = :update)
+    def add_observer(*args, &block)
       if_state(:unscheduled, :pending, :in_progress) do
-        @observers.add_observer(observer, func)
+        observers.add_observer(*args, &block)
       end
     end
 
-    protected
+    protected :set, :fail, :complete
 
-    def work
-      sleep_until_scheduled_time
+    private
 
+    def process_task
       if compare_and_set_state(:in_progress, :pending)
         success, val, reason = SafeTaskExecutor.new(@task).execute
 
@@ -76,26 +71,7 @@ module Concurrent
         end
 
         time = Time.now
-        @observers.notify_and_delete_observers{ [time, self.value, reason] }
-      end
-
-    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
+        observers.notify_and_delete_observers{ [time, self.value, reason] }
       end
     end
   end

data/lib/concurrent/timer_task.rb

@@ -1,10 +1,11 @@
-require 'thread'
-require 'observer'
-
 require 'concurrent/dereferenceable'
+require 'concurrent/observable'
+require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/executor/executor'
+require 'concurrent/executor/safe_task_executor'
+
+# deprecated Updated to use `Executor` instead of `Runnable`
 require 'concurrent/runnable'
-require 'concurrent/stoppable'
-require 'concurrent/utilities'
 
 module Concurrent
 
@@ -15,35 +16,35 @@ module Concurrent
   # 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
-  # a crashed task thread can pose a significant problem. +TimerTask+ alleviates both problems.
+  # a crashed task thread can pose a significant problem. `TimerTask` alleviates both problems.
   # 
-  # When a +TimerTask+ is launched it starts a thread for monitoring the execution interval.
-  # The +TimerTask+ thread does not perform the task, however. Instead, the TimerTask
+  # When a `TimerTask` is launched it starts a thread for monitoring the execution interval.
+  # The `TimerTask` thread does not perform the task, however. Instead, the TimerTask
   # launches the task on a separate thread. Should the task experience an unrecoverable
-  # crash only the task thread will crash. This makes the +TimerTask+ very fault tolerant
-  # Additionally, the +TimerTask+ thread can respond to the success or failure of the task,
-  # performing logging or ancillary operations. +TimerTask+ can also be configured with a
+  # crash only the task thread will crash. This makes the `TimerTask` very fault tolerant
+  # Additionally, the `TimerTask` thread can respond to the success or failure of the task,
+  # 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 business 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.
+  # `TimerTask` for scheduling and running.
   # 
-  # In some cases it may be necessary for a +TimerTask+ to affect its own execution cycle.
+  # In some cases it may be necessary for a `TimerTask` to affect its own execution cycle.
   # To facilitate this a reference to the task object is passed into the block as a block
   # argument every time the task is executed.
   # 
-  # The +TimerTask+ class includes the +Dereferenceable+ mixin module so the result of
-  # the last execution is always available via the +#value+ method. Derefencing options
-  # can be passed to the +TimerTask+ during construction or at any later time using the
-  # +#set_deref_options+ method.
+  # The `TimerTask` class includes the `Dereferenceable` mixin module so the result of
+  # the last execution is always available via the `#value` method. Derefencing options
+  # can be passed to the `TimerTask` during construction or at any later time using the
+  # `#set_deref_options` method.
   # 
-  # +TimerTask+ supports notification through the Ruby standard library
+  # `TimerTask` supports notification through the Ruby standard library
   # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html Observable}
-  # module. On execution the +TimerTask+ will notify the observers
+  # module. On execution the `TimerTask` will notify the observers
   # with threes arguments: time of execution, the result of the block (or nil on failure),
   # and any raised exceptions (or nil on success). If the timeout interval is exceeded
-  # the observer will receive a +Concurrent::TimeoutError+ object as the third argument.
+  # the observer will receive a `Concurrent::TimeoutError` object as the third argument.
   #
   # @example Basic usage
   #   task = Concurrent::TimerTask.new{ puts 'Boom!' }
@@ -57,7 +58,7 @@ module Concurrent
   #   
   #   task.stop #=> true
   #
-  # @example Configuring +:execution_interval+ and +:timeout_interval+
+  # @example Configuring `:execution_interval` and `:timeout_interval`
   #   task = Concurrent::TimerTask.new(execution_interval: 5, timeout_interval: 5) do
   #          puts 'Boom!'
   #        end
@@ -65,13 +66,13 @@ module Concurrent
   #   task.execution_interval #=> 5
   #   task.timeout_interval   #=> 5
   #
-  # @example Immediate execution with +:run_now+
+  # @example Immediate execution with `:run_now`
   #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
   #   task.run!
   #   
   #   #=> 'Boom!'
   #
-  # @example Last +#value+ and +Dereferenceable+ mixin
+  # @example Last `#value` and `Dereferenceable` mixin
   #   task = Concurrent::TimerTask.new(
   #     dup_on_deref: true,
   #     execution_interval: 5
@@ -145,151 +146,228 @@ module Concurrent
   # @see http://docs.oracle.com/javase/7/docs/api/java/util/TimerTask.html
   class TimerTask
     include Dereferenceable
-    include Runnable
-    include Stoppable
+    include Executor
+    include Concurrent::Observable
 
-    # Default +:execution_interval+
+    # Default `:execution_interval` in seconds.
     EXECUTION_INTERVAL = 60
 
-    # Default +:timeout_interval+
+    # Default `:timeout_interval` in seconds.
     TIMEOUT_INTERVAL = 30
 
-    # Number of seconds after the task completes before the task is
-    # performed again.
-    attr_reader :execution_interval
-
-    # Number of seconds the task can run before it is considered to have failed.
-    # Failed tasks are forcibly killed.
-    attr_reader :timeout_interval
-
     # Create a new TimerTask with the given task and configuration.
     #
-    # @param [Hash] opts the options defining task execution.
-    # @option opts [Integer] :execution_interval number of seconds between
-    #   task executions (default: EXECUTION_INTERVAL)
-    # @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 instantiation or to wait until the first #execution_interval
-    #   has passed (default: false)
-    #
-    # @raise ArgumentError when no block is given.
-    #
-    # @yield to the block after :execution_interval seconds have passed since
-    #   the last yield
-    # @yieldparam task a reference to the +TimerTask+ instance so that the
-    #   block can control its own lifecycle. Necessary since +self+ will
-    #   refer to the execution context of the block rather than the running
-    #   +TimerTask+.
+    # @!macro [attach] timer_task_initialize
+    #   @param [Hash] opts the options defining task execution.
+    #   @option opts [Integer] :execution_interval number of seconds between
+    #     task executions (default: EXECUTION_INTERVAL)
+    #   @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 instantiation or to wait until the first #  execution_interval
+    #     has passed (default: false)
+    #  
+    #   @raise ArgumentError when no block is given.
+    #  
+    #   @yield to the block after :execution_interval seconds have passed since
+    #     the last yield
+    #   @yieldparam task a reference to the `TimerTask` instance so that the
+    #     block can control its own lifecycle. Necessary since `self` will
+    #     refer to the execution context of the block rather than the running
+    #     `TimerTask`.
+    #  
+    #   @note Calls Concurrent::Dereferenceable#  set_deref_options passing `opts`.
+    #     All options supported by Concurrent::Dereferenceable can be set
+    #     during object initialization.
     #
-    # @note Calls Concurrent::Dereferenceable#set_deref_options passing +opts+.
-    #   All options supported by Concurrent::Dereferenceable can be set
-    #   during object initialization.
-    #
-    # @see Concurrent::Dereferenceable#set_deref_options
-    def initialize(opts = {}, &block)
+    #   @return [TimerTask] the new `TimerTask`
+    #  
+    #   @see Concurrent::Dereferenceable#  set_deref_options
+    def initialize(opts = {}, &task)
       raise ArgumentError.new('no block given') unless block_given?
 
+      init_executor
+      set_deref_options(opts)
+
       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]
+      @executor = Concurrent::SafeTaskExecutor.new(task)
+      @running = Concurrent::AtomicBoolean.new(false)
 
-      @task = block
-      @observers = CopyOnWriteObserverSet.new
-      init_mutex
-      set_deref_options(opts)
+      self.observers = CopyOnNotifyObserverSet.new
     end
 
-    # Number of seconds after the task completes before the task is
-    # performed again.
+    # Is the executor running?
     #
-    # @param [Float] value number of seconds
+    # @return [Boolean] `true` when running, `false` when shutting down or shutdown
+    def running?
+      @running.true?
+    end
+
+    # Execute a previously created `TimerTask`.
     #
-    # @raise ArgumentError when value is non-numeric or not greater than zero
-    def execution_interval=(value)
-      if (value = value.to_f) <= 0.0
-        raise ArgumentError.new("'execution_interval' must be non-negative number")
+    # @return [TimerTask] a reference to `self`
+    #
+    # @example Instance and execute in separate steps
+    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }
+    #   task.running? #=> false
+    #   task.execute
+    #   task.running? #=> true
+    #
+    # @example Instance and execute in one line
+    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }.execute
+    #   task.running? #=> true
+    #
+    # @since 0.6.0
+    def execute
+      mutex.synchronize do
+        if @running.false?
+          @running.make_true
+          schedule_next_task(@run_now ? 0 : @execution_interval)
+        end
       end
-      @execution_interval = value
+      self
     end
 
-    # Number of seconds the task can run before it is considered to have failed.
-    # Failed tasks are forcibly killed.
+    # Create and execute a new `TimerTask`.
     #
-    # @param [Float] value number of seconds
+    # @!macro timer_task_initialize
     #
-    # @raise ArgumentError when value is non-numeric or not greater than zero
-    def timeout_interval=(value)
+    # @example 
+    #   task = Concurrent::TimerTask.execute(execution_interval: 10){ print "Hello World\n" }
+    #   task.running? #=> true
+    #
+    # @since 0.6.0
+    def self.execute(opts = {}, &task)
+      TimerTask.new(opts, &task).execute
+    end
+
+    # @!attribute [rw] execution_interval
+    # @return [Fixnum] Number of seconds after the task completes before the
+    #   task is performed again.
+    def execution_interval
+      mutex.lock
+      result = @execution_interval
+      mutex.unlock
+      result
+    end
+
+    # @!attribute [rw] execution_interval
+    # @return [Fixnum] Number of seconds after the task completes before the
+    #   task is performed again.
+    def execution_interval=(value)
       if (value = value.to_f) <= 0.0
-        raise ArgumentError.new("'timeout_interval' must be non-negative number")
+        raise ArgumentError.new('must be greater than zero')
+      else
+        mutex.lock
+        result = @execution_interval = value
+        mutex.unlock
+        result
       end
-      @timeout_interval = value
     end
 
-    def add_observer(observer, func = :update)
-      @observers.add_observer(observer, func)
+    # @!attribute [rw] timeout_interval
+    # @return [Fixnum] Number of seconds the task can run before it is
+    #   considered to have failed.
+    def timeout_interval
+      mutex.lock
+      result = @timeout_interval
+      mutex.unlock
+      result
     end
 
-    # Terminate with extreme prejudice. Useful in cases where +#stop+ doesn't
-    # work because one of the threads becomes unresponsive.
-    #
-    # @return [Boolean] indicating whether or not the +TimerTask+ was killed
-    #
-    # @note Do not use this method unless +#stop+ has failed.
-    def kill
-      return true unless running?
-      mutex.synchronize do
-        @running = false
-        Thread.kill(@worker) unless @worker.nil?
-        Thread.kill(@monitor) unless @monitor.nil?
+    # @!attribute [rw] timeout_interval
+    # @return [Fixnum] Number of seconds the task can run before it is
+    #   considered to have failed.
+    def timeout_interval=(value)
+      if (value = value.to_f) <= 0.0
+        raise ArgumentError.new('must be greater than zero')
+      else
+        mutex.lock
+        result = @timeout_interval = value
+        mutex.unlock
+        result
       end
-      return true
-    rescue
-      return false
-    ensure
-      @worker = @monitor = nil
     end
-    alias_method :terminate, :kill
 
-    alias_method :cancel, :stop
+    # @deprecated Updated to use `Executor` instead of `Runnable`
+    def terminate(*args) deprecated(:terminate, :kill, *args); end
+
+    # @deprecated Updated to use `Executor` instead of `Runnable`
+    def stop(*args) deprecated(:stop, :shutdown, *args); end
+
+    # @deprecated Updated to use `Executor` instead of `Runnable`
+    def cancel(*args) deprecated(:cancel, :shutdown, *args); end
+
+    # @deprecated Updated to use `Executor` instead of `Runnable`
+    def run!(*args) deprecated(:run!, :execute); end
+
+    # @deprecated Updated to use `Executor` instead of `Runnable`
+    def self.run!(*args, &block)
+      warn "[DEPRECATED] `run!` is deprecated, please use `execute` instead."
+      Concurrent::Runnable::Context.new(TimerTask.new(*args, &block))
+    end
+
+    # @deprecated Updated to use `Executor` instead of `Runnable`
+    def run
+      raise Concurrent::Runnable::LifecycleError.new('already running') if @running.true?
+      self.execute
+      self.wait_for_termination
+      true
+    end
+
+    private :post, :<<
 
     protected
 
-    def on_run # :nodoc:
-      @monitor = Thread.current
+    # @!visibility private
+    def shutdown_execution
+      @running.make_false
+      super
     end
 
-    def on_stop # :nodoc:
-      before_stop_proc.call if before_stop_proc
-      @monitor.wakeup if @monitor.alive?
-      Thread.pass
+    # @!visibility private
+    def kill_execution
+      @running.make_false
+      super
     end
 
-    def on_task # :nodoc:
-      if @run_now
-        @run_now = false
-      else
-        sleep(@execution_interval)
-      end
-      execute_task
+    # @!visibility private
+    def schedule_next_task(interval = execution_interval)
+      Concurrent::timer(interval, Concurrent::Event.new, &method(:execute_task))
     end
 
-    def execute_task # :nodoc:
-      @value = ex = nil
-      @worker = Thread.new do
-        Thread.current.abort_on_exception = false
-        Thread.current[:result] = @task.call(self)
+    # @!visibility private
+    def execute_task(completion)
+      return unless @running.true?
+      Concurrent::timer(timeout_interval, completion, &method(:timeout_task))
+      success, value, reason = @executor.execute(self)
+      if completion.try?
+        self.value = value
+        schedule_next_task
+        time = Time.now
+        observers.notify_observers do
+          [time, self.value, reason]
+        end
       end
-      raise TimeoutError if @worker.join(@timeout_interval).nil?
-      mutex.synchronize { @value = @worker[:result] }
-    rescue Exception => e
-      ex = e
-    ensure
-      @observers.notify_observers(Time.now, self.value, ex)
-      unless @worker.nil?
-        Thread.kill(@worker)
-        @worker = nil
+    end
+
+    # @!visibility private
+    def timeout_task(completion)
+      return unless @running.true?
+      if completion.try?
+        self.value = value
+        schedule_next_task
+        observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
       end
     end
+
+    # @deprecated Updated to use `Executor` instead of `Runnable`
+    # @!visibility private
+    def deprecated(old, new, *args)
+      warn "[DEPRECATED] `#{old}` is deprecated, please use `#{new}` instead."
+      self.send(new, *args)
+    end
   end
 end