concurrent-ruby 0.9.0.pre3-java → 0.9.1-java

data/lib/concurrent/delay.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'concurrent/configuration'
 require 'concurrent/concern/obligation'
 require 'concurrent/executor/executor'
 require 'concurrent/executor/immediate_executor'

data/lib/concurrent/errors.rb

@@ -15,6 +15,10 @@ module Concurrent
   # Raised when an attempt is made to violate an immutability guarantee.
   ImmutabilityError = Class.new(Error)
 
+  # Raised when an operation is attempted which is not legal given the
+  # receiver's current state
+  IllegalOperationError = Class.new(Error)
+
   # Raised when an object's methods are called when it has not been
   # properly initialized.
   InitializationError = Class.new(Error)

data/lib/concurrent/executor/executor.rb

@@ -1,5 +1,6 @@
-require 'concurrent/executor/executor_service'
+require 'concurrent/configuration'
 require 'concurrent/concern/deprecation'
+require 'concurrent/executor/executor_service'
 
 module Concurrent
 

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -166,7 +166,7 @@ module Concurrent
     def ns_kill_execution
       # TODO log out unprocessed tasks in queue
       # TODO try to shutdown first?
-      @pool.each &:kill
+      @pool.each(&:kill)
       @pool.clear
       @ready.clear
     end
@@ -297,32 +297,31 @@ module Concurrent
       private
 
       def create_worker(queue, pool, idletime)
-        Thread.new(queue, pool, idletime) do |queue, pool, idletime|
+        Thread.new(queue, pool, idletime) do |my_queue, my_pool, my_idletime|
           last_message = Concurrent.monotonic_time
           catch(:stop) do
             loop do
 
-              case message = queue.pop
+              case message = my_queue.pop
               when :idle_test
-                if (Concurrent.monotonic_time - last_message) > idletime
-                  pool.remove_busy_worker(self)
+                if (Concurrent.monotonic_time - last_message) > my_idletime
+                  my_pool.remove_busy_worker(self)
                   throw :stop
                 else
-                  pool.worker_not_old_enough(self)
+                  my_pool.worker_not_old_enough(self)
                 end
 
               when :stop
-                pool.remove_busy_worker(self)
+                my_pool.remove_busy_worker(self)
                 throw :stop
 
               else
                 task, args = message
-                run_task pool, task, args
+                run_task my_pool, task, args
                 last_message = Concurrent.monotonic_time
 
-                pool.ready_worker(self)
+                my_pool.ready_worker(self)
               end
-
             end
           end
         end

data/lib/concurrent/scheduled_task.rb

@@ -1,56 +1,56 @@
 require 'concurrent/errors'
 require 'concurrent/ivar'
-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
 
   # `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). 
+  # [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. 
-  # 
+  # [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. 
-  # 
+  # 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. 
-  # 
+  # 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. 
+  # behaves identically to [Future](Observable) with regard to these modules.
   #
   # @!macro copy_options
   #
@@ -59,7 +59,7 @@ module Concurrent
   #   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"
@@ -67,75 +67,75 @@ module Concurrent
   #       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?> 
-  # 
+  #   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
@@ -196,12 +196,12 @@ module Concurrent
     #
     # @deprecated use {#initial_delay} instead
     def delay
-      warn '[DEPRECATED] use #initial_delay instead'
+      deprecated_method 'delay', 'initial_delay'
       initial_delay
     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 }
@@ -234,7 +234,7 @@ module Concurrent
     #
     # @deprecated Use {#processing?} instead.
     def in_progress?
-      warn '[DEPRECATED] use #processing? instead'
+      deprecated_method 'in_progress?', 'processing?'
       processing?
     end
 
@@ -260,7 +260,7 @@ module Concurrent
     #
     # @deprecated Use {#cancel} instead.
     def stop
-      warn '[DEPRECATED] use #cancel instead'
+      deprecated_method 'stop', 'cancel'
       cancel
     end
 
@@ -363,7 +363,7 @@ module Concurrent
     # @!visibility private
     def calculate_delay!(delay)
       if delay.is_a?(Time)
-        warn '[DEPRECATED] Use an interval not a clock time; schedule is now based on a monotonic clock'
+        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

data/lib/concurrent/synchronization/java_object.rb

@@ -4,7 +4,6 @@ module Concurrent
   module Synchronization
 
     if Concurrent.on_jruby?
-      require 'jruby'
 
       # @!visibility private
       # @!macro internal_implementation_note

data/lib/concurrent/synchronization/monitor_object.rb

@@ -1,3 +1,6 @@
+require 'monitor'
+require 'concurrent/synchronization/mutex_object'
+
 module Concurrent
   module Synchronization
 

data/lib/concurrent/synchronization/object.rb

@@ -1,3 +1,8 @@
+require 'concurrent/synchronization/java_object'
+require 'concurrent/synchronization/monitor_object'
+require 'concurrent/synchronization/mutex_object'
+require 'concurrent/synchronization/rbx_object'
+
 module Concurrent
   module Synchronization
 

data/lib/concurrent/synchronization/rbx_object.rb

@@ -2,35 +2,48 @@ module Concurrent
   module Synchronization
 
     if Concurrent.on_rbx?
-      
+
       # @!visibility private
       # @!macro internal_implementation_note
       class RbxObject < AbstractObject
         def initialize
-          @Waiters = []
+          @__Waiters__ = []
+          @__owner__   = nil
           ensure_ivar_visibility!
         end
 
         protected
 
         def synchronize(&block)
-          Rubinius.synchronize(self, &block)
+          if @__owner__ == Thread.current
+            yield
+          else
+            Rubinius.lock(self)
+            begin
+              @__owner__ = Thread.current
+              result = yield
+            ensure
+              @__owner__ = nil
+              Rubinius.unlock(self)
+              result
+            end
+          end
         end
 
         def ns_wait(timeout = nil)
           wchan = Rubinius::Channel.new
 
           begin
-            @Waiters.push wchan
+            @__Waiters__.push wchan
             Rubinius.unlock(self)
             signaled = wchan.receive_timeout timeout
           ensure
             Rubinius.lock(self)
 
-            if !signaled && !@Waiters.delete(wchan)
+            if !signaled && !@__Waiters__.delete(wchan)
               # we timed out, but got signaled afterwards,
               # so pass that signal on to the next waiter
-              @Waiters.shift << true unless @Waiters.empty?
+              @__Waiters__.shift << true unless @__Waiters__.empty?
             end
           end
 
@@ -38,12 +51,12 @@ module Concurrent
         end
 
         def ns_signal
-          @Waiters.shift << true unless @Waiters.empty?
+          @__Waiters__.shift << true unless @__Waiters__.empty?
           self
         end
 
         def ns_broadcast
-          @Waiters.shift << true until @Waiters.empty?
+          @__Waiters__.shift << true until @__Waiters__.empty?
           self
         end
 

data/lib/concurrent/utility/at_exit.rb

@@ -1,4 +1,4 @@
-require 'concurrent/concern/logging'
+require 'logger'
 require 'concurrent/synchronization'
 
 module Concurrent
@@ -8,11 +8,11 @@ module Concurrent
   #
   # @!visibility private
   class AtExitImplementation < Synchronization::Object
-    include Concern::Logging
+    include Logger::Severity
 
     def initialize(*args)
       super()
-      synchronize { ns_initialize *args }
+      synchronize { ns_initialize(*args) }
     end
 
     # Add a handler to be run at `Kernel#at_exit`
@@ -46,9 +46,9 @@ module Concurrent
     def install
       synchronize do
         @installed ||= begin
-          at_exit { runner }
-          true
-        end
+                         at_exit { runner }
+                         true
+                       end
         self
       end
     end
@@ -71,7 +71,7 @@ module Concurrent
         begin
           handler.call
         rescue => error
-          log ERROR, error
+          Concurrent.global_logger.call(ERROR, error)
         end
       end
       handlers.keys

data/lib/concurrent/utility/engine.rb

@@ -19,6 +19,10 @@ module Concurrent
         ruby_engine == 'rbx'
       end
 
+      def on_windows?
+        !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
+      end
+
       def ruby_engine
         defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
       end

data/lib/concurrent/utility/native_extension_loader.rb

@@ -25,9 +25,6 @@ module Concurrent
             # may be a Windows cross-compiled native gem
             require "concurrent/#{RUBY_VERSION[0..2]}/extension"
             @c_ext_loaded = true
-          end,
-          lambda do
-            warn 'Performance on MRI may be improved with the concurrent-ruby-ext gem. Please see http://concurrent-ruby.com'
           end]
 
         tries.each do |try|
@@ -45,7 +42,7 @@ module Concurrent
           require 'concurrent_ruby_ext'
           @java_ext_loaded = true
         rescue LoadError
-          warn 'Performance on JRuby may be improved by installing the pre-compiled Java extensions. Please see http://concurrent-ruby.com'
+          # move on with pure-Ruby implementations
         end
       end
     end