Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास · पाठ

स्टेट के लिए Refs, Agents और Atoms

थ्रेड के बीच परिवर्तनीय स्टेट को सुरक्षित रूप से प्रबंधित करने के लिए Clojure के मुख्य समवर्ती प्रिमिटिव का उपयोग करना सीखें

पाठ 1, कुल 4 में से13 चरण

स्टेट के लिए Refs, Agents और Atoms, CoddyKit पर Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

समवर्ती निष्पादन और स्थिति का परिचय

समवर्ती प्रोग्राम में स्थिति का प्रबंधन करना कठिन होता है! जब आपके कोड के कई हिस्से एक ही समय में एक ही डेटा को बदलने का प्रयास करते हैं, तो डेटा के दूषित होने या डेडलॉक जैसी गंभीर समस्याएँ आ सकती हैं।

Clojure साझा रूप से बदली जा सकने वाली स्थिति को सुरक्षित और कुशलता से संभालने के लिए शक्तिशाली टूल उपलब्ध कराता है।

Clojure का स्थिति संबंधी दर्शन

Clojure डिफ़ॉल्ट रूप से अपरिवर्तनीयता अपनाता है। इसका अर्थ है कि डेटा संरचनाएँ बनने के बाद बदलती नहीं हैं। लेकिन जब आपको वास्तव में किसी चीज़ को बदलने की आवश्यकता हो, जैसे किसी काउंटर या उपयोगकर्ता की शेष राशि को, तब क्या किया जाए?

Clojure विशेष समवर्ती निष्पादन के आदिम साधन उपलब्ध कराता है।
ये आदिम साधन बदली जा सकने वाली स्थिति को नियंत्रित तरीके से प्रबंधित करते हैं।
ये सुनिश्चित करते हैं कि कई थ्रेड के बीच भी बदलाव सुरक्षित रहें।

एटम: स्वतंत्र स्थिति

एक एटम बदली जा सकने वाली स्थिति के किसी एक, स्वतंत्र हिस्से को प्रबंधित करने का सबसे सरल तरीका है। यह काउंटर या फ़्लैग जैसी चीज़ों के लिए बहुत उपयोगी है।

अपडेट समकालिक और परमाण्विक होते हैं (या तो पूरा बदलाव होगा या बिल्कुल नहीं होगा)।
एटम अंदरूनी रूप से Compare-And-Swap (CAS) लूप का उपयोग करते हैं।
इनका उपयोग ऐसी स्थिति के लिए सबसे अच्छा है जिसे स्थिति के अन्य हिस्सों के साथ समन्वित करने की आवश्यकता न हो।

एटम कोड का उदाहरण

आइए एटम को काम करते हुए देखते हैं। हम एक सरल काउंटर बनाएँगे और उसे अपडेट करेंगे।

(ns coddykit.core
  (:gen-class))

(defn -main
  "Demonstrates Clojure Atoms."
  [& args]
  (let [my-counter (atom 0)]
    (println "Initial value:" @my-counter)

    (swap! my-counter inc)
    (println "After inc:" @my-counter)

    (swap! my-counter + 5)
    (println "After add 5:" @my-counter)))

एटम के `swap!` को समझना

एटम को अपडेट करने के लिए swap! फ़ंक्शन महत्वपूर्ण है:

यह एटम, एक फ़ंक्शन और उस फ़ंक्शन के लिए वैकल्पिक तर्क लेता है।
(swap! my-atom inc) मान को परमाण्विक रूप से बढ़ाता है।
(swap! my-atom + 5) मान में 5 को परमाण्विक रूप से जोड़ता है।
फ़ंक्शन एटम के वर्तमान मान पर लागू होता है और परिणाम नया मान बन जाता है। यह थ्रेड-सुरक्षित तरीके से होता है।

Ref: समन्वित स्थिति

Ref का उपयोग समन्वित बदली जा सकने वाली स्थिति को प्रबंधित करने के लिए किया जाता है। इसका अर्थ है कि स्थिति के कई हिस्सों को एक साथ बदलना आवश्यक हो, या बिल्कुल न बदलना हो।

Ref, Clojure की सॉफ़्टवेयर ट्रांज़ैक्शनल मेमोरी (STM) का उपयोग करते हैं।
बदलाव एक लेन-देन (dosync ब्लॉक) के भीतर होते हैं।
लेन-देन में किए गए सभी बदलाव एक समूह के रूप में या तो सफल होते हैं या विफल।

Ref कोड का उदाहरण

दो खातों के बीच किसी मान को परमाण्विक रूप से स्थानांतरित करने के लिए Ref का उपयोग इस प्रकार करें। यदि एक विफल होता है, तो दोनों बदलाव पूर्ववत हो जाते हैं।

(ns coddykit.core
  (:gen-class))

(defn -main
  "Demonstrates Clojure Refs and STM."
  [& args]
  (let [account-a (ref 100)
        account-b (ref 50)
        amount-to-transfer 20]

    (println "Initial: A=" @account-a "B=" @account-b)

    (dosync
      (alter account-a - amount-to-transfer)
      (alter account-b + amount-to-transfer))

    (println "After transfer: A=" @account-a "B=" @account-b)))

Ref के साथ STM को समझना

dosync ब्लॉक एक लेन-देन परिभाषित करता है:

ref एक नया Ref बनाता है।
alter लेन-देन के भीतर किसी Ref का मान बदलता है। यह Ref, एक फ़ंक्शन और उसके तर्क लेता है।
यदि dosync ब्लॉक का कोई भी भाग विफल होता है, तो सभी बदलाव वापस कर दिए जाते हैं।
इससे परमाण्विकता सुनिश्चित होती है: या तो सब कुछ होगा या कुछ भी नहीं।

एजेंट: अतुल्यकालिक स्थिति

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

अपडेट संदेशों के रूप में एजेंट को भेजे जाते हैं।
एजेंट इन संदेशों को एक अलग थ्रेड में संसाधित करता है।
इससे अलगाव मिलता है: एजेंट की स्थिति केवल उसकी अपनी प्रक्रिया के माध्यम से बदलती है।

एजेंट कोड का उदाहरण

आइए संख्याओं की एक सूची को अतुल्यकालिक रूप से संसाधित करके उनका योग निकालने के लिए एजेंट का उपयोग करें।

(ns coddykit.core
  (:gen-class))

(defn -main
  "Demonstrates Clojure Agents."
  [& args]
  (let [sum-agent (agent 0)]
    (println "Initial sum:" @sum-agent)

    (send sum-agent + 10)
    (send sum-agent + 20)
    (send sum-agent + 5)

    (println "Waiting for agent to finish...")
    (await sum-agent) ; Wait for all sent actions to complete
    
    (println "Final sum:" @sum-agent)))

एजेंट का कार्यप्रवाह

एजेंट इस प्रकार कार्य करते हैं:

agent प्रारंभिक मान वाला एक नया एजेंट बनाता है।
send एजेंट को एक फ़ंक्शन और तर्क भेजता है। यह फ़ंक्शन किसी अन्य थ्रेड पर एजेंट की वर्तमान स्थिति पर लागू किया जाएगा।
एजेंट अपने थ्रेड में एक-एक करके संदेशों को संसाधित करता है, जिससे अपडेट अलग-अलग बने रहते हैं।
await (या await-for) का उपयोग वर्तमान थ्रेड को तब तक रोकने के लिए किया जाता है, जब तक एजेंट सभी लंबित क्रियाओं को संसाधित न कर ले।

सही प्रिमिटिव चुनना

आपने Atoms, Refs और Agents के बारे में सीखा है। परिवर्तनीय स्थिति को सुरक्षित रूप से प्रबंधित करने के लिए प्रत्येक का एक विशिष्ट उद्देश्य है।

निम्नलिखित में से कौन-से कथन सही रूप से बताते हैं कि किस स्थिति में कौन-सा समवर्ती प्रिमिटिव उपयोग करना चाहिए?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: स्थिति प्रबंधन

इस पाठ में हमने परिवर्तनीय स्थिति को सुरक्षित रूप से प्रबंधित करने के लिए Clojure के मुख्य समवर्ती प्रिमिटिव का अध्ययन किया:

Atoms: सरल, स्वतंत्र और तुल्यकालिक स्थिति परिवर्तनों के लिए।
Refs: STM का उपयोग करके कई मानों में समन्वित, लेन-देनात्मक स्थिति परिवर्तनों के लिए।
Agents: अतुल्यकालिक और अलग-अलग स्थिति अपडेट के लिए, जिन्हें अलग थ्रेड में संसाधित किया जाता है।

मज़बूत और समवर्ती Clojure अनुप्रयोग बनाने के लिए इन उपकरणों को समझना बहुत महत्वपूर्ण है!

शुरुआत निःशुल्क

एआई शिक्षक के साथ Clojure सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “स्टेट के लिए Refs, Agents और Atoms” पाठ निःशुल्क है?

हाँ—“स्टेट के लिए Refs, Agents और Atoms” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“स्टेट के लिए Refs, Agents और Atoms” में मैं क्या सीखूँगा?

थ्रेड के बीच परिवर्तनीय स्टेट को सुरक्षित रूप से प्रबंधित करने के लिए Clojure के मुख्य समवर्ती प्रिमिटिव का उपयोग करना सीखें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“स्टेट के लिए Refs, Agents और Atoms” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Clojure में कार्यात्मक प्रोग्रामिंग और JVM बैकएंड विकास पर वापस जाएँ