concurrent-ruby 1.1.2 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b989ff504545fbd515aa9623e18515993f30d758768702fd48775efbf1eb68da
-  data.tar.gz: 6de4e1598114ce722b56eb2ca567d75dd8828afb998252bdb46906e2578f943d
+  metadata.gz: 96f32c31090c8a0547e4ee452739bdc993aad1256e2c89cb9a46d7f7e7b5762a
+  data.tar.gz: 307d26bde3add56b7e2b37fb0b016c7726a3ba0755dcfec8202fb0760e4ac485
 SHA512:
-  metadata.gz: b81c2d2d16e02a03ef0e77c8d633280c02946472e7a762de733da0ee7203c2227ccb09ce5f03835446db42f0bef78df55a2158a787eea3620b1c228a234836df
-  data.tar.gz: f5ca5bacf3edbc0cf9894d94b8a3c3bc4aef173e4122c6a9cae84d257a3d3df5ada3280431c14f8e33b328348ce039af9a278975954daccb5aea916bad18a1fa
+  metadata.gz: b8cff93c6ef396aebbe5cf69734d9a91f0351e24b5c1846ae105b055254f972cd9d6bb99b90ce10d387627ed43c4e21db9ce47d1587e10278e80e33a53f8d4c4
+  data.tar.gz: f367f097759eedb8e18b0117543176c9f30ab29552888fcedab0baaea355cee3d100d2559dd16cf54483778545097f8b3340bebe44b0e3ab2a51c1af3830f5e1

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## Current
 
+## Release v1.1.5, edge v0.5.0 (10 mar 2019)
+
+concurrent-ruby:
+
+* fix potential leak of context on JRuby and Java 7
+
+concurrent-ruby-edge:
+
+* Add finalized Concurrent::Cancellation
+* Add finalized Concurrent::Throttle
+* Add finalized Concurrent::Promises::Channel
+* Add new Concurrent::ErlangActor
+
+## Release v1.1.4 (14 Dec 2018)
+
+* (#780) Remove java_alias of 'submit' method of Runnable to let executor service work on java 11
+* (#776) Fix NameError on defining a struct with a name which is already taken in an ancestor
+
+## Release v1.1.3 (7 Nov 2018)
+
+* (#775) fix partial require of the gem (although not officially supported)
+
+## Release v1.1.2 (6 Nov 2018)
+
+* (#773) more defensive 1.9.3 support
+
 ## Release v1.1.1, edge v0.4.1 (1 Nov 2018)
 
 * (#768) add support for 1.9.3 back 

data/Gemfile

@@ -1,6 +1,7 @@
 source 'https://rubygems.org'
 
-require File.join(File.dirname(__FILE__ ), 'lib/concurrent/version')
+require File.join(File.dirname(__FILE__), 'lib/concurrent/version')
+require File.join(File.dirname(__FILE__ ), 'lib-edge/concurrent/edge/version')
 
 no_path = ENV['NO_PATH']
 options = no_path ? {} : { path: '.' }
@@ -11,26 +12,27 @@ gem 'concurrent-ruby-ext', Concurrent::VERSION, options.merge(platform: :mri)
 
 group :development do
   gem 'rake', '~> 12.0'
-  gem 'rake-compiler', '~> 1.0'
-  gem 'rake-compiler-dock', '~> 0.6.0'
+  gem 'rake-compiler', '~> 1.0', '>= 1.0.7'
+  gem 'rake-compiler-dock', '~> 0.7.0'
   gem 'pry', '~> 0.11', platforms: :mri
 end
 
 group :documentation, optional: true do
-  gem 'yard', '~> 0.9.0', :require => false
+  gem 'yard', '~> 0.9.0', require: false
   gem 'redcarpet', '~> 3.0', platforms: :mri # understands github markdown
-  gem 'md-ruby-eval', '~> 0.3'
+  gem 'md-ruby-eval', '~> 0.6'
 end
 
 group :testing do
   gem 'rspec', '~> 3.7'
   gem 'timecop', '~> 0.7.4'
+  gem 'sigdump', require: false
 end
 
 # made opt-in since it will not install on jruby 1.7
 group :coverage, optional: !ENV['COVERAGE'] do
-  gem 'simplecov', '~> 0.10.0', :require => false
-  gem 'coveralls', '~> 0.8.2', :require => false
+  gem 'simplecov', '~> 0.16.0', require: false
+  gem 'coveralls', '~> 0.8.2', require: false
 end
 
 group :benchmarks, optional: true do

data/README.md

@@ -42,8 +42,8 @@ appreciate your help. Would you like to contribute? Great! Have a look at
 ## Thread Safety
 
 *Concurrent Ruby makes one of the strongest thread safety guarantees of any Ruby concurrency 
-library, providing consistent behavior and guarantees on all three of the main Ruby interpreters 
-(MRI/CRuby, JRuby, and Rubinius).*
+library, providing consistent behavior and guarantees on all four of the main Ruby interpreters 
+(MRI/CRuby, JRuby, Rubinius, TruffleRuby).*
 
 Every abstraction in this library is thread safe. Specific thread safety guarantees are documented 
 with each abstraction.
@@ -59,7 +59,7 @@ Concurrent Ruby is also the only Ruby library which provides a full suite of thr
 immutable variable types and data structures.
 
 We've also initiated discussion to document [memory model](docs-source/synchronization.md) of Ruby which 
-would provide consistent behaviour and guarantees on all three of the main Ruby interpreters 
+would provide consistent behaviour and guarantees on all four of the main Ruby interpreters 
 (MRI/CRuby, JRuby, Rubinius, TruffleRuby).
 
 ## Features & Documentation
@@ -224,6 +224,35 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
     *Status: will be moved to core soon.*
 *   [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/LockFreeStack.html)
     *Status: missing documentation and tests.*
+*   [Promises::Channel](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises/Channel.html)
+    A first in first out channel that accepts messages with push family of methods and returns
+    messages with pop family of methods.
+    Pop and push operations can be represented as futures, see `#pop_op` and `#push_op`.
+    The capacity of the channel can be limited to support back pressure, use capacity option in `#initialize`.
+    `#pop` method blocks ans `#pop_op` returns pending future if there is no message in the channel.
+    If the capacity is limited the `#push` method blocks and `#push_op` returns pending future.
+*   [Cancellation](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Cancellation.html)
+    The Cancellation abstraction provides cooperative cancellation.
+
+    The standard methods `Thread#raise` of `Thread#kill` available in Ruby
+    are very dangerous (see linked the blog posts bellow).
+    Therefore concurrent-ruby provides an alternative.
+    
+    *   <https://jvns.ca/blog/2015/11/27/why-rubys-timeout-is-dangerous-and-thread-dot-raise-is-terrifying/>
+    *   <http://www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/>
+    *   <http://blog.headius.com/2008/02/rubys-threadraise-threadkill-timeoutrb.html>
+
+    It provides an object which represents a task which can be executed,
+    the task has to get the reference to the object and periodically cooperatively check that it is not cancelled.
+    Good practices to make tasks cancellable:
+    *   check cancellation every cycle of a loop which does significant work,
+    *   do all blocking actions in a loop with a timeout then on timeout check cancellation
+        and if ok block again with the timeout 
+*   [Throttle](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Throttle.html)
+    A tool managing concurrency level of tasks.
+*   [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.
 
 ## Supported Ruby versions
 
@@ -339,11 +368,14 @@ and to the past maintainers
 *   [Paweł Obrok](https://github.com/obrok)
 *   [Lucas Allan](https://github.com/lucasallan)
 
+and to [Ruby Association](https://www.ruby.or.jp/en/) for sponsoring a project 
+["Enhancing Ruby’s concurrency tooling"](https://www.ruby.or.jp/en/news/20181106) in 2018. 
+
 ## License and Copyright
 
 *Concurrent Ruby* is free software released under the 
 [MIT License](http://www.opensource.org/licenses/MIT).
 
-The *Concurrent Ruby* [logo](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Logo) was
+The *Concurrent Ruby* [logo](https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/docs-source/logo/concurrent-ruby-logo-300x300.png) was
 designed by [David Jones](https://twitter.com/zombyboy). It is Copyright &copy; 2014 
 [Jerry D'Antonio](https://twitter.com/jerrydantonio). All Rights Reserved.

data/Rakefile

@@ -1,5 +1,3 @@
-#!/usr/bin/env rake
-
 require_relative 'lib/concurrent/version'
 require_relative 'lib/concurrent/utility/engine'
 
@@ -18,29 +16,7 @@ edge_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-edge.
 
 require 'rake/javaextensiontask'
 
-JRUBY_JAR_PATH = '/usr/local/opt/rbenv/versions/jruby-9.1.17.0/lib/jruby.jar'
-
-class ConcurrentRubyJavaExtensionTask < Rake::JavaExtensionTask
-  def java_classpath_arg(*args)
-    jruby_cpath = nil
-    if RUBY_PLATFORM =~ /java/
-      begin
-        cpath       = Java::java.lang.System.getProperty('java.class.path').split(File::PATH_SEPARATOR)
-        cpath       += Java::java.lang.System.getProperty('sun.boot.class.path').split(File::PATH_SEPARATOR)
-        jruby_cpath = cpath.compact.join(File::PATH_SEPARATOR)
-      rescue => e
-      end
-    end
-    unless jruby_cpath
-      jruby_cpath = JRUBY_JAR_PATH
-      raise "#{jruby_cpath} does not exist" unless File.exist? jruby_cpath
-    end
-    jruby_cpath += File::PATH_SEPARATOR + args.join(File::PATH_SEPARATOR) unless args.empty?
-    jruby_cpath ? "-cp \"#{jruby_cpath}\"" : ""
-  end
-end
-
-ConcurrentRubyJavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
+Rake::JavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
   ext.ext_dir = 'ext/concurrent-ruby'
   ext.lib_dir = 'lib/concurrent'
 end
@@ -63,10 +39,14 @@ namespace :repackage do
   desc '* with Windows fat distributions'
   task :all do
     Dir.chdir(__dir__) do
+      # store gems in vendor cache for docker
       sh 'bundle package'
-      # needed only if the jar is built outside of docker
+
+      # 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
-      RakeCompilerDock.exec 'support/cross_building.sh'
+
+      # build all gem files
+      RakeCompilerDock.sh 'bundle install --local && bundle exec rake cross native package --trace'
     end
   end
 end
@@ -86,15 +66,14 @@ begin
 
   RSpec::Core::RakeTask.new(:spec)
 
-  options = %w[ --color
-                --backtrace
-                --seed 1
-                --format documentation
-                --tag ~notravis ]
-
   namespace :spec do
     desc '* Configured for ci'
     RSpec::Core::RakeTask.new(:ci) do |t|
+      options      = %w[ --color
+                    --backtrace
+                    --order defined
+                    --format documentation
+                    --tag ~notravis ]
       t.rspec_opts = [*options].join(' ')
     end
 
@@ -119,7 +98,7 @@ rescue LoadError => e
   puts 'RSpec is not installed, skipping test task definitions: ' + e.message
 end
 
-current_yard_version_name = Concurrent::VERSION.split('.')[0..2].join('.')
+current_yard_version_name = Concurrent::VERSION
 
 begin
   require 'yard'
@@ -163,15 +142,25 @@ begin
             "{Concurrent::#{$1} #{$1}}"
           end
         end
+        FileUtils.mkpath 'tmp'
         File.write 'tmp/README.md', content
       end
     end
 
     define_yard_task = -> name do
+      output_dir = "docs/#{name}"
+
+      removal_name = "remove.#{name}"
+      task removal_name do
+        Dir.chdir __dir__ do
+          FileUtils.rm_rf output_dir
+        end
+      end
+
       desc "* of #{name} into subdir #{name}"
       YARD::Rake::YardocTask.new(name) do |yard|
         yard.options.push(
-            '--output-dir', "docs/#{name}",
+            '--output-dir', output_dir,
             '--main', 'tmp/README.md',
             *common_yard_options)
         yard.files = ['./lib/**/*.rb',
@@ -180,10 +169,11 @@ begin
                       '-',
                       'docs-source/thread_pools.md',
                       'docs-source/promises.out.md',
+                      'docs-source/medium-example.out.rb',
                       'LICENSE.md',
                       'CHANGELOG.md']
       end
-      Rake::Task[name].prerequisites.push '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
@@ -206,7 +196,15 @@ begin
             begin
               FileUtils.cp_r 'docs', 'docs-copy', verbose: true
               Rake::Task["yard:#{name}"].invoke
-              sh 'diff -r docs/ docs-copy/'
+              sh 'diff -r docs/ docs-copy/' do |ok, res|
+                unless ok
+                  begin
+                    STDOUT.puts 'Command failed. Continue? (y/n)'
+                    input = STDIN.gets.strip.downcase
+                  end until %w(y n).include?(input)
+                  exit 1 if input == 'n'
+                end
+              end
             ensure
               FileUtils.rm_rf 'docs-copy', verbose: true
             end
@@ -258,7 +256,7 @@ namespace :release do
   end
 
   desc '* build all *.gem files necessary for release'
-  task :build => 'repackage:all'
+  task :build => [:clobber, 'repackage:all']
 
   desc '* test actual installed gems instead of cloned repository on MRI and JRuby'
   task :test do

data/ext/concurrent-ruby/com/concurrent_ruby/ext/SynchronizationLibrary.java

@@ -23,6 +23,7 @@ import java.lang.reflect.Method;
 public class SynchronizationLibrary implements Library {
 
     private static final Unsafe UNSAFE = loadUnsafe();
+    private static final boolean FULL_FENCE = supportsFences();
 
     private static Unsafe loadUnsafe() {
         try {
@@ -140,17 +141,17 @@ public class SynchronizationLibrary implements Library {
         // volatile threadContext is used as a memory barrier per the JVM memory model happens-before semantic
         // on volatile fields. any volatile field could have been used but using the thread context is an
         // attempt to avoid code elimination.
-        private static volatile ThreadContext threadContext = null;
+        private static volatile int volatileField;
 
         @JRubyMethod(name = "full_memory_barrier", visibility = Visibility.PUBLIC)
         public static IRubyObject fullMemoryBarrier(ThreadContext context, IRubyObject self) {
             // Prevent reordering of ivar writes with publication of this instance
-            if (!supportsFences()) {
+            if (!FULL_FENCE) {
                 // Assuming that following volatile read and write is not eliminated it simulates fullFence.
                 // If it's eliminated it'll cause problems only on non-x86 platforms.
                 // http://shipilev.net/blog/2014/jmm-pragmatics/#_happens_before_test_your_understanding
-                final ThreadContext oldContext = threadContext;
-                threadContext = context;
+                final int volatileRead = volatileField;
+                volatileField = context.getLine();
             } else {
                 UNSAFE.fullFence();
             }
@@ -163,9 +164,9 @@ public class SynchronizationLibrary implements Library {
                 IRubyObject self,
                 IRubyObject name) {
             // Ensure we ses latest value with loadFence
-            if (!supportsFences()) {
+            if (!FULL_FENCE) {
                 // piggybacking on volatile read, simulating loadFence
-                final ThreadContext oldContext = threadContext;
+                final int volatileRead = volatileField;
                 return ((RubyBasicObject) self).instance_variable_get(context, name);
             } else {
                 UNSAFE.loadFence();
@@ -180,10 +181,10 @@ public class SynchronizationLibrary implements Library {
                 IRubyObject name,
                 IRubyObject value) {
             // Ensure we make last update visible
-            if (!supportsFences()) {
+            if (!FULL_FENCE) {
                 // piggybacking on volatile write, simulating storeFence
                 final IRubyObject result = ((RubyBasicObject) self).instance_variable_set(name, value);
-                threadContext = context;
+                volatileField = context.getLine();
                 return result;
             } else {
                 // JRuby uses StampedVariableAccessor which calls fullFence

data/lib/concurrent/array.rb

@@ -21,8 +21,9 @@ module Concurrent
   # @!macro internal_implementation_note
   ArrayImplementation = case
                         when Concurrent.on_cruby?
-                          # Because MRI never runs code in parallel, the existing
-                          # non-thread-safe structures should usually work fine.
+                          # Array is thread-safe in practice because CRuby runs
+                          # threads one at a time and does not do context
+                          # switching during the execution of C functions.
                           ::Array
 
                         when Concurrent.on_jruby?
@@ -63,4 +64,3 @@ module Concurrent
   end
 
 end
-

data/lib/concurrent/async.rb

@@ -333,6 +333,13 @@ module Concurrent
         ivar
       end
 
+      # Check whether the method is responsive
+      #
+      # @param [Symbol] method the method being called
+      def respond_to_missing?(method, include_private = false)
+        @delegate.respond_to?(method) || super
+      end
+
       # Perform all enqueued tasks.
       #
       # This method must be called from within the executor. It must not be
@@ -383,6 +390,13 @@ module Concurrent
         ivar.wait
         ivar
       end
+
+      # Check whether the method is responsive
+      #
+      # @param [Symbol] method the method being called
+      def respond_to_missing?(method, include_private = false)
+        @delegate.respond_to?(method) || super
+      end
     end
     private_constant :AwaitDelegator
 

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -79,10 +79,10 @@ module Concurrent
   #   @!method value=(value)
   #     @!macro atomic_fixnum_method_value_set
   #
-  #   @!method increment(delta)
+  #   @!method increment(delta = 1)
   #     @!macro atomic_fixnum_method_increment
   #
-  #   @!method decrement(delta)
+  #   @!method decrement(delta = 1)
   #     @!macro atomic_fixnum_method_decrement
   #
   #   @!method compare_and_set(expect, update)

data/lib/concurrent/collection/lock_free_stack.rb

@@ -53,7 +53,7 @@ module Concurrent
 
     # @param [Node] head
     # @return [true, false]
-    def empty?(head = self.head)
+    def empty?(head = head())
       head.equal? EMPTY
     end
 

data/lib/concurrent/configuration.rb

@@ -4,6 +4,7 @@ require 'concurrent/errors'
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/concern/logging'
 require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/cached_thread_pool'
 require 'concurrent/utility/at_exit'
 require 'concurrent/utility/processor_counter'
 

data/lib/concurrent/executor/java_executor_service.rb

@@ -20,13 +20,12 @@ if Concurrent.on_jruby?
 
       def initialize(*args, &block)
         super
-        ns_make_executor_runnable
       end
 
       def post(*args, &task)
         raise ArgumentError.new('no block given') unless block_given?
         return handle_fallback(*args, &task) unless running?
-        @executor.submit_runnable Job.new(args, task)
+        @executor.submit Job.new(args, task)
         true
       rescue Java::JavaUtilConcurrent::RejectedExecutionException
         raise RejectedExecutionError
@@ -75,14 +74,6 @@ if Concurrent.on_jruby?
         @executor.isShutdown || @executor.isTerminated
       end
 
-      def ns_make_executor_runnable
-        if !defined?(@executor.submit_runnable)
-          @executor.class.class_eval do
-            java_alias :submit_runnable, :submit, [java.lang.Runnable.java_class]
-          end
-        end
-      end
-
       class Job
         include Runnable
         def initialize(args, block)