Project

General

Profile

Actions

Bug #17624

open

Ractor.receive is not thread-safe

Added by dazuma (Daniel Azuma) 9 months ago. Updated about 1 month ago.

Status:
Open
Priority:
Normal
Target version:
-
ruby -v:
ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin20]
[ruby-core:102473]

Description

It does not seem to be possible to have multiple blocked Ractor.receive calls concurrently in the same Ractor (but different threads). One may succeed but the others will hang indefinitely, even if messages are present in the queue.

Example code below. It does the following:

  1. Starts a Ractor r1 that spawns two "listener threads". Each thread calls Ractor.receive, which blocks waiting for messages.
  2. The main Ractor pauses briefly to ensure that the threads have started, and then sends two messages to the Ractor r1, with the expectation that each thread will receive one of them.
  3. What actually happens is, the Ractor.receive call in one of the threads will pick a message and return. However, the Ractor.receive call in the other thread remains blocked, even though the second message is in the queue.
  4. Ractor r1, after a pause to ensure that both messages have been sent, issues another Ractor.receive call. This call does not block (because the second message is in the queue), and successfully returns the message. Meanwhile, the second thread's Ractor.receive call remains blocked. This demonstrates that the second message has been sent successfully and is receivable, even though the second thread still hasn't returned it. It appears that the second thread's receive call is in a bad state.
r1 = Ractor.new do
  # Start two listener threads
  t1 = Thread.new do
    puts "T1 received #{Ractor.receive}"
  end
  t2 = Thread.new do
    puts "T2 received #{Ractor.receive}"
  end

  # Pause to ensure that both messages have been sent.
  # (One of the messages will have been picked up by a
  # thread, but the other remains in the queue.)
  sleep(3)

  # Receive the second message. This will succeed, even
  # though the second thread is still blocked.
  puts "Later received #{Ractor.receive}"

  # Wait for the threads to finish.
  # This will never complete because one of the threads will not
  # receive the second message, and is still blocking.
  [t1, t2].each(&:join)
  :ok
end

# Make sure both receive calls are blocking
sleep(1)

# Send two messages.
r1.send(1)
r1.send(2)

# This never returns because the ractor never completes.
puts r1.take

This happens both in 3.0.0 release and on 3.1.0 head.

% ruby -v
ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin20]
% ruby -v
ruby 3.1.0dev (2021-02-09T13:22:37Z master e7a831de8e) [x86_64-darwin20]

Notes:

  • This also happens when using receive_if.
  • I would expect this use case to be common when writing a Ractor that contains multiple thread-safe "workers". (This was in fact the use case I was trying to implement when I encountered this issue.) Thus, if we decide this is working as intended, we should document it, and possibly suggest to users that they write their Ractor to funnel communication through a single dedicated thread.

Updated by mame (Yusuke Endoh) about 1 month ago

  • Assignee set to ko1 (Koichi Sasada)
Actions

Also available in: Atom PDF