एक समस्या यह है कि आपको अपनी फोर्क प्रक्रियाओं को पूरा करने के लिए Process.wait का उपयोग करने की आवश्यकता है। दूसरा यह है कि आप चर के माध्यम से इंटरप्रोसेस संचार नहीं कर सकते हैं। इस देखने के लिए:
@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, {} ]
एक तरह से इंटरप्रोसेस संवाद करने के लिए एक पाइप (IO::pipe) का उपयोग कर रहा है। इसे फोर्क से पहले खोलें, फिर कांटा के प्रत्येक तरफ पाइप के एक छोर को बंद करें।
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>
आप चर, उपयोग धागे साझा करना चाहते हैं:
@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 } ]
हालांकि, मैं अगर सूत्रण जब आप आईओ रहे आप किसी भी लाभ मिल जाएगा यकीन नहीं है बाध्य।
आप यकीन है कि यह YAML कि समय देने के लिए है रहे हैं? यदि हां, तो क्या आपने इसे सिक की बजाय मन के साथ लोड करने का प्रयास किया है? –