Bug #17624


Ractor.receive is not thread-safe

Added by dazuma (Daniel Azuma) over 3 years ago. Updated 4 months ago.

Target version:
ruby -v:
ruby 3.3.0dev (2023-11-13T21:00:10Z master e8ab3f7010) [x86_64-darwin23]


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 = do
  # Start two listener threads
  t1 = do
    puts "T1 received #{Ractor.receive}"
  t2 = do
    puts "T2 received #{Ractor.receive}"

  # 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.)

  # 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)

# Make sure both receive calls are blocking

# Send two messages.

# 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]


  • 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) almost 3 years ago

  • Assignee set to ko1 (Koichi Sasada)

Updated by dazuma (Daniel Azuma) 8 months ago

  • ruby -v changed from ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin20] to ruby 3.3.0dev (2023-11-13T21:00:10Z master e8ab3f7010) [x86_64-darwin23]

Retested, still reproduces on 3.2.2 and 3.3.0-dev as of 2023 Nov 13.

Actions #3

Updated by hsbt (Hiroshi SHIBATA) 4 months ago

  • Status changed from Open to Assigned

Also available in: Atom PDF