Ruby Language
धागा

बुनियादी धागा शब्दार्थ

मुख्य थ्रेड के निष्पादन से अलग एक नया थ्रेड, Thread.new का उपयोग करके बनाया जा सकता है।

thr = Thread.new {
  sleep 1 # 1 second sleep of sub thread
  puts "Whats the big deal"
}

यह स्वचालित रूप से नए थ्रेड का निष्पादन शुरू कर देगा।

मुख्य थ्रेड को निष्पादित करने के लिए, जब तक कि नया धागा बंद न हो जाए, तब तक join हो join :

thr.join #=> ... "Whats the big deal"

ध्यान दें कि जब आप ज्वाइन करते हैं, तो थ्रेड पहले ही समाप्त हो सकता है, जिस स्थिति में निष्पादन सामान्य रूप से जारी रहेगा। यदि कोई उप-थ्रेड कभी नहीं जुड़ता है, और मुख्य थ्रेड पूरा हो जाता है, तो उप-थ्रेड किसी भी शेष कोड को निष्पादित नहीं करेगा।

साझा संसाधनों तक पहुँच

एक चर को एक्सेस करने के लिए एक म्यूटेक्स का उपयोग करें जो कई थ्रेड्स से एक्सेस किया जाता है:

counter = 0
counter_mutex = Mutex.new

# Start three parallel threads and increment counter
3.times.map do |index|
  Thread.new do
    counter_mutex.synchronize { counter += 1 }
  end
end.each(&:join) # Wait for all threads to finish before killing the process

अन्यथा, वर्तमान में एक थ्रेड को दिखाई देने वाले counter का मान दूसरे थ्रेड द्वारा बदला जा सकता है।

Mutex बिना उदाहरण (उदाहरण के लिए देखें Thread 0 , जहां Before और After 1 से अधिक भिन्न होता है):

2.2.0 :224 > counter = 0; 3.times.map { |i| Thread.new { puts "[Thread #{i}] Before: #{counter}"; counter += 1; puts "[Thread #{i}] After: #{counter}"; } }.each(&:join)
[Thread 2] Before: 0
[Thread 0] Before: 0
[Thread 0] After: 2
[Thread 1] Before: 0
[Thread 1] After: 3
[Thread 2] After: 1

Mutex साथ उदाहरण:

2.2.0 :226 > mutex = Mutex.new; counter = 0; 3.times.map { |i| Thread.new { mutex.synchronize { puts "[Thread #{i}] Before: #{counter}"; counter += 1; puts "[Thread #{i}] After: #{counter}"; } } }.each(&:join)
[Thread 2] Before: 0
[Thread 2] After: 1
[Thread 1] Before: 1
[Thread 1] After: 2
[Thread 0] Before: 2
[Thread 0] After: 3

एक धागे को कैसे मारना है

आप उपयोग फोन Thread.kill या Thread.terminate :

thr = Thread.new { ... }
Thread.kill(thr)

एक धागा समाप्त करना

एक धागा समाप्त हो जाता है अगर यह अपने कोड ब्लॉक के अंत तक पहुंचता है। किसी धागे को जल्दी समाप्त करने का सबसे अच्छा तरीका यह है कि वह अपने कोड ब्लॉक के अंत तक पहुंचने के लिए मना ले। इस तरह, थ्रेड मरने से पहले सफाई कोड चला सकता है।

यह थ्रेड एक लूप चलाता है, जबकि उदाहरण चर जारी रखना सही है। इस चर को असत्य पर सेट करें, और धागा एक प्राकृतिक मौत मर जाएगा:

require 'thread'

class CounterThread < Thread
  def initialize
    @count = 0
    @continue = true

    super do
      @count += 1 while @continue
      puts "I counted up to #{@count} before I was cruelly stopped."
    end
  end

  def stop
    @continue = false
  end
end

counter = CounterThread.new
sleep 2
counter.stop