Concorrenza di ruby ​​/ elaborazione asincrona (con caso d'uso semplice)

Question

Stavo esaminando le capacità di elaborazione parallela/asincrona di Ruby e leggevo molti articoli e post di blog. Ho guardato attraverso EventMachine, Fibre, Revactor, Reia, ecc, ecc Purtroppo, non ero in grado di trovare una soluzione semplice, efficace (e non-IO-blocco) per questo molto semplice caso d'uso:

File.open('somelogfile.txt') do |file| 
    while line = file.gets  # (R) Read from IO 
    line = process_line(line) # (P) Process the line 
    write_to_db(line)   # (W) Write the output to some IO (DB or file) 
    end 
end 

è che si può vedere, il mio piccolo script sta eseguendo tre operazioni lette (R), processo (P) & scrittura (W). Supponiamo - per semplicità - che ogni operazione richiede esattamente 1 unità di tempo (ad esempio 10 ms), il codice attuale sarebbe quindi fare qualcosa di simile (5 righe):

Time:  123456789(15 units in total) 
Operations: RPWRPWRPWRPWRPW 

Ma, mi piacerebbe fare qualcosa in questo modo:

Time:  1234567 (7 units in total) 
Operations: RRRRR 
      PPPPP 
       WWWWW 

Ovviamente, ho potuto eseguire tre processi (lettore, processore & scrittore) e trasmettere leggere linee dal lettore nella coda del processore e quindi passare linee trasformate nella coda scrittore (tutti coordinati ad esempio tramite RabbitMQ) . Ma il caso d'uso è così semplice, non sembra giusto.

Eventuali indizi su come ciò potrebbe essere fatto (senza passare da Ruby a Erlang, Closure o Scala)?

Answer 1

Check out pesca (http://peach.rubyforge.org/). Fare un parallelo "ciascuno" non potrebbe essere più semplice. Tuttavia, come dice la documentazione, è necessario eseguire JRuby per utilizzare il threading nativo della JVM.

Vedere la risposta di Jorg Mittag a this SO question per un sacco di dettagli sulle capacità di multithreading dei vari interpreti Ruby.

Answer 2

Se è necessario che sia veramente parallelo (da un singolo processo), credo che dovrai utilizzare JRuby per ottenere veri thread nativi e senza GIL.

È possibile utilizzare qualcosa come DRb per distribuire l'elaborazione su più processi/core, ma per il proprio caso di utilizzo questo è un po 'troppo. Invece, si potrebbe provare di avere più processi comunicano utilizzando tubi:

$ cat somelogfile.txt | ruby ./proc-process | ruby ./proc-store 

In questo scenario ogni pezzo è il suo proprio processo che può essere eseguito in parallelo, ma sono comunicare utilizzando STDIN/STDOUT. Questo è probabilmente l'approccio più semplice (e più veloce) al tuo problema.

# proc-process 
while line = $stdin.gets do 
    # do cpu intensive stuff here 
    $stdout.puts "data to be stored in DB" 
    $stdout.flush # this is important 
end 

# proc-store 
while line = $stdin.gets do 
    write_to_db(line) 
end