Biến chia sẻ giữa các quá trình Ruby

Question

Tôi có một chương trình Ruby tải hai tệp yaml rất lớn, vì vậy tôi có thể tăng tốc bằng cách tận dụng nhiều lõi bằng cách tắt một số quy trình. Tôi đã thử tìm kiếm, nhưng tôi đang gặp khó khăn trong việc tìm cách, hoặc thậm chí nếu tôi có thể chia sẻ các biến trong các quy trình khác nhau.

Các mã sau đây là những gì tôi hiện có:

@proteins = "" 
@decoyProteins = "" 

fork do 
    @proteins = YAML.load_file(database) 
    exit 
end 

fork do 
    @decoyProteins = YAML.load_file(database) 
    exit 
end 

p @proteins["LVDK"] 

P màn Nil dù vì ngã ba.

Vì vậy, có thể có các quy trình chia đôi chia sẻ các biến không? Và nếu vậy, làm thế nào?

Answer 1

Một vấn đề là bạn cần sử dụng Process.wait để đợi cho quá trình chia đôi của bạn hoàn tất. Cái còn lại là bạn không thể thực hiện truyền thông interprocess thông qua các biến. Để xem điều này:

@one = nil 
@two = nil 
@hash = {} 
pidA = fork do 
    sleep 1 
    @one = 1 
    @hash[:one] = 1 
    p [:one, @one, :hash, @hash] #=> [ :one, 1, :hash, { :one => 1 } ] 
end 
pidB = fork do 
    sleep 2 
    @two = 2 
    @hash[:two] = 2 
    p [:two, @two, :hash, @hash] #=> [ :two, 2, :hash, { :two => 2 } ] 
end 
Process.wait(pidB) 
Process.wait(pidA) 
p [:one, @one, :two, @two, :hash, @hash] #=> [ :one, nil, :two, nil, :hash, {} ] 

Một cách để thực hiện liên lạc liên thông là sử dụng đường ống (IO::pipe). Mở nó trước khi bạn ngã ba, sau đó có mỗi bên của ngã ba đóng một đầu của đường ống.

Từ ri IO::pipe:

rd, wr = IO.pipe 

    if fork 
     wr.close 
     puts "Parent got: <#{rd.read}>" 
     rd.close 
     Process.wait 
    else 
     rd.close 
     puts "Sending message to parent" 
     wr.write "Hi Dad" 
     wr.close 
    end 

_produces:_ 

    Sending message to parent 
    Parent got: <Hi Dad> 

Nếu bạn muốn chia sẻ các biến, đề sử dụng:

@one = nil 
@two = nil 
@hash = {} 
threadA = Thread.fork do 
    sleep 1 
    @one = 1 
    @hash[:one] = 1 
    p [:one, @one, :hash, @hash] #=> [ :one, 1, :hash, { :one => 1 } ] # (usually) 
end 
threadB = Thread.fork do 
    sleep 2 
    @two = 2 
    @hash[:two] = 2 
    p [:two, @two, :hash, @hash] #=> [ :two, 2, :hash, { :one => 1, :two => 2 } ] # (usually) 
end 
threadA.join 
threadB.join 
p [:one, @one, :two, @two, :hash, @hash] #=> [ :one, 1, :two, 2, :hash, { :one => 1, :two => 2 } ] 

Tuy nhiên, tôi không chắc chắn nếu luồng sẽ giúp bạn có bất kỳ khoản lãi khi bạn đang IO bị ràng buộc.

Answer 2

Có thể chia sẻ các biến giữa các quy trình; DRuby có lẽ là cách rào cản nhập cảnh thấp nhất để làm điều đó.

Answer 3

Bạn có thể muốn sử dụng một chuỗi thay vì một ngã ba nếu bạn muốn chia sẻ dữ liệu.

http://ruby-doc.org/docs/ProgrammingRuby/html/tut_threads.html

Oh, và nếu bạn thực sự muốn tận dụng lợi thế của đề bạn sẽ muốn sử dụng JRuby. Trong [c] Ruby 1.9 bạn có thể luôn muốn nhìn vào sợi. Tôi đã không nhìn vào họ mặc dù, tôi không biết nếu nó là một giải pháp cho bạn.

Answer 4

Cod có nghĩa là cho Inter Communication Communication và sẽ cho phép bạn dễ dàng gửi dữ liệu giữa các quy trình được chia hai.