concurrent-ruby 1.1.6 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 649de1a5e5c7c82652bd6ad21496f2c1061d7c75517271d8ca30c3ceb9c49038
-  data.tar.gz: 6274d2cd2dcda660a1e34436547eca26d6c74d03e9a527d7ce5d1a9f3f72f4be
+  metadata.gz: 4e26dce842bfb7973c28f13017d50c3e729a9261f48427920db279055c4d089b
+  data.tar.gz: 501e9d485d4683657b49cd5820ef0462ce91133ad163ba9e790f254892d1e533
 SHA512:
-  metadata.gz: 2adbf28bdf7034295709496964e8e70d22f59bf058bf18ca005c2ce536627160538de6c510ea1f39893de0ad90b2fb50d6f35c848c97f58bd8f71ff8d9e57fc2
-  data.tar.gz: 1cbc384488e0f70d19d742e54c34dbd7abfaffe89f75230b2f5b80d2ae4d161b731666ce6b64e8f5adeb561b6d32191ce6bd679e05d6bd9eec91b869ee379b2f
+  metadata.gz: 7f894d3207ce129044970321fabe750cc4b9744a876f354dd791d045fb4ffed1d0a5a9a50dcb1ab0ca36df705b6b7578fe7eded26bcaa3dbeb0c7a12e655596c
+  data.tar.gz: 3cb4ccbbf13e2f73987eda48a32b444d7330c53a668ddef2fd4a73841caf18805d68cec45273a02de2c10087da4a4ce063c01b1bdccb96d4668b10cc4af79f88

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## Current
 
+## Release v1.1.9 (5 Jun 2021)
+
+concurrent-ruby:
+
+* (#866) Child promise state not set to :pending immediately after #execute when parent has completed 
+* (#905, #872) Fix RubyNonConcurrentPriorityQueue#delete method
+* (2df0337d) Make sure locks are not shared on shared when objects are dup/cloned
+* (#900, #906, #796, #847, #911) Fix Concurrent::Set tread-safety issues on CRuby
+* (#907) Add new ConcurrentMap backend for TruffleRuby
+
+## Release v1.1.8 (20 January 2021)
+
+concurrent-ruby:
+
+* (#885) Fix race condition in TVar for stale reads 
+* (#884) RubyThreadLocalVar: Do not iterate over hash which might conflict with new pair addition
+
+## Release v1.1.7 (6 August 2020)
+
+concurrent-ruby:
+
+* (#879) Consider falsy value on `Concurrent::Map#compute_if_absent` for fast non-blocking path
+* (#876) Reset Async queue on forking, makes Async fork-safe
+* (#856) Avoid running problematic code in RubyThreadLocalVar on MRI that occasionally results in segfault
+* (#853) Introduce ThreadPoolExecutor without a Queue
+
 ## Release v1.1.6, edge v0.6.0 (10 Feb 2020)
 
 concurrent-ruby:

data/Gemfile

@@ -14,7 +14,7 @@ gem 'concurrent-ruby-ext', Concurrent::VERSION, options.merge(platform: :mri)
 group :development do
   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 'rake-compiler-dock', '~> 1.0'
   gem 'pry', '~> 0.11', platforms: :mri
 end
 

data/{LICENSE.md → LICENSE.txt}

@@ -1,23 +1,21 @@
-```
 Copyright (c) Jerry D'Antonio -- released under the MIT license.
 
-http://www.opensource.org/licenses/mit-license.php  
+http://www.opensource.org/licenses/mit-license.php
 
-Permission is hereby granted, free of charge, to any person obtaining a copy  
-of this software and associated documentation files (the "Software"), to deal  
-in the Software without restriction, including without limitation the rights  
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
-copies of the Software, and to permit persons to whom the Software is  
-furnished to do so, subject to the following conditions:  
- 
-The above copyright notice and this permission notice shall be included in  
-all copies or substantial portions of the Software.  
- 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
-THE SOFTWARE. 
-```
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -105,9 +105,9 @@ We also have a [IRC (gitter)](https://gitter.im/ruby-concurrency/concurrent-ruby
 Collection classes that were originally part of the (deprecated) `thread_safe` gem:
 
 *   [Array](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Array.html) A thread-safe
-    subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
+    subclass of Ruby's standard [Array](http://ruby-doc.org/core/Array.html).
 *   [Hash](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Hash.html) A thread-safe
-    subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
+    subclass of Ruby's standard [Hash](http://ruby-doc.org/core/Hash.html).
 *   [Set](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Set.html) A thread-safe
     subclass of Ruby's standard [Set](http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html).
 *   [Map](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Map.html) A hash-like object
@@ -122,7 +122,7 @@ Value objects inspired by other languages:
     immutable object representing an optional value, based on 
     [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
 
-Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
+Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core/Struct.html):
 
 *   [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ImmutableStruct.html)
     Immutable struct where values are set at construction and cannot be changed later.
@@ -353,19 +353,43 @@ and load the appropriate C extensions.
 No gems should depend on `concurrent-ruby-ext`. Doing so will force C extensions on your users. The
 best practice is to depend on `concurrent-ruby` and let users to decide if they want C extensions.
 
+## Building the gem
+
+### Requirements
+
+* Recent CRuby
+* JRuby, `rbenv install jruby-9.2.17.0`
+* Set env variable `CONCURRENT_JRUBY_HOME` to point to it, e.g. `/usr/local/opt/rbenv/versions/jruby-9.2.17.0`
+* Install Docker, required for Windows builds
+
+### Publishing the Gem
+
+* Update`version.rb`
+* Update the CHANGELOG
+* Update the Yard documentation
+    - Add the new version to `docs-source/signpost.md`. Needs to be done only if there are visible changes in the
+      documentation.
+    - Run `bundle exec rake yard` to update the master documentation and signpost.
+    - Run `bundle exec rake yard:<new-version>` to add or update the documentation of the new version.
+* Commit (and push) the changes.
+* Use `be rake release` to release the gem. It consists
+  of `['release:checks', 'release:build', 'release:test', 'release:publish']` steps. It will ask at the end before
+  publishing anything. Steps can also be executed individually.
+
 ## Maintainers
 
-*   [Petr Chalupa](https://github.com/pitr-ch) (lead maintainer, point-of-contact)
-*   [Jerry D'Antonio](https://github.com/jdantonio) (creator)
-*   [Chris Seaton](https://github.com/chrisseaton)
+*   [Petr Chalupa](https://github.com/pitr-ch) — Lead maintainer, point-of-contact.
+*   [Chris Seaton](https://github.com/chrisseaton) —
+    If Petr is not available Chris can help or poke Petr to pay attention where it is needed.
 
 ### Special Thanks to
 
+*   [Jerry D'Antonio](https://github.com/jdantonio) for creating the gem
 *   [Brian Durand](https://github.com/bdurand) for the `ref` gem
 *   [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
 *   [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
 
-and to the past maintainers
+to the past maintainers
 
 *   [Michele Della Torre](https://github.com/mighe)
 *   [Paweł Obrok](https://github.com/obrok)

data/Rakefile

@@ -49,7 +49,9 @@ namespace :repackage do
       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'
+      %w[x86-mingw32 x64-mingw32].each do |plat|
+        RakeCompilerDock.sh "bundle install --local && bundle exec rake native:#{plat} gem --trace", platform: plat
+      end
     end
   end
 end
@@ -133,7 +135,7 @@ begin
     task :update_readme do
       Dir.chdir __dir__ do
         content = File.read(File.join('README.md')).
-            gsub(/\[([\w ]+)\]\(http:\/\/ruby-concurrency\.github\.io\/concurrent-ruby\/master\/.*\)/) do |_|
+          gsub(/\[([\w ]+)\]\(http:\/\/ruby-concurrency\.github\.io\/concurrent-ruby\/master\/.*\)/) do |_|
           case $1
           when 'LockFreeLinkedSet'
             "{Concurrent::Edge::#{$1} #{$1}}"
@@ -163,9 +165,9 @@ begin
       desc "* of #{name} into subdir #{name}"
       YARD::Rake::YardocTask.new(name) do |yard|
         yard.options.push(
-            '--output-dir', output_dir,
-            '--main', 'tmp/README.md',
-            *common_yard_options)
+          '--output-dir', output_dir,
+          '--main', 'tmp/README.md',
+          *common_yard_options)
         yard.files = ['./lib/concurrent-ruby/**/*.rb',
                       './lib/concurrent-ruby-edge/**/*.rb',
                       './ext/concurrent_ruby_ext/**/*.c',
@@ -173,7 +175,7 @@ begin
                       'docs-source/thread_pools.md',
                       'docs-source/promises.out.md',
                       'docs-source/medium-example.out.rb',
-                      'LICENSE.md',
+                      'LICENSE.txt',
                       'CHANGELOG.md']
       end
       Rake::Task[name].prerequisites.push removal_name,
@@ -187,9 +189,9 @@ begin
     desc "* signpost for versions"
     YARD::Rake::YardocTask.new(:signpost) do |yard|
       yard.options.push(
-          '--output-dir', 'docs',
-          '--main', 'docs-source/signpost.md',
-          *common_yard_options)
+        '--output-dir', 'docs',
+        '--main', 'docs-source/signpost.md',
+        *common_yard_options)
       yard.files = ['no-lib']
     end
 
@@ -204,7 +206,7 @@ begin
               sh 'diff -r docs/ docs-copy/' do |ok, res|
                 unless ok
                   begin
-                    STDOUT.puts 'Command failed. Continue? (y/n)'
+                    STDOUT.puts "yard:#{name} is not properly generated and committed.", "Continue? (y/n)"
                     input = STDIN.gets.strip.downcase
                   end until %w(y n).include?(input)
                   exit 1 if input == 'n'
@@ -232,15 +234,13 @@ task :release => ['release:checks', 'release:build', 'release:test', 'release:pu
 namespace :release do
   # Depends on environment of @pitr-ch
 
-  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
       sh 'test -z "$(git status --porcelain)"' do |ok, res|
         unless ok
           begin
-            STDOUT.puts 'Command failed. Continue? (y/n)'
+            status = `git status --porcelain`
+            STDOUT.puts 'There are local changes that you might want to commit.', status, 'Continue? (y/n)'
             input = STDIN.gets.strip.downcase
           end until %w(y n).include?(input)
           exit 1 if input == 'n'
@@ -248,10 +248,10 @@ namespace :release do
       end
       sh 'git fetch'
       sh 'test $(git show-ref --verify --hash refs/heads/master) = ' +
-             '$(git show-ref --verify --hash refs/remotes/origin/master)' do |ok, res|
+           '$(git show-ref --verify --hash refs/remotes/origin/master)' do |ok, res|
         unless ok
           begin
-            STDOUT.puts 'Command failed. Continue? (y/n)'
+            STDOUT.puts 'Local master branch is not pushed to origin.', 'Continue? (y/n)'
             input = STDIN.gets.strip.downcase
           end until %w(y n).include?(input)
           exit 1 if input == 'n'
@@ -268,6 +268,12 @@ namespace :release do
     Dir.chdir(__dir__) do
       old = ENV['RBENV_VERSION']
 
+      mri_version   = `ruby -e 'puts RUBY_VERSION'`.chomp
+      jruby_version = File.basename(ENV['CONCURRENT_JRUBY_HOME'])
+
+      puts "Using following version:"
+      pp mri_version: mri_version, jruby_version: jruby_version
+
       ENV['RBENV_VERSION'] = mri_version
       sh 'rbenv version'
       sh 'bundle exec rake spec:installed'
@@ -290,19 +296,19 @@ namespace :release do
 
     task :ask do
       begin
-        STDOUT.puts 'Do you want to publish anything? (y/n)'
+        STDOUT.puts 'Do you want to publish anything now? (y/n)'
         input = STDIN.gets.strip.downcase
       end until %w(y n).include?(input)
       exit 1 if input == 'n'
       begin
-        STDOUT.puts 'Do you want to publish edge? (y/n)'
+        STDOUT.puts 'It will publish `concurrent-ruby`. Do you want to publish `concurrent-ruby-edge`? (y/n)'
         input = STDIN.gets.strip.downcase
       end until %w(y n).include?(input)
       publish_edge = input == 'y'
     end
 
     desc '** tag HEAD with current version and push to github'
-    task :tag do
+    task :tag => :ask do
       Dir.chdir(__dir__) do
         sh "git tag v#{Concurrent::VERSION}"
         sh "git push origin v#{Concurrent::VERSION}"
@@ -312,7 +318,7 @@ namespace :release do
     end
 
     desc '** push all *.gem files to rubygems'
-    task :rubygems do
+    task :rubygems => :ask do
       Dir.chdir(__dir__) do
         sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
         sh "gem push pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem" if publish_edge
@@ -324,9 +330,10 @@ namespace :release do
 
     desc '** print post release steps'
     task :post_steps do
-      puts 'Manually: create a release on GitHub with relevant changelog part'
-      puts 'Manually: send email same as release with relevant changelog part'
-      puts 'Manually: tweet'
+      # TODO: (petr 05-Jun-2021) automate and renew the process
+      # puts 'Manually: create a release on GitHub with relevant changelog part'
+      # puts 'Manually: send email same as release with relevant changelog part'
+      # puts 'Manually: tweet'
     end
   end
 end

data/lib/concurrent-ruby/concurrent/array.rb

@@ -16,7 +16,7 @@ module Concurrent
   #     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`
+  #   @see http://ruby-doc.org/core/Array.html Ruby standard library `Array`
 
   # @!macro internal_implementation_note
   ArrayImplementation = case

data/lib/concurrent-ruby/concurrent/async.rb

@@ -58,26 +58,6 @@ module Concurrent
   # end
   # ```
   #
-  # When defining a constructor it is critical that the first line be a call to
-  # `super` with no arguments. The `super` method initializes the background
-  # thread and other asynchronous components.
-  #
-  # ```
-  # class BackgroundLogger
-  #   include Concurrent::Async
-  #
-  #   def initialize(level)
-  #     super()
-  #     @logger = Logger.new(STDOUT)
-  #     @logger.level = level
-  #   end
-  #
-  #   def info(msg)
-  #     @logger.info(msg)
-  #   end
-  # end
-  # ```
-  #
   # Mixing this module into a class provides each object two proxy methods:
   # `async` and `await`. These methods are thread safe with respect to the
   # enclosing object. The former proxy allows methods to be called
@@ -309,6 +289,7 @@ module Concurrent
         @delegate = delegate
         @queue = []
         @executor = Concurrent.global_io_executor
+        @ruby_pid = $$
       end
 
       # Delegates method calls to the wrapped object.
@@ -326,6 +307,7 @@ module Concurrent
 
         ivar = Concurrent::IVar.new
         synchronize do
+          reset_if_forked
           @queue.push [ivar, method, args, block]
           @executor.post { perform } if @queue.length == 1
         end
@@ -361,6 +343,13 @@ module Concurrent
           end
         end
       end
+
+      def reset_if_forked
+        if $$ != @ruby_pid
+          @queue.clear
+          @ruby_pid = $$
+        end
+      end
     end
     private_constant :AsyncDelegator
 

data/lib/concurrent-ruby/concurrent/atomic/ruby_thread_local_var.rb

@@ -28,38 +28,27 @@ module Concurrent
     # But when a Thread is GC'd, we need to drop the reference to its thread-local
     #   array, so we don't leak memory
 
-    # @!visibility private
-    FREE   = []
-    LOCK   = Mutex.new
-    ARRAYS = {} # used as a hash set
-    # noinspection RubyClassVariableUsageInspection
-    @@next = 0
-    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
+    FREE                = []
+    LOCK                = Mutex.new
+    THREAD_LOCAL_ARRAYS = {} # used as a hash set
+
+    # synchronize when not on MRI
+    # on MRI using lock in finalizer leads to "can't be called from trap context" error
+    # so the code is carefully written to be tread-safe on MRI relying on GIL
+
+    if Concurrent.on_cruby?
+      # @!visibility private
+      def self.semi_sync(&block)
+        block.call
+      end
+    else
+      # @!visibility private
+      def self.semi_sync(&block)
+        LOCK.synchronize(&block)
       end
     end
 
-    private_constant :FREE, :LOCK, :ARRAYS, :QUEUE, :THREAD
+    private_constant :FREE, :LOCK, :THREAD_LOCAL_ARRAYS
 
     # @!macro thread_local_var_method_get
     def value
@@ -85,7 +74,7 @@ module Concurrent
       # Using Ruby's built-in thread-local storage is faster
       unless (array = get_threadlocal_array(me))
         array = set_threadlocal_array([], me)
-        LOCK.synchronize { ARRAYS[array.object_id] = array }
+        self.class.semi_sync { THREAD_LOCAL_ARRAYS[array.object_id] = array }
         ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array.object_id))
       end
       array[@index] = (value.nil? ? NULL : value)
@@ -95,32 +84,53 @@ module Concurrent
     protected
 
     # @!visibility private
-    # noinspection RubyClassVariableUsageInspection
     def allocate_storage
-      @index = LOCK.synchronize do
-        FREE.pop || begin
-          result = @@next
-          @@next += 1
-          result
-        end
-      end
+      @index = FREE.pop || next_index
+
       ObjectSpace.define_finalizer(self, self.class.thread_local_finalizer(@index))
     end
 
     # @!visibility private
     def self.thread_local_finalizer(index)
-      # avoid error: can't be called from trap context
-      proc { QUEUE.push [:thread_local_finalizer, index] }
+      proc do
+        semi_sync do
+          # 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
+          #
+          # DO NOT use each_value which might conflict with new pair assignment
+          # into the hash in #value= method
+          THREAD_LOCAL_ARRAYS.values.each { |array| array[index] = nil }
+          # free index has to be published after the arrays are cleared
+          FREE.push(index)
+        end
+      end
     end
 
     # @!visibility private
     def self.thread_finalizer(id)
-      # avoid error: can't be called from trap context
-      proc { QUEUE.push [:thread_finalizer, id] }
+      proc do
+        semi_sync 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)
+          THREAD_LOCAL_ARRAYS.delete(id)
+        end
+      end
     end
 
     private
 
+    # noinspection RubyClassVariableUsageInspection
+    @@next = 0
+    # noinspection RubyClassVariableUsageInspection
+    def next_index
+      LOCK.synchronize do
+        result = @@next
+        @@next += 1
+        result
+      end
+    end
+
     if Thread.instance_methods.include?(:thread_variable_get)
 
       def get_threadlocal_array(thread = Thread.current)

data/lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb

@@ -19,7 +19,7 @@ module Concurrent
       end
 
       def compute_if_absent(key)
-        if stored_value = _get(key) # fast non-blocking path for the most likely case
+        if NULL != (stored_value = @backend.fetch(key, NULL)) # fast non-blocking path for the most likely case
           stored_value
         else
           @write_lock.synchronize { super }

data/lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb

@@ -0,0 +1,14 @@
+module Concurrent
+
+  # @!visibility private
+  module Collection
+
+    # @!visibility private
+    class TruffleRubyMapBackend < TruffleRuby::ConcurrentMap
+      def initialize(options = nil)
+        options ||= {}
+        super(initial_capacity: options[:initial_capacity], load_factor: options[:load_factor])
+      end
+    end
+  end
+end

data/lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb

@@ -30,7 +30,7 @@ module Concurrent
           if @queue[k] == item
             swap(k, @length)
             @length -= 1
-            sink(k)
+            sink(k) || swim(k)
             @queue.pop
           else
             k += 1
@@ -126,12 +126,17 @@ module Concurrent
       # 
       # @!visibility private
       def sink(k)
+        success = false
+
         while (j = (2 * k)) <= @length do
           j += 1 if j < @length && ! ordered?(j, j+1)
           break if ordered?(k, j)
           swap(k, j)
+          success = true
           k = j
         end
+
+        success
       end
 
       # Percolate up to maintain heap invariant.
@@ -140,10 +145,15 @@ module Concurrent
       # 
       # @!visibility private
       def swim(k)
+        success = false
+
         while k > 1 && ! ordered?(k/2, k) do
           swap(k, k/2)
           k = k/2
+          success = true
         end
+
+        success
       end
     end
   end

data/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb

@@ -16,6 +16,9 @@ module Concurrent
   #   Default maximum number of seconds a thread in the pool may remain idle
   #   before being reclaimed.
 
+  # @!macro thread_pool_executor_constant_default_synchronous
+  #   Default value of the :synchronous option.
+
   # @!macro thread_pool_executor_attr_reader_max_length
   #   The maximum number of threads that may be created in the pool.
   #   @return [Integer] The maximum number of threads that may be created in the pool.
@@ -40,6 +43,10 @@ module Concurrent
   #   The number of seconds that a thread may be idle before being reclaimed.
   #   @return [Integer] The number of seconds that a thread may be idle before being reclaimed.
 
+  # @!macro thread_pool_executor_attr_reader_synchronous
+  #   Whether or not a value of 0 for :max_queue option means the queue must perform direct hand-off or rather unbounded queue.
+  #   @return [true, false]
+
   # @!macro thread_pool_executor_attr_reader_max_queue
   #   The maximum number of tasks that may be waiting in the work queue at any one time.
   #   When the queue size reaches `max_queue` subsequent tasks will be rejected in

data/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb

@@ -21,12 +21,18 @@ if Concurrent.on_jruby?
       # @!macro thread_pool_executor_constant_default_thread_timeout
       DEFAULT_THREAD_IDLETIMEOUT = 60
 
+      # @!macro thread_pool_executor_constant_default_synchronous
+      DEFAULT_SYNCHRONOUS = false
+
       # @!macro thread_pool_executor_attr_reader_max_length
       attr_reader :max_length
 
       # @!macro thread_pool_executor_attr_reader_max_queue
       attr_reader :max_queue
 
+      # @!macro thread_pool_executor_attr_reader_synchronous
+      attr_reader :synchronous
+
       # @!macro thread_pool_executor_method_initialize
       def initialize(opts = {})
         super(opts)
@@ -94,8 +100,10 @@ if Concurrent.on_jruby?
         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
+        @synchronous     = opts.fetch(:synchronous, DEFAULT_SYNCHRONOUS)
         @fallback_policy = opts.fetch(:fallback_policy, :abort)
 
+        raise ArgumentError.new("`synchronous` cannot be set unless `max_queue` is 0") if @synchronous && @max_queue > 0
         raise ArgumentError.new("`max_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if max_length < DEFAULT_MIN_POOL_SIZE
         raise ArgumentError.new("`max_threads` cannot be greater than #{DEFAULT_MAX_POOL_SIZE}") if max_length > DEFAULT_MAX_POOL_SIZE
         raise ArgumentError.new("`min_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if min_length < DEFAULT_MIN_POOL_SIZE
@@ -103,7 +111,11 @@ if Concurrent.on_jruby?
         raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICY_CLASSES.include?(@fallback_policy)
 
         if @max_queue == 0
-          queue = java.util.concurrent.LinkedBlockingQueue.new
+          if @synchronous
+            queue = java.util.concurrent.SynchronousQueue.new
+          else
+            queue = java.util.concurrent.LinkedBlockingQueue.new
+          end
         else
           queue = java.util.concurrent.LinkedBlockingQueue.new(@max_queue)
         end

data/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb

@@ -23,6 +23,9 @@ module Concurrent
     # @!macro thread_pool_executor_constant_default_thread_timeout
     DEFAULT_THREAD_IDLETIMEOUT = 60
 
+    # @!macro thread_pool_executor_constant_default_synchronous
+    DEFAULT_SYNCHRONOUS = false
+
     # @!macro thread_pool_executor_attr_reader_max_length
     attr_reader :max_length
 
@@ -35,6 +38,9 @@ module Concurrent
     # @!macro thread_pool_executor_attr_reader_max_queue
     attr_reader :max_queue
 
+    # @!macro thread_pool_executor_attr_reader_synchronous
+    attr_reader :synchronous
+
     # @!macro thread_pool_executor_method_initialize
     def initialize(opts = {})
       super(opts)
@@ -114,9 +120,11 @@ module Concurrent
       @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
+      @synchronous     = opts.fetch(:synchronous, DEFAULT_SYNCHRONOUS)
       @fallback_policy = opts.fetch(:fallback_policy, :abort)
-      raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
 
+      raise ArgumentError.new("`synchronous` cannot be set unless `max_queue` is 0") if @synchronous && @max_queue > 0
+      raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
       raise ArgumentError.new("`max_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if @max_length < DEFAULT_MIN_POOL_SIZE
       raise ArgumentError.new("`max_threads` cannot be greater than #{DEFAULT_MAX_POOL_SIZE}") if @max_length > DEFAULT_MAX_POOL_SIZE
       raise ArgumentError.new("`min_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if @min_length < DEFAULT_MIN_POOL_SIZE
@@ -201,6 +209,8 @@ module Concurrent
     #
     # @!visibility private
     def ns_enqueue(*args, &task)
+      return false if @synchronous
+      
       if !ns_limited_queue? || @queue.size < @max_queue
         @queue << [task, args]
         true

data/lib/concurrent-ruby/concurrent/executor/thread_pool_executor.rb

@@ -73,7 +73,8 @@ module Concurrent
     #   @option opts [Symbol] :fallback_policy (:abort) the policy for handling new
     #     tasks that are received when the queue size has reached
     #     `max_queue` or the executor has shut down
-    #
+    #   @option opts [Boolean] :synchronous (DEFAULT_SYNCHRONOUS) whether or not a value of 0
+    #     for :max_queue means the queue must perform direct hand-off rather than unbounded.
     #   @raise [ArgumentError] if `:max_threads` is less than one
     #   @raise [ArgumentError] if `:min_threads` is less than zero
     #   @raise [ArgumentError] if `:fallback_policy` is not one of the values specified

data/lib/concurrent-ruby/concurrent/hash.rb

@@ -10,7 +10,7 @@ module Concurrent
   #   or writing at a time. This includes iteration methods like `#each`,
   #   which takes the lock repeatedly when reading an item.
   #
-  #   @see http://ruby-doc.org/core-2.2.0/Hash.html Ruby standard library `Hash`
+  #   @see http://ruby-doc.org/core/Hash.html Ruby standard library `Hash`
 
   # @!macro internal_implementation_note
   HashImplementation = case

data/lib/concurrent-ruby/concurrent/immutable_struct.rb

@@ -5,7 +5,7 @@ module Concurrent
 
   # A thread-safe, immutable variation of Ruby's standard `Struct`.
   #
-  # @see http://ruby-doc.org/core-2.2.0/Struct.html Ruby standard library `Struct`
+  # @see http://ruby-doc.org/core/Struct.html Ruby standard library `Struct`
   module ImmutableStruct
     include Synchronization::AbstractStruct
 

data/lib/concurrent-ruby/concurrent/map.rb

@@ -15,7 +15,10 @@ module Concurrent
                         when Concurrent.on_cruby?
                           require 'concurrent/collection/map/mri_map_backend'
                           MriMapBackend
-                        when Concurrent.on_rbx? || Concurrent.on_truffleruby?
+                        when Concurrent.on_truffleruby? && defined?(::TruffleRuby::ConcurrentMap)
+                          require 'concurrent/collection/map/truffleruby_map_backend'
+                          TruffleRubyMapBackend
+                        when Concurrent.on_truffleruby? || Concurrent.on_rbx?
                           require 'concurrent/collection/map/atomic_reference_map_backend'
                           AtomicReferenceMapBackend
                         else
@@ -114,7 +117,7 @@ module Concurrent
     #   @return [true, false] true if deleted
     #   @!macro map.atomic_method
 
-
+    #
     def initialize(options = nil, &block)
       if options.kind_of?(::Hash)
         validate_options_hash!(options)
@@ -143,8 +146,15 @@ module Concurrent
       end
     end
 
+    # Set a value with key
+    # @param [Object] key
+    # @param [Object] value
+    # @return [Object] the new value
+    def []=(key, value)
+      super
+    end
+
     alias_method :get, :[]
-    # TODO (pitr-ch 30-Oct-2018): doc
     alias_method :put, :[]=
 
     # Get a value with key, or default_value when key is absent,

data/lib/concurrent-ruby/concurrent/mutable_struct.rb

@@ -6,7 +6,7 @@ module Concurrent
   # An thread-safe variation of Ruby's standard `Struct`. Values can be set at
   # construction or safely changed at any time during the object's lifecycle.
   #
-  # @see http://ruby-doc.org/core-2.2.0/Struct.html Ruby standard library `Struct`
+  # @see http://ruby-doc.org/core/Struct.html Ruby standard library `Struct`
   module MutableStruct
     include Synchronization::AbstractStruct
 
@@ -40,7 +40,7 @@ module Concurrent
     #   struct. Unset parameters default to nil. Passing more parameters than number of attributes
     #   will raise an `ArgumentError`.
     #
-    #   @see http://ruby-doc.org/core-2.2.0/Struct.html#method-c-new Ruby standard library `Struct#new`
+    #   @see http://ruby-doc.org/core/Struct.html#method-c-new Ruby standard library `Struct#new`
 
     # @!macro struct_values
     #

data/lib/concurrent-ruby/concurrent/promise.rb

@@ -250,6 +250,7 @@ module Concurrent
           realize(@promise_body)
         end
       else
+        compare_and_set_state(:pending, :unscheduled)
         @parent.execute
       end
       self

data/lib/concurrent-ruby/concurrent/set.rb

@@ -19,13 +19,19 @@ module Concurrent
   #
   #   @see http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html Ruby standard library `Set`
 
-
   # @!macro internal_implementation_note
   SetImplementation = case
                       when Concurrent.on_cruby?
-                        # Because MRI never runs code in parallel, the existing
-                        # non-thread-safe structures should usually work fine.
-                        ::Set
+                        # The CRuby implementation of Set is written in Ruby itself and is
+                        # not thread safe for certain methods.
+                        require 'monitor'
+                        require 'concurrent/thread_safe/util/data_structures'
+
+                        class CRubySet < ::Set
+                        end
+
+                        ThreadSafe::Util.make_synchronized_on_cruby CRubySet
+                        CRubySet
 
                       when Concurrent.on_jruby?
                         require 'jruby/synchronized'
@@ -33,6 +39,7 @@ module Concurrent
                         class JRubySet < ::Set
                           include JRuby::Synchronized
                         end
+
                         JRubySet
 
                       when Concurrent.on_rbx?
@@ -41,7 +48,8 @@ module Concurrent
 
                         class RbxSet < ::Set
                         end
-                        ThreadSafe::Util.make_synchronized_on_rbx Concurrent::RbxSet
+
+                        ThreadSafe::Util.make_synchronized_on_rbx RbxSet
                         RbxSet
 
                       when Concurrent.on_truffleruby?
@@ -50,7 +58,7 @@ module Concurrent
                         class TruffleRubySet < ::Set
                         end
 
-                        ThreadSafe::Util.make_synchronized_on_truffleruby Concurrent::TruffleRubySet
+                        ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubySet
                         TruffleRubySet
 
                       else

data/lib/concurrent-ruby/concurrent/settable_struct.rb

@@ -9,7 +9,7 @@ module Concurrent
   # 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://ruby-doc.org/core/Struct.html Ruby standard library `Struct`
   # @see http://en.wikipedia.org/wiki/Final_(Java) Java `final` keyword
   module SettableStruct
     include Synchronization::AbstractStruct

data/lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb

@@ -26,8 +26,8 @@ module Concurrent
     #   the classes using it. Use {Synchronization::Object} not this abstract class.
     #
     #   @note this object does not support usage together with
-    #     [`Thread#wakeup`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-wakeup)
-    #     and [`Thread#raise`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-raise).
+    #     [`Thread#wakeup`](http://ruby-doc.org/core/Thread.html#method-i-wakeup)
+    #     and [`Thread#raise`](http://ruby-doc.org/core/Thread.html#method-i-raise).
     #     `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `Synchronization::Object#wait` and
     #     `Thread#wakeup` will not work on all platforms.
     #

data/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb

@@ -32,6 +32,12 @@ module Concurrent
         @__Condition__ = ::ConditionVariable.new
       end
 
+      def initialize_copy(other)
+        super
+        @__Lock__      = ::Mutex.new
+        @__Condition__ = ::ConditionVariable.new
+      end
+
       protected
 
       def synchronize
@@ -61,6 +67,12 @@ module Concurrent
         @__Condition__ = @__Lock__.new_cond
       end
 
+      def initialize_copy(other)
+        super
+        @__Lock__      = ::Monitor.new
+        @__Condition__ = @__Lock__.new_cond
+      end
+
       protected
 
       def synchronize # TODO may be a problem with lock.synchronize { lock.wait }

data/lib/concurrent-ruby/concurrent/synchronization/rbx_lockable_object.rb

@@ -12,6 +12,12 @@ module Concurrent
         @__owner__   = nil
       end
 
+      def initialize_copy(other)
+        super
+        @__Waiters__ = []
+        @__owner__   = nil
+      end
+
       protected
 
       def synchronize(&block)

data/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb

@@ -12,12 +12,37 @@ end
 module Concurrent
   module ThreadSafe
     module Util
+      def self.make_synchronized_on_cruby(klass)
+        klass.class_eval do
+          def initialize(*args, &block)
+            @_monitor = Monitor.new
+            super
+          end
+
+          def initialize_copy(other)
+            # make sure a copy is not sharing a monitor with the original object!
+            @_monitor = Monitor.new
+            super
+          end
+        end
+
+        klass.superclass.instance_methods(false).each do |method|
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args)
+              monitor = @_monitor
+              monitor or raise("BUG: Internal monitor was not properly initialized. Please report this to the concurrent-ruby developers.")
+              monitor.synchronize { super }
+            end
+          RUBY
+        end
+      end
+
       def self.make_synchronized_on_rbx(klass)
         klass.class_eval do
           private
 
           def _mon_initialize
-            @_monitor = Monitor.new unless @_monitor # avoid double initialisation
+            @_monitor ||= Monitor.new # avoid double initialisation
           end
 
           def self.new(*args)

data/lib/concurrent-ruby/concurrent/thread_safe/util/striped64.rb

@@ -97,7 +97,7 @@ module Concurrent
             # TODO: this only adds padding after the :value slot, need to find a way to add padding before the slot
             # TODO (pitr-ch 28-Jul-2018): the padding instance vars may not be created
             # hide from yardoc in a method
-            attr_reader *(12.times.collect{ |i| "padding_#{i}".to_sym })
+            attr_reader :padding_0, :padding_1, :padding_2, :padding_3, :padding_4, :padding_5, :padding_6, :padding_7, :padding_8, :padding_9, :padding_10, :padding_11
           end
           padding
         end

data/lib/concurrent-ruby/concurrent/timer_task.rb

@@ -325,7 +325,6 @@ module Concurrent
     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

data/lib/concurrent-ruby/concurrent/tvar.rb

@@ -188,7 +188,10 @@ module Concurrent
     def write(tvar, value)
       # Have we already written to this TVar?
 
-      unless @write_log.has_key? tvar
+      if @write_log.has_key? tvar
+        # Record the value written
+        @write_log[tvar] = value
+      else
         # Try to lock the TVar
 
         unless tvar.unsafe_lock.try_lock
@@ -196,7 +199,11 @@ module Concurrent
           Concurrent::abort_transaction
         end
 
-        # If we previously wrote to it, check the version hasn't changed
+        # Record the value written
+  
+        @write_log[tvar] = value
+
+        # If we previously read from it, check the version hasn't changed
 
         @read_log.each do |log_entry|
           if log_entry.tvar == tvar and tvar.unsafe_version > log_entry.version
@@ -204,10 +211,6 @@ module Concurrent
           end
         end
       end
-
-      # Record the value written
-
-      @write_log[tvar] = value
     end
 
     def abort

data/lib/concurrent-ruby/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION      = '1.1.6'
+  VERSION = '1.1.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.1.9
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-10 00:00:00.000000000 Z
+date: 2021-06-05 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -20,12 +20,12 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
-- LICENSE.md
+- LICENSE.txt
 - CHANGELOG.md
 files:
 - CHANGELOG.md
 - Gemfile
-- LICENSE.md
+- LICENSE.txt
 - README.md
 - Rakefile
 - ext/concurrent-ruby/ConcurrentRubyService.java
@@ -79,6 +79,7 @@ files:
 - lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb
+- lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/non_concurrent_priority_queue.rb
 - lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb
 - lib/concurrent-ruby/concurrent/concern/deprecation.rb
@@ -184,8 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,