Sé que en realidad no debería responder a su propia pregunta, pero parece que todo es fácil en rubí:
require 'thread'
require 'singleton'
require 'delegate'
require 'monitor'
class Async
include Singleton
def initialize
@queue = Queue.new
Thread.new { loop { @queue.pop.call } }
end
def run(&blk)
@queue.push blk
end
end
class Work < Delegator
include MonitorMixin
def initialize(&work)
super work; @work, @done, @lock = work, false, new_cond
end
def calc
synchronize {
@result, @done = @work.call, true;
@lock.signal
}
end
def __getobj__
synchronize { @lock.wait_while { [email protected] } }
@result
end
end
Module.class.class_exec {
def async(*method_names)
method_names.each do |method_name|
original_method = instance_method(method_name)
define_method(method_name) do |*args,&blk|
work = Work.new { original_method.bind(self).call(*args,&blk) }
Async.instance.run { work.calc }
return work
end
end
end
}
Y para mi ejemplo de registro:
require 'Logger'
class Logger
async :debug
end
log = Logger.new STDOUT
log.debug "heloo"
Como valores de retorno trabajo, puede usar esto para casi cualquier cosa:
require "test/unit"
class ReturnValues < Test::Unit::TestCase
def do_it
5 + 7
end
async :do_it
def test_simple
assert_equal 10, do_it - 2
end
end
son 'intérpretes ruby' estos días todavía bastante desjarretaron cuando se trata de código multihilo? ¿Todavía hay un bloqueo de intérprete gigante que codifica Ruby nativo de un único subproceso? Tengo curiosidad porque, a menos que ya estés usando un framework como [eventmachine] (http://rubyeventmachine.com/) para forzar que _todo_ tu IO sea asincrónico, es posible que no veas ningún beneficio al hacer solo el registro asincrónico . – sarnold
Suelo usar JRuby, así que tengo hilos de Java reales (creo) ... –
ooh;) esa es una razón de peso para considerar usar JRuby, entonces. Gracias. – sarnold