Rubinius - Constant autoloading and thread-safety

b.rb

module A
  class B
    autoload :C, 'c'

    def foo
      C
    end
  end
end

c.rb

module A
  class B
    class C
    end
  end
end

foo.rb

require 'monitor'

module A
  autoload :B, 'b'
end

require 'b'

class Foo
  include MonitorMixin
  attr_accessor :b

  def initialize
    super
    @cv        = new_cond
    @committed = false
  end

  def await_commit
    synchronize do
      @cv.wait_until { @committed }
    end
  end

  def commit!
    synchronize do
      @committed = true
      @cv.broadcast
    end
  end

  def process
    error = nil
    Thread.new {
      begin
        # Line loading the A::B::C constant
        b.foo
      rescue => e
        error = e
      ensure
        commit!
      end
    }

    await_commit
    raise error if error
  end
end

foo   = Foo.new
foo.b = A::B.new
foo.process