परिचय

कंकरेंसी प्रोग्रामिंग में एक शक्तिशाली उपकरण है, जो कई थ्रेड्स को एक साथ कोड निष्पादित करने में सक्षम बनाता है। हालाँकि, इस शक्ति के साथ साझा संसाधनों को सुरक्षित रूप से प्रबंधित करने की जिम्मेदारी भी आती है। रूबी में, म्यूटेक्स (पारस्परिक बहिष्करण का संक्षिप्त रूप) यह सुनिश्चित करने में एक महत्वपूर्ण घटक है कि एक समय में केवल एक थ्रेड संसाधन तक पहुंच सकता है, संभावित डेटा भ्रष्टाचार या अप्रत्याशित व्यवहार को रोक सकता है।
इस ब्लॉग में, हम यह पता लगाएंगे कि रूबी में म्यूटेक्स का उपयोग कैसे करें, इसके व्यावहारिक अनुप्रयोग को दर्शाने के लिए नमूना कोड और वास्तविक जीवन परिदृश्य द्वारा समर्थित।

म्यूटेक्स क्या है?

म्यूटेक्स एक ऑब्जेक्ट है जिसका उपयोग थ्रेड्स के सिंक्रोनाइज़ेशन को प्रबंधित करने के लिए किया जाता है। जब एक थ्रेड म्यूटेक्स को लॉक करता है, तो कोई भी अन्य थ्रेड जो उसी म्यूटेक्स को लॉक करने का प्रयास करता है, उसे तब तक होल्ड पर रखा जाएगा जब तक कि पहला थ्रेड उसे रिलीज़ नहीं कर देता। यह तंत्र सुनिश्चित करता है कि कोड के महत्वपूर्ण अनुभाग, जहां साझा संसाधनों तक पहुंच है, एक समय में केवल एक थ्रेड द्वारा निष्पादित किए जाते हैं।

म्यूटेक्स का उपयोग क्यों करें?

एक ऐसे परिदृश्य की कल्पना करें जहां कई थ्रेड एक ही वेरिएबल को संशोधित कर रहे हैं या एक ही फ़ाइल में लिख रहे हैं। उचित समन्वयन के बिना, परिणाम अप्रत्याशित या गलत हो सकता है। म्यूटेक्स यह सुनिश्चित करके ऐसे मुद्दों से बचने में मदद करता है कि किसी भी समय केवल एक थ्रेड साझा संसाधन तक पहुंच सकता है।

रूबी में म्यूटेक्स का उपयोग कैसे करें

require 'thread'

# Initialize a Mutex
mutex = Mutex.new

# Shared resource
counter = 0

# Create threads
threads = 10.times.map do
  Thread.new do
    1000.times do
      # Lock the mutex before modifying the shared resource
      mutex.synchronize do
        counter  = 1
      end
    end
  end
end

# Wait for all threads to finish
threads.each(&:join)

puts "Final counter value: #{counter}"

इस उदाहरण में:

• हम एक म्यूटेक्स ऑब्जेक्ट को इनिशियलाइज़ करते हैं।
• हम एक साझा संसाधन (काउंटर) बनाते हैं जिसे कई थ्रेड्स द्वारा एक्सेस किया जाएगा।
• हम 10 थ्रेड बनाते हैं, प्रत्येक काउंटर को 1000 गुना बढ़ाता है।
• mutex.synchronize ब्लॉक के अंदर, हम सुनिश्चित करते हैं कि एक समय में केवल एक थ्रेड काउंटर को संशोधित कर सकता है।
• अंत में, हम काउंटर का अंतिम मान प्रिंट करते हैं, जो 10000 होना चाहिए यदि म्यूटेक्स ने एक्सेस को ठीक से सिंक्रनाइज़ किया है।

वास्तविक जीवन परिदृश्य: बैंक खाता लेनदेन का प्रबंधन

म्यूटेक्स के वास्तविक जीवन के अनुप्रयोग को समझने के लिए, आइए एक ऐसे परिदृश्य पर विचार करें जहां कई थ्रेड एक बैंक खाते पर लेनदेन का प्रतिनिधित्व करते हैं। प्रत्येक लेनदेन में पैसे जमा करना या निकालना शामिल हो सकता है, और हमें यह सुनिश्चित करना चाहिए कि खाते की शेष राशि सही रहे।

require 'thread'

# Initialize a Mutex
account_mutex = Mutex.new

# Bank account class
class BankAccount
  attr_reader :balance

  def initialize(balance = 0)
    @balance = balance
  end

  def deposit(amount)
    @balance  = amount
  end

  def withdraw(amount)
    @balance -= amount
  end
end

# Shared bank account
account = BankAccount.new(1000)

# Transactions
threads = []

# Deposit thread
threads 




  
  
  इस परिदृश्य में:

• हम जमा और निकासी विधियों के साथ एक बैंक खाता वर्ग को परिभाषित करते हैं।
• हम 1000 की प्रारंभिक शेष राशि के साथ एक साझा बैंक खाता उदाहरण बनाते हैं।
• हम दो थ्रेड बनाते हैं: एक पैसे जमा करने के लिए और एक पैसे निकालने के लिए।
• हम जमा और निकासी के तरीकों तक पहुंच को सिंक्रनाइज़ करने के लिए म्यूटेक्स का उपयोग करते हैं, यह सुनिश्चित करते हुए कि एक समय में केवल एक लेनदेन ही खाते की शेष राशि को संशोधित कर सकता है।
• अंत में, हम अंतिम खाता शेष प्रिंट करते हैं, जो सभी लेनदेन को सटीक रूप से प्रतिबिंबित करना चाहिए।

निष्कर्ष

समवर्ती और साझा संसाधनों से निपटने के दौरान रूबी में म्यूटेक्स का उपयोग करना आवश्यक है। यह यह सुनिश्चित करने का एक सरल लेकिन प्रभावी तरीका प्रदान करता है कि एक समय में केवल एक थ्रेड कोड के महत्वपूर्ण अनुभाग तक पहुंच सकता है, जिससे डेटा भ्रष्टाचार या दौड़ की स्थिति जैसे संभावित मुद्दों को रोका जा सकता है।