concurrent-ruby 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96f32c31090c8a0547e4ee452739bdc993aad1256e2c89cb9a46d7f7e7b5762a
-  data.tar.gz: 307d26bde3add56b7e2b37fb0b016c7726a3ba0755dcfec8202fb0760e4ac485
+  metadata.gz: 649de1a5e5c7c82652bd6ad21496f2c1061d7c75517271d8ca30c3ceb9c49038
+  data.tar.gz: 6274d2cd2dcda660a1e34436547eca26d6c74d03e9a527d7ce5d1a9f3f72f4be
 SHA512:
-  metadata.gz: b8cff93c6ef396aebbe5cf69734d9a91f0351e24b5c1846ae105b055254f972cd9d6bb99b90ce10d387627ed43c4e21db9ce47d1587e10278e80e33a53f8d4c4
-  data.tar.gz: f367f097759eedb8e18b0117543176c9f30ab29552888fcedab0baaea355cee3d100d2559dd16cf54483778545097f8b3340bebe44b0e3ab2a51c1af3830f5e1
+  metadata.gz: 2adbf28bdf7034295709496964e8e70d22f59bf058bf18ca005c2ce536627160538de6c510ea1f39893de0ad90b2fb50d6f35c848c97f58bd8f71ff8d9e57fc2
+  data.tar.gz: 1cbc384488e0f70d19d742e54c34dbd7abfaffe89f75230b2f5b80d2ae4d161b731666ce6b64e8f5adeb561b6d32191ce6bd679e05d6bd9eec91b869ee379b2f

data/CHANGELOG.md

@@ -1,6 +1,30 @@
 ## Current
 
-## Release v1.1.5, edge v0.5.0 (10 mar 2019)
+## Release v1.1.6, edge v0.6.0 (10 Feb 2020)
+
+concurrent-ruby:
+
+* (#841) Concurrent.disable_at_exit_handlers! is no longer needed and was deprecated.
+* (#841) AbstractExecutorService#auto_terminate= was deprecated and has no effect. 
+  Set :auto_terminate option instead when executor is initialized.
+
+## Release v1.1.6.pre1, edge v0.6.0.pre1 (26 Jan 2020)
+
+concurrent-ruby:
+
+* (#828) Allow to name executors, the name is also used to name their threads 
+* (#838) Implement #dup and #clone for structs
+* (#821) Safer finalizers for thread local variables
+* Documentation fixes
+* (#814) Use Ruby's Etc.nprocessors if available
+* (#812) Fix directory structure not to mess with packaging tools
+* (#840) Fix termination of pools on JRuby
+
+concurrent-ruby-edge:
+
+* Add WrappingExecutor (#830)
+
+## Release v1.1.5, edge v0.5.0 (10 Mar 2019)
 
 concurrent-ruby:
 

data/Gemfile

@@ -1,7 +1,8 @@
 source 'https://rubygems.org'
 
-require File.join(File.dirname(__FILE__), 'lib/concurrent/version')
-require File.join(File.dirname(__FILE__ ), 'lib-edge/concurrent/edge/version')
+require File.join(File.dirname(__FILE__), 'lib/concurrent-ruby/concurrent/version')
+require File.join(File.dirname(__FILE__ ), 'lib/concurrent-ruby-edge/concurrent/edge/version')
+require File.join(File.dirname(__FILE__ ), 'lib/concurrent-ruby/concurrent/utility/engine')
 
 no_path = ENV['NO_PATH']
 options = no_path ? {} : { path: '.' }
@@ -11,7 +12,7 @@ gem 'concurrent-ruby-edge', Concurrent::EDGE_VERSION, options
 gem 'concurrent-ruby-ext', Concurrent::VERSION, options.merge(platform: :mri)
 
 group :development do
-  gem 'rake', '~> 12.0'
+  gem 'rake', (Concurrent.ruby_version :<, 2, 2, 0) ? '~> 12.0' : '~> 13.0'
   gem 'rake-compiler', '~> 1.0', '>= 1.0.7'
   gem 'rake-compiler-dock', '~> 0.7.0'
   gem 'pry', '~> 0.11', platforms: :mri

data/README.md

@@ -253,6 +253,9 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 *   [ErlangActor](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ErlangActor.html)
     Actor implementation which precisely matches Erlang actor behaviour. 
     Requires at least Ruby 2.1 otherwise it's not loaded.
+*   [WrappingExecutor](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/WrappingExecutor.html) 
+    A delegating executor which modifies each task before the task is given to 
+    the target executor it delegates to.
 
 ## Supported Ruby versions
 

data/Rakefile

@@ -1,5 +1,6 @@
-require_relative 'lib/concurrent/version'
-require_relative 'lib/concurrent/utility/engine'
+require_relative 'lib/concurrent-ruby/concurrent/version'
+require_relative 'lib/concurrent-ruby-edge/concurrent/edge/version'
+require_relative 'lib/concurrent-ruby/concurrent/utility/engine'
 
 if Concurrent.ruby_version :<, 2, 0, 0
   # @!visibility private
@@ -16,9 +17,11 @@ edge_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-edge.
 
 require 'rake/javaextensiontask'
 
+ENV['JRUBY_HOME'] = ENV['CONCURRENT_JRUBY_HOME'] if ENV['CONCURRENT_JRUBY_HOME'] && !Concurrent.on_jruby?
+
 Rake::JavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
   ext.ext_dir = 'ext/concurrent-ruby'
-  ext.lib_dir = 'lib/concurrent'
+  ext.lib_dir = 'lib/concurrent-ruby/concurrent'
 end
 
 unless Concurrent.on_jruby?
@@ -26,7 +29,7 @@ unless Concurrent.on_jruby?
 
   Rake::ExtensionTask.new('concurrent_ruby_ext', ext_gemspec) do |ext|
     ext.ext_dir        = 'ext/concurrent-ruby-ext'
-    ext.lib_dir        = 'lib/concurrent'
+    ext.lib_dir        = 'lib/concurrent-ruby/concurrent'
     ext.source_pattern = '*.{c,h}'
 
     ext.cross_compile  = true
@@ -43,7 +46,7 @@ namespace :repackage do
       sh 'bundle package'
 
       # build only the jar file not the whole gem for java platform, the jar is part the concurrent-ruby-x.y.z.gem
-      Rake::Task['lib/concurrent/concurrent_ruby.jar'].invoke
+      Rake::Task['lib/concurrent-ruby/concurrent/concurrent_ruby.jar'].invoke
 
       # build all gem files
       RakeCompilerDock.sh 'bundle install --local && bundle exec rake cross native package --trace'
@@ -58,7 +61,7 @@ Gem::PackageTask.new(core_gemspec) {} if core_gemspec
 Gem::PackageTask.new(ext_gemspec) {} if ext_gemspec && !Concurrent.on_jruby?
 Gem::PackageTask.new(edge_gemspec) {} if edge_gemspec
 
-CLEAN.include('lib/concurrent/2.*', 'lib/concurrent/*.jar')
+CLEAN.include('lib/concurrent-ruby/concurrent/2.*', 'lib/concurrent-ruby/concurrent/*.jar')
 
 begin
   require 'rspec'
@@ -163,8 +166,8 @@ begin
             '--output-dir', output_dir,
             '--main', 'tmp/README.md',
             *common_yard_options)
-        yard.files = ['./lib/**/*.rb',
-                      './lib-edge/**/*.rb',
+        yard.files = ['./lib/concurrent-ruby/**/*.rb',
+                      './lib/concurrent-ruby-edge/**/*.rb',
                       './ext/concurrent_ruby_ext/**/*.c',
                       '-',
                       'docs-source/thread_pools.md',
@@ -173,7 +176,9 @@ begin
                       'LICENSE.md',
                       'CHANGELOG.md']
       end
-      Rake::Task[name].prerequisites.push removal_name, 'yard:eval_md', 'yard:update_readme'
+      Rake::Task[name].prerequisites.push removal_name,
+                                          # 'yard:eval_md',
+                                          'yard:update_readme'
     end
 
     define_yard_task.call current_yard_version_name
@@ -227,8 +232,8 @@ task :release => ['release:checks', 'release:build', 'release:test', 'release:pu
 namespace :release do
   # Depends on environment of @pitr-ch
 
-  mri_version   = '2.5.1'
-  jruby_version = 'jruby-9.1.17.1'
+  mri_version   = '2.6.5'
+  jruby_version = 'jruby-9.2.9.0'
 
   task :checks => "yard:#{current_yard_version_name}:uptodate" do
     Dir.chdir(__dir__) do

data/lib/{concurrent → concurrent-ruby/concurrent}/array.rb

@@ -10,11 +10,11 @@ module Concurrent
   #   or writing at a time. This includes iteration methods like `#each`.
   #
   #   @note `a += b` is **not** a **thread-safe** operation on
-  #   `Concurrent::Array`. It reads array `a`, then it creates new `Concurrent::Array`
-  #   which is concatenation of `a` and `b`, then it writes the concatenation to `a`.
-  #   The read and write are independent operations they do not form a single atomic
-  #   operation therefore when two `+=` operations are executed concurrently updates
-  #   may be lost. Use `#concat` instead.
+  #     `Concurrent::Array`. It reads array `a`, then it creates new `Concurrent::Array`
+  #     which is concatenation of `a` and `b`, then it writes the concatenation to `a`.
+  #     The read and write are independent operations they do not form a single atomic
+  #     operation therefore when two `+=` operations are executed concurrently updates
+  #     may be lost. Use `#concat` instead.
   #
   #   @see http://ruby-doc.org/core-2.2.0/Array.html Ruby standard library `Array`
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atom.rb

@@ -18,7 +18,7 @@ require 'concurrent/synchronization'
 #     uncoordinated, *synchronous* change of individual values. Best used when
 #     the value will undergo frequent reads but only occasional, though complex,
 #     updates. Suitable when the result of an update must be known immediately.
-#   * *{Concurrent::AtomicReference}:* A simple object reference that can be
+#   * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
 #     atomically. Updates are synchronous but fast. Best used when updates a
 #     simple set operations. Not suitable when updates are complex.
 #     {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/atomic_boolean.rb

@@ -41,13 +41,13 @@ module Concurrent
   #
   #   Explicitly sets the value to true.
   #
-  #   @return [Boolean] true is value has changed, otherwise false
+  #   @return [Boolean] true if value has changed, otherwise false
 
   # @!macro atomic_boolean_method_make_false
   #
   #   Explicitly sets the value to false.
   #
-  #   @return [Boolean] true is value has changed, otherwise false
+  #   @return [Boolean] true if value has changed, otherwise false
 
   ###################################################################
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/count_down_latch.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/atomic/mutex_count_down_latch'
 require 'concurrent/atomic/java_count_down_latch'
-require 'concurrent/utility/engine'
 
 module Concurrent
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/ruby_thread_local_var.rb

@@ -32,12 +32,38 @@ module Concurrent
     FREE   = []
     LOCK   = Mutex.new
     ARRAYS = {} # used as a hash set
+    # noinspection RubyClassVariableUsageInspection
     @@next = 0
-    private_constant :FREE, :LOCK, :ARRAYS
+    QUEUE  = Queue.new
+    THREAD = Thread.new do
+      while true
+        method, i = QUEUE.pop
+        case method
+        when :thread_local_finalizer
+          LOCK.synchronize do
+            FREE.push(i)
+            # The cost of GC'ing a TLV is linear in the number of threads using TLVs
+            # But that is natural! More threads means more storage is used per TLV
+            # So naturally more CPU time is required to free more storage
+            ARRAYS.each_value do |array|
+              array[i] = nil
+            end
+          end
+        when :thread_finalizer
+          LOCK.synchronize do
+            # The thread which used this thread-local array is now gone
+            # So don't hold onto a reference to the array (thus blocking GC)
+            ARRAYS.delete(i)
+          end
+        end
+      end
+    end
+
+    private_constant :FREE, :LOCK, :ARRAYS, :QUEUE, :THREAD
 
     # @!macro thread_local_var_method_get
     def value
-      if array = get_threadlocal_array
+      if (array = get_threadlocal_array)
         value = array[@index]
         if value.nil?
           default
@@ -57,10 +83,10 @@ module Concurrent
       # We could keep the thread-local arrays in a hash, keyed by Thread
       # But why? That would require locking
       # Using Ruby's built-in thread-local storage is faster
-      unless array = get_threadlocal_array(me)
+      unless (array = get_threadlocal_array(me))
         array = set_threadlocal_array([], me)
         LOCK.synchronize { ARRAYS[array.object_id] = array }
-        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
+        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array.object_id))
       end
       array[@index] = (value.nil? ? NULL : value)
       value
@@ -69,6 +95,7 @@ module Concurrent
     protected
 
     # @!visibility private
+    # noinspection RubyClassVariableUsageInspection
     def allocate_storage
       @index = LOCK.synchronize do
         FREE.pop || begin
@@ -77,37 +104,19 @@ module Concurrent
           result
         end
       end
-      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
+      ObjectSpace.define_finalizer(self, self.class.thread_local_finalizer(@index))
     end
 
     # @!visibility private
-    def self.threadlocal_finalizer(index)
-      proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            FREE.push(index)
-            # The cost of GC'ing a TLV is linear in the number of threads using TLVs
-            # But that is natural! More threads means more storage is used per TLV
-            # So naturally more CPU time is required to free more storage
-            ARRAYS.each_value do |array|
-              array[index] = nil
-            end
-          end
-        end
-      end
+    def self.thread_local_finalizer(index)
+      # avoid error: can't be called from trap context
+      proc { QUEUE.push [:thread_local_finalizer, index] }
     end
 
     # @!visibility private
-    def self.thread_finalizer(array)
-      proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            # The thread which used this thread-local array is now gone
-            # So don't hold onto a reference to the array (thus blocking GC)
-            ARRAYS.delete(array.object_id)
-          end
-        end
-      end
+    def self.thread_finalizer(id)
+      # avoid error: can't be called from trap context
+      proc { QUEUE.push [:thread_finalizer, id] }
     end
 
     private
@@ -136,21 +145,22 @@ module Concurrent
     # This exists only for use in testing
     # @!visibility private
     def value_for(thread)
-      if array = get_threadlocal_array(thread)
+      if (array = get_threadlocal_array(thread))
         value = array[@index]
         if value.nil?
-          default_for(thread)
+          get_default
         elsif value.equal?(NULL)
           nil
         else
           value
         end
       else
-        default_for(thread)
+        get_default
       end
     end
 
-    def default_for(thread)
+    # @!visibility private
+    def get_default
       if @default_block
         raise "Cannot use default_for with default block"
       else

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/thread_local_var.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/atomic/ruby_thread_local_var'
 require 'concurrent/atomic/java_thread_local_var'
-require 'concurrent/utility/engine'
 
 module Concurrent
 

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/non_concurrent_priority_queue.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/collection/java_non_concurrent_priority_queue'
 require 'concurrent/collection/ruby_non_concurrent_priority_queue'
-require 'concurrent/utility/engine'
 
 module Concurrent
   module Collection

data/lib/{concurrent → concurrent-ruby/concurrent}/concern/dereferenceable.rb

@@ -37,8 +37,8 @@ module Concurrent
       #   returning data to the caller (dereferencing).
       #
       #   @note Most classes that include this module will call `#set_deref_options`
-      #   from within the constructor, thus allowing these options to be set at
-      #   object creation.
+      #     from within the constructor, thus allowing these options to be set at
+      #     object creation.
       #
       #   @param [Hash] opts the options defining dereference behavior.
       #   @option opts [String] :dup_on_deref (false) call `#dup` before returning the data

data/lib/{concurrent → concurrent-ruby/concurrent}/configuration.rb

@@ -3,13 +3,14 @@ require 'concurrent/delay'
 require 'concurrent/errors'
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/concern/logging'
+require 'concurrent/concern/deprecation'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/cached_thread_pool'
-require 'concurrent/utility/at_exit'
 require 'concurrent/utility/processor_counter'
 
 module Concurrent
   extend Concern::Logging
+  extend Concern::Deprecation
 
   autoload :Options, 'concurrent/options'
   autoload :TimerSet, 'concurrent/executor/timer_set'
@@ -97,15 +98,15 @@ module Concurrent
   end
 
   # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
+  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor }
   private_constant :GLOBAL_FAST_EXECUTOR
 
   # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
+  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor }
   private_constant :GLOBAL_IO_EXECUTOR
 
   # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
+  GLOBAL_TIMER_SET = Delay.new { TimerSet.new }
   private_constant :GLOBAL_TIMER_SET
 
   # @!visibility private
@@ -115,7 +116,7 @@ module Concurrent
   # Disables AtExit handlers including pool auto-termination handlers.
   # When disabled it will be the application programmer's responsibility
   # to ensure that the handlers are shutdown properly prior to application
-  # exit by calling {AtExit.run} method.
+  # exit by calling `AtExit.run` method.
   #
   # @note this option should be needed only because of `at_exit` ordering
   #   issues which may arise when running some of the testing frameworks.
@@ -125,9 +126,10 @@ module Concurrent
   # @note This method should *never* be called
   #   from within a gem. It should *only* be used from within the main
   #   application and even then it should be used only when necessary.
-  # @see AtExit
+  # @deprecated Has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841.
+  #
   def self.disable_at_exit_handlers!
-    AtExit.enabled = false
+    deprecated "Method #disable_at_exit_handlers! has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841."
   end
 
   # Global thread pool optimized for short, fast *operations*.
@@ -171,14 +173,16 @@ module Concurrent
         auto_terminate:  opts.fetch(:auto_terminate, true),
         idletime:        60, # 1 minute
         max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "fast"
     )
   end
 
   def self.new_io_executor(opts = {})
     CachedThreadPool.new(
         auto_terminate:  opts.fetch(:auto_terminate, true),
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "io"
     )
   end
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/abstract_executor_service.rb

@@ -1,7 +1,7 @@
 require 'concurrent/errors'
+require 'concurrent/concern/deprecation'
 require 'concurrent/executor/executor_service'
 require 'concurrent/synchronization'
-require 'concurrent/utility/at_exit'
 
 module Concurrent
 
@@ -9,6 +9,7 @@ module Concurrent
   # @!visibility private
   class AbstractExecutorService < Synchronization::LockableObject
     include ExecutorService
+    include Concern::Deprecation
 
     # The set of possible fallback policies that may be set at thread pool creation.
     FALLBACK_POLICIES = [:abort, :discard, :caller_runs].freeze
@@ -16,10 +17,20 @@ module Concurrent
     # @!macro executor_service_attr_reader_fallback_policy
     attr_reader :fallback_policy
 
+    attr_reader :name
+
     # Create a new thread pool.
-    def initialize(*args, &block)
+    def initialize(opts = {}, &block)
       super(&nil)
-      synchronize { ns_initialize(*args, &block) }
+      synchronize do
+        @auto_terminate = opts.fetch(:auto_terminate, true)
+        @name = opts.fetch(:name) if opts.key?(:name)
+        ns_initialize(opts, &block)
+      end
+    end
+
+    def to_s
+      name ? "#{super[0..-2]} name: #{name}>" : super
     end
 
     # @!macro executor_service_method_shutdown
@@ -54,12 +65,12 @@ module Concurrent
 
     # @!macro executor_service_method_auto_terminate_question
     def auto_terminate?
-      synchronize { ns_auto_terminate? }
+      synchronize { @auto_terminate }
     end
 
     # @!macro executor_service_method_auto_terminate_setter
     def auto_terminate=(value)
-      synchronize { self.ns_auto_terminate = value }
+      deprecated "Method #auto_terminate= has no effect. Set :auto_terminate option when executor is initialized."
     end
 
     private
@@ -110,25 +121,8 @@ module Concurrent
     end
 
     def ns_auto_terminate?
-      !!@auto_terminate
+      @auto_terminate
     end
 
-    def ns_auto_terminate=(value)
-      case value
-      when true
-        AtExit.add(self) { terminate_at_exit }
-        @auto_terminate = true
-      when false
-        AtExit.delete(self)
-        @auto_terminate = false
-      else
-        raise ArgumentError
-      end
-    end
-
-    def terminate_at_exit
-      kill # TODO be gentle first
-      wait_for_termination(10)
-    end
   end
 end