concurrent-ruby 1.1.3 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e771744bb5e8ed6f2e29f284b92dc82c86052313e32ca6113ca14866316e888b
-  data.tar.gz: 72f694ab26e04d3d0eba6966d22dc124e6c047bd34d0531c9f7c33ffca0f2962
+  metadata.gz: 3db57904f9a4906ae01e04d1873aa824992ed1b4258d2b2523ba5ea0ca86b17f
+  data.tar.gz: d8bfd56f2c29b311e528754ee1db476ecbb6387ac7f05a63bb5e395877379452
 SHA512:
-  metadata.gz: 5b351d16a4a900ecefcfddfe282e30ab7c4c022c71aa3d596199cb9a4816adcc8eeedba6a219b8f239bba73ce992403ac40e9d4eb83038713edee9705262677c
-  data.tar.gz: 8a49539c89fe3f073a0a89c1c79453a49132c0ba5ce575172f9592b62be98e35136f0c216c80660f1e0489c5b33ca62a7db5575866794231b0d81d0f0665c03d
+  metadata.gz: b76f7f31795dce80951ea7b5231d919aa28384d04fe6591c43e310774450f16b074ce5536ef218fd2475f5413cdf0c9409bc1d3542b19b78146cc5375c30a603
+  data.tar.gz: 9bb9d431f6995bdec6e7ed6c6323f72ac0cc713d71072115c0dfcefb6ccb42c8b5b703bf34049071bebf4e0686dce2e28cc44865329884785eae8a6a2eabd060

data/CHANGELOG.md

@@ -1,5 +1,56 @@
 ## Current
 
+## 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:
+
+* (#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:
+
+* 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)

data/Gemfile

@@ -1,6 +1,8 @@
 source 'https://rubygems.org'
 
-require File.join(File.dirname(__FILE__ ), 'lib/concurrent/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: '.' }
@@ -10,27 +12,28 @@ 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-compiler', '~> 1.0'
-  gem 'rake-compiler-dock', '~> 0.6.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', '~> 1.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/{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

@@ -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
@@ -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.
@@ -224,6 +224,38 @@ 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.
+*   [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
 
@@ -339,11 +371,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,7 +1,6 @@
-#!/usr/bin/env rake
-
-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
@@ -18,31 +17,11 @@ 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
+ENV['JRUBY_HOME'] = ENV['CONCURRENT_JRUBY_HOME'] if ENV['CONCURRENT_JRUBY_HOME'] && !Concurrent.on_jruby?
 
-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'
+  ext.lib_dir = 'lib/concurrent-ruby/concurrent'
 end
 
 unless Concurrent.on_jruby?
@@ -50,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
@@ -63,10 +42,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
-      Rake::Task['lib/concurrent/concurrent_ruby.jar'].invoke
-      RakeCompilerDock.exec 'support/cross_building.sh'
+
+      # 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-ruby/concurrent/concurrent_ruby.jar'].invoke
+
+      # build all gem files
+      RakeCompilerDock.sh 'bundle install --local && bundle exec rake cross native package --trace'
     end
   end
 end
@@ -78,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'
@@ -86,15 +69,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 +101,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'
@@ -169,22 +151,34 @@ begin
     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',
-                      './lib-edge/**/*.rb',
+        yard.files = ['./lib/concurrent-ruby/**/*.rb',
+                      './lib/concurrent-ruby-edge/**/*.rb',
                       './ext/concurrent_ruby_ext/**/*.c',
                       '-',
                       'docs-source/thread_pools.md',
                       'docs-source/promises.out.md',
-                      'LICENSE.md',
+                      'docs-source/medium-example.out.rb',
+                      'LICENSE.txt',
                       '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
@@ -207,7 +201,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
@@ -230,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
@@ -259,7 +261,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