concurrent-ruby 0.7.0.rc2-java → 0.7.1-java

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -1,3 +1,6 @@
+require_relative '../../extension_helper'
+Concurrent.safe_require_c_extensions
+
 module Concurrent
 
   # @!macro [attach] atomic_boolean
@@ -159,7 +162,7 @@ module Concurrent
     class AtomicBoolean < JavaAtomicBoolean
     end
 
-  elsif defined? Concurrent::CAtomicBoolean
+  elsif Concurrent.allow_c_native_class?('CAtomicBoolean')
 
     # @!macro atomic_boolean
     class CAtomicBoolean

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -1,3 +1,6 @@
+require_relative '../../extension_helper'
+Concurrent.safe_require_c_extensions
+
 module Concurrent
 
   # @!macro [attach] atomic_fixnum
@@ -163,7 +166,7 @@ module Concurrent
     class AtomicFixnum < JavaAtomicFixnum
     end
 
-  elsif defined? Concurrent::CAtomicFixnum
+  elsif Concurrent.allow_c_native_class?('CAtomicFixnum')
 
     # @!macro atomic_fixnum
     class CAtomicFixnum

data/lib/concurrent/atomic/thread_local_var.rb

@@ -2,41 +2,83 @@ require 'concurrent/atomic'
 
 module Concurrent
 
-  module ThreadLocalRubyStorage
+  # @!macro [attach] abstract_thread_local_var
+  #   A `ThreadLocalVar` is a variable where the value is different for each thread.
+  #   Each variable may have a default value, but when you modify the variable only
+  #   the current thread will ever see that change.
+  #   
+  #   @example
+  #     v = ThreadLocalVar.new(14)
+  #     v.value #=> 14
+  #     v.value = 2
+  #     v.value #=> 2
+  #   
+  #   @example
+  #     v = ThreadLocalVar.new(14)
+  #   
+  #     t1 = Thread.new do
+  #       v.value #=> 14
+  #       v.value = 1
+  #       v.value #=> 1
+  #     end
+  #   
+  #     t2 = Thread.new do
+  #       v.value #=> 14
+  #       v.value = 2
+  #       v.value #=> 2
+  #     end
+  #   
+  #     v.value #=> 14
+  class AbstractThreadLocalVar
 
-    def allocate_storage
-      @storage = Atomic.new Hash.new
-    end
+    module ThreadLocalRubyStorage
 
-    def get
-      @storage.get[Thread.current]
-    end
+      protected
 
-    def set(value)
-      @storage.update { |s| s.merge Thread.current => value }
-    end
+      unless RUBY_PLATFORM == 'java'
+        require 'ref'
+      end
 
-  end
+      def allocate_storage
+        @storage = Ref::WeakKeyMap.new
+      end
 
-  module ThreadLocalJavaStorage
+      def get
+        @storage[Thread.current]
+      end
 
-    protected
+      def set(value, &block)
+        key = Thread.current
 
-    def allocate_storage
-      @var = java.lang.ThreadLocal.new
-    end
+        @storage[key] = value
 
-    def get
-      @var.get
+        if block_given?
+          begin
+            block.call
+          ensure
+            @storage.delete key
+          end
+        end
+      end
     end
 
-    def set(value)
-      @var.set(value)
-    end
+    module ThreadLocalJavaStorage
 
-  end
+      protected
 
-  class AbstractThreadLocalVar
+      def allocate_storage
+        @var = java.lang.ThreadLocal.new
+      end
+
+      def get
+        @var.get
+      end
+
+      def set(value)
+        @var.set(value)
+      end
+
+    end
 
     NIL_SENTINEL = Object.new
 
@@ -58,19 +100,24 @@ module Concurrent
     end
 
     def value=(value)
+      bind value
+    end
+
+    def bind(value, &block)
       if value.nil?
         stored_value = NIL_SENTINEL
       else
         stored_value = value
       end
 
-      set stored_value
+      set stored_value, &block
 
       value
     end
 
   end
 
+  # @!macro abstract_thread_local_var
   class ThreadLocalVar < AbstractThreadLocalVar
     if RUBY_PLATFORM == 'java'
       include ThreadLocalJavaStorage

data/lib/concurrent/atomic_reference/jruby.rb

@@ -1,10 +1,14 @@
-require 'concurrent_ruby_ext'
-require 'concurrent/atomic_reference/direct_update'
+require_relative '../../extension_helper'
+Concurrent.safe_require_java_extensions
 
-module Concurrent
+if defined?(Concurrent::JavaAtomic)
+  require 'concurrent/atomic_reference/direct_update'
 
-  # @!macro atomic_reference
-  class JavaAtomic
-    include Concurrent::AtomicDirectUpdate
+  module Concurrent
+
+    # @!macro atomic_reference
+    class JavaAtomic
+      include Concurrent::AtomicDirectUpdate
+    end
   end
 end

data/lib/concurrent/atomic_reference/ruby.rb

@@ -1,8 +1,12 @@
-begin
-  require 'concurrent_ruby_ext'
-rescue LoadError
-  # may be a Windows cross-compiled native gem
-  require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+require_relative '../../extension_helper'
+
+if Concurrent.allow_c_extensions?
+  begin
+    require 'concurrent_ruby_ext'
+  rescue LoadError
+    # may be a Windows cross-compiled native gem
+    require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+  end
 end
 
 require 'concurrent/atomic_reference/direct_update'
@@ -14,19 +18,19 @@ module Concurrent
   class CAtomic
     include Concurrent::AtomicDirectUpdate
     include Concurrent::AtomicNumericCompareAndSetWrapper
-    
+
     # @!method initialize
     #   @!macro atomic_reference_method_initialize
-    
+
     # @!method get
     #   @!macro atomic_reference_method_get
-    
+
     # @!method set
     #   @!macro atomic_reference_method_set
-    
+
     # @!method get_and_set
     #   @!macro atomic_reference_method_get_and_set
-    
+
     # @!method _compare_and_set
     #   @!macro atomic_reference_method_compare_and_set
   end

data/lib/concurrent/atomics.rb

@@ -7,5 +7,4 @@ require 'concurrent/atomic/copy_on_write_observer_set'
 require 'concurrent/atomic/cyclic_barrier'
 require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/event'
-require 'concurrent/atomic/thread_local_var'
 require 'concurrent/atomic/synchronization'

data/lib/concurrent/configuration.rb

@@ -17,6 +17,9 @@ module Concurrent
     #   lambda { |level, progname, message = nil, &block| _ }
     attr_accessor :logger
 
+    # defines if executors should be auto-terminated in at_exit callback
+    attr_accessor :auto_terminate
+
     # Create a new configuration object.
     def initialize
       immediate_executor     = ImmediateExecutor.new
@@ -24,6 +27,7 @@ module Concurrent
       @global_operation_pool = Delay.new(executor: immediate_executor) { new_operation_pool }
       @global_timer_set      = Delay.new(executor: immediate_executor) { Concurrent::TimerSet.new }
       @logger                = no_logger
+      @auto_terminate        = true
     end
 
     # if assigned to {#logger}, it will log nothing.
@@ -129,6 +133,12 @@ module Concurrent
     yield(configuration)
   end
 
+  def self.finalize_global_executors
+    self.finalize_executor(self.configuration.global_timer_set)
+    self.finalize_executor(self.configuration.global_task_pool)
+    self.finalize_executor(self.configuration.global_operation_pool)
+  end
+
   private
 
   # Attempt to properly shutdown the given executor using the `shutdown` or
@@ -150,12 +160,8 @@ module Concurrent
     false
   end
 
-
   # set exit hook to shutdown global thread pools
   at_exit do
-    self.finalize_executor(self.configuration.global_timer_set)
-    self.finalize_executor(self.configuration.global_task_pool)
-    self.finalize_executor(self.configuration.global_operation_pool)
-    # TODO may break other test suites using concurrent-ruby, terminates before test is run
+    finalize_global_executors if configuration.auto_terminate
   end
 end

data/lib/concurrent/dataflow.rb

@@ -19,36 +19,7 @@ module Concurrent
     end
   end
 
-  # Dataflow allows you to create a task that will be scheduled then all of its
-  # data dependencies are available. Data dependencies are `Future` values. The
-  # dataflow task itself is also a `Future` value, so you can build up a graph of
-  # these tasks, each of which is run when all the data and other tasks it depends
-  # on are available or completed.
-  #
-  # Our syntax is somewhat related to that of Akka's `flow` and Habanero Java's
-  # `DataDrivenFuture`. However unlike Akka we don't schedule a task at all until
-  # it is ready to run, and unlike Habanero Java we pass the data values into the
-  # task instead of dereferencing them again in the task.
-  #
-  # The theory of dataflow goes back to the 80s. In the terminology of the literature,
-  # our implementation is coarse-grained, in that each task can be many instructions,
-  # and dynamic in that you can create more tasks within other tasks.
-  #
-  # @example Parallel Fibonacci calculator
-  #   def fib(n)
-  #     if n < 2
-  #       Concurrent::dataflow { n }
-  #     else
-  #       n1 = fib(n - 1)
-  #       n2 = fib(n - 2)
-  #       Concurrent::dataflow(n1, n2) { |v1, v2| v1 + v2 }
-  #     end
-  #   end
-  #   
-  #   f = fib(14) #=> #<Concurrent::Future:0x000001019a26d8 ...
-  #   
-  #   # wait up to 1 second for the answer...
-  #   f.value(1) #=> 377
+  # {include:file:doc/dataflow.md}
   #
   # @param [Future] inputs zero or more `Future` operations that this dataflow depends upon
   #

data/lib/concurrent/dereferenceable.rb

@@ -3,8 +3,15 @@ module Concurrent
   # Object references in Ruby are mutable. This can lead to serious problems when
   # the `#value` of a concurrent object is a mutable reference. Which is always the
   # case unless the value is a `Fixnum`, `Symbol`, or similar "primitive" data type.
-  # Most classes in this library that expose a `#value` getter method do so using
-  # this mixin module.
+  # Most classes in this library that expose a `#value` getter method do so using the
+  # `Dereferenceable` mixin module. 
+  # 
+  # Objects with this mixin can be configured with a few options that can help protect
+  # the program from potentially dangerous operations.
+  # 
+  # * `:dup_on_deref` when true  will call the `#dup` method on the `value` object every time the `#value` method is called (default: false)
+  # * `:freeze_on_deref` when true  will call the `#freeze` method on the `value` object every time the `#value` method is called (default: false)
+  # * `:copy_on_deref` when given a `Proc` object the `Proc` will be run every time the `#value` method is called. The `Proc` will be given the current `value` as its only parameter and the result returned by the block will be the return value of the `#value` call. When `nil` this option will be ignored (default: nil)
   module Dereferenceable
 
     # Return the value this object represents after applying the options specified

data/lib/concurrent/executor/indirect_immediate_executor.rb

@@ -0,0 +1,46 @@
+require 'concurrent/executor/executor'
+
+module Concurrent
+  # An executor service which runs all operations on a new thread, blocking
+  # until it completes. Operations are performed in the order they are received
+  # and no two operations can be performed simultaneously.
+  #
+  # This executor service exists mainly for testing an debugging. When used it
+  # immediately runs every `#post` operation on a new thread, blocking the
+  # current thread until the operation is complete. This is similar to how the
+  # ImmediateExecutor works, but the operation has the full stack of the new
+  # thread at its disposal. This can be helpful when the operations will spawn
+  # more operations on the same executor and so on - such a situation might
+  # overflow the single stack in case of an ImmediateExecutor, which is
+  # inconsistent with how it would behave for a threaded executor.
+  #
+  # @note Intended for use primarily in testing and debugging.
+  class IndirectImmediateExecutor < ImmediateExecutor
+    # Creates a new executor
+    def initialize
+      super
+      @internal_executor = PerThreadExecutor.new
+    end
+
+    # @!macro executor_method_post
+    def post(*args, &task)
+      raise ArgumentError.new("no block given") unless block_given?
+      return false unless running?
+
+      event = Concurrent::Event.new
+      internal_executor.post do
+        begin
+          task.call(*args)
+        ensure
+          event.set
+        end
+      end
+      event.wait
+
+      true
+    end
+
+    private
+    attr_reader :internal_executor
+  end
+end

data/lib/concurrent/executor/java_thread_pool_executor.rb

@@ -74,9 +74,7 @@ if RUBY_PLATFORM == 'java'
         raise ArgumentError.new('min_threads cannot be more than max_threads') if min_length > max_length
         raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
 
-        if min_length == 0 && @max_queue == 0
-          queue = java.util.concurrent.SynchronousQueue.new
-        elsif @max_queue == 0
+        if @max_queue == 0
           queue = java.util.concurrent.LinkedBlockingQueue.new
         else
           queue = java.util.concurrent.LinkedBlockingQueue.new(@max_queue)
@@ -90,7 +88,7 @@ if RUBY_PLATFORM == 'java'
         set_shutdown_hook
       end
 
-    # @!macro executor_module_method_can_overflow_question
+      # @!macro executor_module_method_can_overflow_question
       def can_overflow?
         @max_queue != 0
       end

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -11,20 +11,20 @@ module Concurrent
     include RubyExecutor
 
     # Default maximum number of threads that will be created in the pool.
-    DEFAULT_MAX_POOL_SIZE = 2**15 # 32768
+    DEFAULT_MAX_POOL_SIZE      = 2**15 # 32768
 
     # Default minimum number of threads that will be retained in the pool.
-    DEFAULT_MIN_POOL_SIZE = 0
+    DEFAULT_MIN_POOL_SIZE      = 0
 
     # Default maximum number of tasks that may be added to the task queue.
-    DEFAULT_MAX_QUEUE_SIZE = 0
+    DEFAULT_MAX_QUEUE_SIZE     = 0
 
     # Default maximum number of seconds a thread in the pool may remain idle
     # before being reclaimed.
     DEFAULT_THREAD_IDLETIMEOUT = 60
 
     # The set of possible overflow policies that may be set at thread pool creation.
-    OVERFLOW_POLICIES = [:abort, :discard, :caller_runs]
+    OVERFLOW_POLICIES          = [:abort, :discard, :caller_runs]
 
     # The maximum number of threads that may be created in the pool.
     attr_reader :max_length
@@ -77,10 +77,10 @@ module Concurrent
     #
     # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html
     def initialize(opts = {})
-      @min_length = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
-      @max_length = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
-      @idletime = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
-      @max_queue = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i
+      @min_length      = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
+      @max_length      = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
+      @idletime        = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
+      @max_queue       = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i
       @overflow_policy = opts.fetch(:overflow_policy, :abort)
 
       raise ArgumentError.new('max_threads must be greater than zero') if @max_length <= 0
@@ -90,13 +90,13 @@ module Concurrent
 
       init_executor
 
-      @pool = []
-      @queue = Queue.new
+      @pool                 = []
+      @queue                = Queue.new
       @scheduled_task_count = 0
       @completed_task_count = 0
-      @largest_length = 0
+      @largest_length       = 0
 
-      @gc_interval = opts.fetch(:gc_interval, 1).to_i # undocumented
+      @gc_interval  = opts.fetch(:gc_interval, 1).to_i # undocumented
       @last_gc_time = Time.now.to_f - [1.0, (@gc_interval * 2.0)].max
     end
 
@@ -109,15 +109,16 @@ module Concurrent
     #
     # @return [Integer] the length
     def length
-      mutex.synchronize{ running? ? @pool.length : 0 }
+      mutex.synchronize { running? ? @pool.length : 0 }
     end
+
     alias_method :current_length, :length
 
     # The number of tasks in the queue awaiting execution.
     #
     # @return [Integer] the queue_length
     def queue_length
-      mutex.synchronize{ running? ? @queue.length : 0 }
+      mutex.synchronize { running? ? @queue.length : 0 }
     end
 
     # Number of tasks that may be enqueued before reaching `max_queue` and rejecting
@@ -152,7 +153,7 @@ module Concurrent
     def on_worker_exit(worker)
       mutex.synchronize do
         @pool.delete(worker)
-        if @pool.empty? && ! running?
+        if @pool.empty? && !running?
           stop_event.set
           stopped_event.set
         end
@@ -177,7 +178,7 @@ module Concurrent
       if @pool.empty?
         stopped_event.set
       else
-        @pool.length.times{ @queue << :stop }
+        @pool.length.times { @queue << :stop }
       end
     end
 
@@ -196,7 +197,7 @@ module Concurrent
     # @!visibility private
     def ensure_capacity?
       additional = 0
-      capacity = true
+      capacity   = true
 
       if @pool.size < @min_length
         additional = @min_length - @pool.size
@@ -254,10 +255,11 @@ module Concurrent
     # @!visibility private
     def prune_pool
       if Time.now.to_f - @gc_interval >= @last_gc_time
-        @pool.delete_if do |worker|
-          worker.dead? ||
-            (@idletime == 0 ? false : Time.now.to_f - @idletime > worker.last_activity)
-        end
+        @pool.delete_if { |worker| worker.dead? }
+        # send :stop for each thread over idletime
+        @pool.
+            select { |worker| @idletime != 0 && Time.now.to_f - @idletime > worker.last_activity }.
+            each { @queue << :stop }
         @last_gc_time = Time.now.to_f
       end
     end
@@ -266,7 +268,7 @@ module Concurrent
     #
     # @!visibility private
     def drain_pool
-      @pool.each {|worker| worker.kill }
+      @pool.each { |worker| worker.kill }
       @pool.clear
     end