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

सॉफ़्टवेयर लेन-देनात्मक मेमोरी (STM)

समझें कि Clojure की STM साझा स्टेट के लिए परमाण्विक, सुसंगत, पृथक और टिकाऊ (ACID) लेन-देन कैसे उपलब्ध कराती है

पाठ 2, कुल 4 में से11 चरण

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

सॉफ़्टवेयर लेन-देनात्मक मेमोरी क्या है?

बैंक हस्तांतरण की कल्पना कीजिए: आप नहीं चाहेंगे कि पैसा अचानक गायब हो जाए या कहीं से प्रकट हो जाए। आप चाहेंगे कि पूरी प्रक्रिया या तो पूरी तरह सफल हो या पूरी तरह विफल।

Clojure में सॉफ़्टवेयर लेन-देनात्मक मेमोरी (STM) समवर्ती प्रोग्रामों में साझा, परिवर्तनीय स्थिति को प्रबंधित करने के लिए इसी प्रकार की गारंटी देती है।

यह आपके अनुप्रयोग की मेमोरी के लिए एक छोटी डेटाबेस लेन-देन प्रणाली जैसी है।
यह सुनिश्चित करती है कि साझा डेटा पर होने वाली क्रियाएँ "या तो पूरी हों या बिल्कुल न हों।"

हमें STM की आवश्यकता क्यों है

समवर्ती प्रोग्रामिंग में, आपके कोड के कई भाग एक ही समय पर डेटा के एक ही हिस्से को बदलने का प्रयास कर सकते हैं। इससे निम्न समस्याएँ हो सकती हैं:

रेस कंडीशन: परिणाम क्रियाओं के अप्रत्याशित समय पर निर्भर करता है।
असंगत स्थिति: डेटा दूषित हो जाता है या आंशिक रूप से अपडेट होता है।

STM साझा डेटा तक पहुँच का समन्वय करके इन समस्याओं को रोकने में मदद करता है और डेटा की अखंडता सुनिश्चित करता है।

Clojure के `Ref` का परिचय

Clojure का STM विशेष डेटा कंटेनरों का प्रबंधन करता है जिन्हें Refs कहा जाता है। सामान्य चरों के विपरीत, Refs लेन-देनात्मक अपडेट के लिए बनाए गए हैं।

एक Ref ऐसा मान रखता है जिसे बदला जा सकता है, लेकिन केवल किसी लेन-देन के भीतर।
आप (ref initial-value) का उपयोग करके प्रारंभिक मान वाला Ref बनाते हैं।

Ref को अपने डेटा के लिए एक सुरक्षित तिजोरी जैसा समझिए, जो केवल लेन-देन के समय खुलती है।

`dosync` के साथ परमाणु अपडेट

Refs पर क्रियाएँ करने के लिए आपको उन्हें dosync मैक्रो के भीतर रखना होगा।

dosync एक लेन-देन ब्लॉक परिभाषित करता है।
dosync के भीतर Refs में होने वाले सभी परिवर्तन एकल, परमाणु इकाई माने जाते हैं।
यदि लेन-देन का कोई भी भाग विफल होता है, तो सभी परिवर्तन वापस ले लिए जाते हैं।

यह सुनिश्चित करता है कि समवर्ती पहुँच के बावजूद आपका डेटा सुसंगत बना रहे।

`Ref`s में बदलाव: `alter`

dosync ब्लॉक के भीतर, Ref का मान बदलने के लिए आप alter का उपयोग करते हैं।

(alter a-ref update-fn & args)

update-fn वह फ़ंक्शन है जो Ref के वर्तमान मान पर लागू किया जाता है।
& args वे अतिरिक्त तर्क हैं जो update-fn को दिए जाते हैं।
यदि कोई टकराव (किसी अन्य लेन-देन द्वारा उसी Ref में बदलाव) पाया जाता है, तो alter लेन-देन का दोबारा प्रयास करेगा।

`dosync` और `alter` का प्रयोग

यह उदाहरण दिखाता है कि `dosync` और `alter` साथ मिलकर कैसे काम करते हैं। हम किसी लेन-देन के भीतर एक Ref को कई बार अपडेट करेंगे।

(def balance (ref 100))

(defn deposit [amount]
  (dosync
    (println "Current balance (inside transaction):" @balance)
    (alter balance + amount)
    (println "New balance (inside transaction):" @balance)))

(defn -main []
  (println "Initial balance:" @balance)
  (deposit 50)
  (println "Final balance:" @balance))

(-main)

स्वतंत्र परिवर्तनों के लिए `commute`

कभी-कभी क्रियाओं का क्रम महत्वपूर्ण नहीं होता, जैसे किसी सूची में जोड़ना या गिनती करना। ऐसी क्रियाओं के लिए alter के बजाय commute का उपयोग करें।

(commute a-ref update-fn & args)

commute किसी अपडेट को "क्रम-विनिमेय" के रूप में चिह्नित करता है।
इससे लेन-देन के दोबारा प्रयास की संभावना कम हो सकती है और प्रदर्शन बेहतर हो सकता है।
यह उन क्रियाओं के लिए सबसे अच्छा काम करता है जहाँ `(f (f x a) b)` और `(f (f x b) a)` समान हों।

कई थ्रेड के साथ `commute`

यहाँ एक उदाहरण है जिसमें कई थ्रेड `commute` का उपयोग करके एक काउंटर को समवर्ती रूप से बढ़ाते हैं। इससे पता चलता है कि STM साझा स्थिति को सुरक्षित और प्रभावी ढंग से कैसे प्रबंधित करता है।

(def counter (ref 0))

(defn increment-counter []
  (dosync
    (commute counter inc)))

(defn -main []
  (println "Initial counter:" @counter)
  (let [futures (doall (for [_ (range 10)]
                         (future (dotimes [_ 100] (increment-counter)))))]
    (doseq [f futures] @f)) ; Wait for all futures to complete
  (println "Final counter:" @counter))

(-main)

STM की ACID गारंटियाँ

Clojure का STM मज़बूत गारंटियाँ देता है, जिन्हें अक्सर ACID संक्षिप्त नाम से बताया जाता है:

परमाणुता: सब कुछ या कुछ भी नहीं। कोई लेन-देन या तो पूरी तरह पूरा होता है या पूरी तरह विफल।
संगति: लेन-देन डेटा को एक मान्य स्थिति से दूसरी मान्य स्थिति में ले जाते हैं।
अलगाव: समवर्ती लेन-देन क्रमिक रूप से निष्पादित होते हुए दिखाई देते हैं, जिससे हस्तक्षेप रुकता है।
स्थायित्व: (सीधे मेमोरी में मौजूद STM पर कम लागू होता है, लेकिन सफल प्रतिबद्धता से निहित होता है) एक बार लेन-देन प्रतिबद्ध हो जाने पर उसके परिवर्तन स्थायी हो जाते हैं।

STM की त्वरित जाँच

निम्नलिखित Clojure कोड अंश पर विचार कीजिए:

(def data (ref []))

(defn add-item [item]
  (dosync
    (alter data conj item)))

(add-item 10)
(add-item 20)

(println @data)

(println @data) का अंतिम आउटपुट क्या होगा?

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

STM का पुनरावलोकन और आगे

इस पाठ में हमने Clojure की शक्तिशाली सॉफ़्टवेयर लेन-देनात्मक मेमोरी (STM) प्रणाली का अध्ययन किया।

हमने साझा स्थिति के प्रबंधन के लिए Refs के बारे में सीखा।
dosync मैक्रो परमाणु लेन-देन सुनिश्चित करता है।
alter टकराव का पता लगाकर और दोबारा प्रयास करके Refs को अपडेट करता है।
commute क्रम-विनिमेय क्रियाओं के लिए अपडेट को बेहतर बनाता है।
STM मज़बूत समवर्तीता के लिए ACID गारंटियाँ प्रदान करता है।

आगे हम अतुल्यकालिक क्रियाओं के लिए Promises और Futures जैसे अन्य समवर्ती प्रिमिटिव देखेंगे!

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

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

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

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

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

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

क्या “सॉफ़्टवेयर लेन-देनात्मक मेमोरी (STM)” पाठ निःशुल्क है?

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

“सॉफ़्टवेयर लेन-देनात्मक मेमोरी (STM)” में मैं क्या सीखूँगा?

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

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

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

“सॉफ़्टवेयर लेन-देनात्मक मेमोरी (STM)” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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