…d_wakeup()In rb_ractor_sched_wait() (ex: Ractor.receive), we acquireRACTOR_LOCK(cr) and then thread_sched_lock(cur_th). However, on wakeupif we're a dnt, in thread_sched_wait_running_turn() we acquirethread_sched_lock(cur_th) after condvar wakeup and then RACTOR_LOCK(cr).This lock inversion can cause a deadlock with rb_ractor_wakeup_all()(ex: port.send(obj)), where we acquire RACTOR_LOCK(other_r) and thenthread_sched_lock(other_th).So, the error happens:nt 1:   Ractor.receive            rb_ractor_sched_wait() after condvar wakeup in thread_sched_wait_running_turn():              - thread_sched_lock(cur_th) (condvar) # acquires lock              - rb_ractor_lock_self(cr) # deadlock here: tries to acquire, HANGSnt 2: port.send            ractor_wakeup_all()              - RACTOR_LOCK(port_r) # acquires lock              - thread_sched_lock # tries to acquire, HANGSOne solution would be to rework `thread_sched_wait_running_turn()` with DNT's. I didn'tdo this because it would be a bigger architectural change. What I changed is to unlockRACTOR_LOCK before calling rb_ractor_sched_wakeup() in a pthread env. In a non-pthreadenv it's safe to hold this lock, and we should.Script that reproduces issue:```rubyrequire "async"class RactorWrapper  def initialize@Ractor = Ractor.new do      Ractor.recv # Ractor doesn't start until explicitly told to      # Do some calculations      fib = ->(x) { x < 2 ? 1 : fib.call(x - 1) + fib.call(x - 2) }      fib.call(20)    end  end  def take_async    @ractor.send(nil)    Thread.new { @ractor.value }.value  endendAsync do |task|  10_000.times do |i|    task.async do      RactorWrapper.new.take_async      puts i    end  endendexit 0```Fixes [Bug #21398]