Fix CountDownLatch and Exchanger on JRuby

* make the threads sleep
* allow the threads to be unblocked and killed

Author: pitr-ch

lib/concurrent/atomic/java_count_down_latch.rb

@@ -18,10 +18,12 @@ def initialize(count = 1)
       # @!macro count_down_latch_method_wait
       def wait(timeout = nil)
         if timeout.nil?
-          @latch.await
+          Synchronization::JRuby.sleep_interruptibly { @latch.await }
           true
         else
-          @latch.await(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          Synchronization::JRuby.sleep_interruptibly do
+            @latch.await(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          end
         end
       end
 

lib/concurrent/exchanger.rb

@@ -315,9 +315,11 @@ def initialize
       # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
       def do_exchange(value, timeout)
         if timeout.nil?
-          @exchanger.exchange(value)
+          Synchronization::JRuby.sleep_interruptibly { @exchanger.exchange(value) }
         else
-          @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          Synchronization::JRuby.sleep_interruptibly do
+            @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          end
         end
       rescue java.util.concurrent.TimeoutException
         CANCEL

spec/concurrent/atomic/count_down_latch_spec.rb

@@ -42,10 +42,14 @@
 
   describe '#wait' do
 
-    it 'blocks indefinitely' do
-      # test the thread is kill-able
-      in_thread(latch) { |l| l.wait }
-      sleep 0.1
+    it 'blocks indefinitely, and is kill-able' do
+      t = in_thread(latch) { |l| l.wait }
+      is_sleeping t
+    end
+
+    it 'blocks indefinitely with timeout, and is kill-able' do
+      t = in_thread(latch) { |l| l.wait 100 }
+      is_sleeping t
     end
 
     context 'count set to zero' do

spec/concurrent/exchanger_spec.rb

@@ -8,14 +8,13 @@
     latch_1 = Concurrent::CountDownLatch.new
     latch_2 = Concurrent::CountDownLatch.new
 
-    in_thread do
+    t = in_thread do
       latch_1.count_down
-      subject.send(method_name, 1)
+      subject.send(method_name, 0.1)
       latch_2.count_down
     end
 
-    latch_1.wait(1)
-    latch_2.wait(0.1)
+    is_sleeping t
     expect(latch_1.count).to eq 0
     expect(latch_2.count).to eq 1
   end
@@ -238,7 +237,6 @@ module Concurrent
   end
 
   if defined? JavaExchanger
-
     RSpec.describe JavaExchanger do
       it_behaves_like :exchanger
     end

spec/support/example_group_extensions.rb

@@ -36,6 +36,10 @@ def in_thread(*args, &block)
       new_thread
     end
 
+    def is_sleeping(thread)
+      expect(in_thread { Thread.pass until thread.status == 'sleep' }.join(1)).not_to eq nil
+    end
+
     def join_with(threads, timeout = 5)
       threads = Array(threads)
       threads.each do |t|