रस्ट ट्यूटोरियल: मेमोरी सुरक्षा और समवर्तीता

रस्ट उन भाषाओं में से एक बन गई है जो प्रत्येक सिस्टम डेवलपर को यह बात बार-बार सुननी पड़ती है।यह C और C++ जितना ही तेज़ है, लेकिन मेमोरी सुरक्षा और सुव्यवस्थित समवर्तीता पर लगभग जुनूनी ध्यान केंद्रित करता है। यह सिर्फ़ खोखली मार्केटिंग नहीं है: इसका डिज़ाइन संकलन के समय कंपाइलर द्वारा त्रुटियों का पता लगाने के इर्द-गिर्द घूमता है—ऐसी त्रुटियाँ जो अन्य भाषाओं में आपको केवल तब दिखाई देती हैं जब सिस्टम पहले से ही उत्पादन में हो... या जब यह क्रैश हो जाए।

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

रस्ट ट्यूटोरियल: प्रदर्शन, मेमोरी सुरक्षा और समवर्तीता

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

इसकी परिभाषित विशेषता यह है कि संकलन समय पर मेमोरी सुरक्षा की गारंटी देता है बिना किसी गार्बेज कलेक्टर का इस्तेमाल किए। इसके बजाय, रस्ट एक ओनरशिप सिस्टम और एक बॉरो चेकर का इस्तेमाल करता है जो प्रत्येक मान और उसके संदर्भों के जीवनकाल को ट्रैक करता है। यह लटकते पॉइंटर्स, बफर ओवरफ्लो या मेमोरी लीक जैसी पारंपरिक समस्याओं से बचाता है, बिना स्वचालित संदर्भ गणना या गार्बेज कलेक्शन की आवश्यकता के।

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

इन सभी कारणों से, बड़ी कंपनियां जैसे ड्रॉपबॉक्स, माइक्रोसॉफ्ट, अमेज़न या गूगल उन्होंने अपने बुनियादी ढाँचे के महत्वपूर्ण हिस्सों में रस्ट को अपनाया है। और यह कोई संयोग नहीं है कि यह वर्षों से स्टैक ओवरफ्लो पोल में डेवलपर्स द्वारा "सबसे पसंदीदा" भाषाओं में से एक के रूप में शीर्ष पर रही है: यह C++-शैली के प्रदर्शन को एक आधुनिक टूलसेट (कार्गो, crates.io) और एक बेहद सक्रिय समुदाय, जिसे रस्टेशियन कहा जाता है, के साथ जोड़ती है।

बुनियादी अवधारणाएँ: प्रोग्रामिंग भाषा, प्रकार और मेमोरी

मेमोरी सुरक्षा और समवर्तीता की बारीकियों में जाने से पहले, कुछ सामान्य अवधारणाओं को स्पष्ट करना उचित है जो पूरे सिस्टम में दिखाई देती हैं। समय रस्ट के साथ काम करते समय, खासकर यदि आप अन्य भाषाओं से आते हैं या अभी प्रोग्रामिंग शुरू कर रहे हैं.

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

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

रस्ट में ऐसे शब्द भी शामिल हैं स्मार्ट प्रकार और संकेतएक प्रकार यह बताता है कि एक चर किस प्रकार का डेटा संग्रहीत करता है (पूर्णांक, फ़्लोट, स्ट्रिंग, संरचनाएँ, आदि) और इसे कैसे नियंत्रित किया जा सकता है। स्मार्ट पॉइंटर्स (उदाहरण के लिए, Box, Rc y Arc) ऐसी संरचनाएं हैं जो मेमोरी एड्रेस को एनकैप्सुलेट करती हैं और संसाधनों को सुरक्षित रूप से प्रबंधित करने के लिए अतिरिक्त तर्क जोड़ती हैं, जैसे साझा संदर्भों की गणना करना या मूल्यों को हीप में ले जाना।

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

रस्ट क्यों सीखें: मेमोरी सुरक्षा और निडर समवर्तीता

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

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

मेमोरी सुरक्षा इस पर आधारित है स्वामित्व और ऋण प्रणालीकोई गार्बेज कलेक्टर नहीं है, लेकिन कंपाइलर को ठीक-ठीक पता होता है कि प्रत्येक संसाधन का मालिक कौन है, कब उसकी ज़रूरत नहीं रह जाती, और कब उसे रिलीज़ किया जा सकता है। इससे लीक, लटकते पॉइंटर्स और कई ऐसी त्रुटियों से बचाव होता है जिन्होंने पारंपरिक रूप से C और C++ प्रोग्रामिंग को इतना खतरनाक बना दिया है।

प्रतियोगिता के क्षेत्र में, रस्ट वह करता है जिसे आमतौर पर कहा जाता है “बिना किसी डर के समवर्तीता”टाइप सिस्टम स्वयं डेटा रूट्स को सुरक्षित कोड में मौजूद रहने से रोकता है। यदि आप थ्रेड्स के बीच परिवर्तनशील डेटा साझा करना चाहते हैं, तो आपको उपयुक्त प्रिमिटिव्स का उपयोग करना होगा, जैसे कि Mutex, RwLock o Arc, और संकलक यह सुनिश्चित करेगा कि उपनाम और परिवर्तनशीलता नियमों का सम्मान किया जाए।

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

स्थापना और आवश्यक उपकरण: रस्टअप, रस्टसी और कार्गो

रस्ट में अपना पहला प्रोग्राम लिखने और चलाने के लिए, सामान्य तरीका आधिकारिक टूलचेन को इंस्टॉल करना है जंग (देखें रस्ट का संपूर्ण परिचय), एक सरल इंस्टॉलर और संस्करण प्रबंधक जो सभी प्रमुख ऑपरेटिंग सिस्टम पर काम करता है।

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

संकलक rustc यह आपके सोर्स कोड को एक्ज़ीक्यूटेबल बाइनरी या लाइब्रेरी में बदल देता है। हालाँकि आप इसे सीधे भी इस्तेमाल कर सकते हैं comandos जैसा rustc main.rsव्यवहार में, आप लगभग हमेशा कार्गो के माध्यम से काम करेंगे, जो कॉल को संभालता है rustc सही विकल्पों के साथ.

वर्कफ़्लो का केंद्रीय उपकरण है माल गाड़ीबस कुछ कमांड्स की मदद से, आप crates.io पर नए प्रोजेक्ट बना सकते हैं, निर्भरताएँ प्रबंधित कर सकते हैं, पैकेज संकलित, चला, परीक्षण और प्रकाशित कर सकते हैं। कुछ सामान्यतः उपयोग किए जाने वाले बुनियादी कमांड्स ये हैं: cargo new, cargo build, cargo run, cargo test y cargo check, जो अंतिम निष्पादन योग्य बनाये बिना कोड की जांच करता है, त्रुटियों का शीघ्र पता लगाने के लिए आदर्श है।

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

आपका पहला प्रोग्राम: हैलो, रस्ट, और बेसिक फ्लो

किसी भी भाषा में बातचीत शुरू करने का पारंपरिक तरीका प्रसिद्ध "हैलो, वर्ल्ड" है। रस्ट में, एक फ़ाइल main.rs न्यूनतम में एक फ़ंक्शन जैसा सरल कुछ भी शामिल हो सकता है main जो स्क्रीन पर एक स्ट्रिंग प्रिंट करता है.

कीवर्ड fn यह दर्शाता है कि हम एक फ़ंक्शन परिभाषित कर रहे हैं, और main यह प्रोग्राम का प्रवेश बिंदु है। फ़ंक्शन का कोड ब्लॉक कर्ली ब्रेसेज़ के अंदर होता है। कंसोल में लिखने के लिए, इसका उपयोग करें। मैक्रो println!, जो एक स्ट्रिंग लिटरल (या बुकमार्क के साथ एक टेम्पलेट) को स्वीकार करता है और इसे एक न्यूलाइन कैरेक्टर में समाप्त होने वाले मानक आउटपुट पर भेजता है।

यदि आप सीधे संकलित करते हैं rustc main.rs, आपको एक निष्पादन योग्य बाइनरी मिलेगी (उदाहरण के लिए, main o main.exe (सिस्टम के आधार पर)। जब आप इसे चलाएँगे, तो आपको टर्मिनल में संदेश दिखाई देगा। लेकिन रस्ट के साथ काम करने का मुहावरेदार तरीका यह है कि प्रोजेक्ट का नेतृत्व कार्गो को करने दिया जाए।

साथ cargo new nombre_proyecto एक फ़ोल्डर संरचना स्वचालित रूप से बनाई जाती है src/main.rs पहले से ही "हैलो, वर्ल्ड" और एक फ़ाइल के साथ तैयार Cargo.toml जिसमें मेटाडेटा और भविष्य की निर्भरताएँ शामिल हैं। वहाँ से, cargo run बाइनरी को संकलित और चलाएंऔर यह केवल तभी पुनः संकलित होता है जब इसमें परिवर्तन का पता चलता है।

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

// हम मुख्य फ़ंक्शन घोषित करते हैं: प्रोग्राम प्रवेश बिंदु fn main() { // हम कंसोल पर टेक्स्ट प्रिंट करने के लिए println! मैक्रो का उपयोग करते हैं println!("Hello, world!"); }

चर, परिवर्तनशीलता और बुनियादी डेटा प्रकार

रस्ट में, वेरिएबल्स को कीवर्ड के साथ घोषित किया जाता है let, और डिफ़ॉल्ट रूप से अपरिवर्तनीय हैंदूसरे शब्दों में, एक बार जब आप उन्हें कोई मान दे देते हैं, तो आप उसे तब तक संशोधित नहीं कर सकते जब तक कि आप उसे स्पष्ट रूप से परिवर्तनशील घोषित न कर दें mut.

डिफ़ॉल्ट रूप से अपरिवर्तनीयता सूक्ष्म तर्क त्रुटियों से बचने में मदद करती है, खासकर समवर्ती प्रोग्रामों में जहाँ कई थ्रेड एक ही मान को बदलना चाह सकते हैं। अगर आपको इसे बदलने की ज़रूरत है, तो आप कुछ इस तरह लिख सकते हैं let mut contador = 0;वहां से आप नए मान पुनः निर्दिष्ट कर सकते हैं contador.

जंग तथाकथित को भी अनुमति देता है ग्रहणआप उसी स्कोप में उसी नाम से एक नया वेरिएबल घोषित कर सकते हैं, पिछले वेरिएबल को छिपाते हुए। यह म्यूटेशन जैसा नहीं है, क्योंकि आप एक नया मान बना रहे हैं (जो किसी अलग प्रकार का भी हो सकता है)। उदाहरण के लिए, आप उसी नाम का उपयोग करके एक स्ट्रिंग को पूर्णांक में बदल सकते हैं, बशर्ते यह एक नई घोषणा हो। let.

रस्ट की प्रकार प्रणाली स्थिर है, जिसका अर्थ है कि प्रत्येक चर का प्रकार संकलन के समय ज्ञात होता हैहालाँकि, प्रकार अनुमान काफी शक्तिशाली है: यदि आप लिखते हैं let x = 5;संकलक मानता है कि यह एक i32 जब तक कि आप अन्यथा न कहें। आप इस तरह के नोट्स जोड़ सकते हैं let x: i64 = 5; जब आप स्पष्ट होना चाहते हैं।

उपलब्ध स्केलर प्रकारों में हस्ताक्षरित और अहस्ताक्षरित पूर्णांक शामिल हैं (i8, u8, i32, आदि), तैरने वाले (f32, f64), बूलियन (bool) और यूनिकोड वर्ण (char). इन सरल प्रकारों की नकल करना आमतौर पर सस्ता होता है और कई लोग इस विशेषता को लागू करते हैं Copyजिसका अर्थ है कि जब आप उन्हें असाइन करते हैं या किसी फ़ंक्शन को पास करते हैं, तो उन्हें स्थानांतरित करने के बजाय कॉपी किया जाता है।

रस्ट में स्ट्रिंग्स: &str और स्ट्रिंग

रस्ट में टेक्स्ट हैंडलिंग शुरू में थोड़ी भ्रामक हो सकती है क्योंकि यह स्पष्ट रूप से अंतर करती है चेन “स्लाइस” और मालिकाना चेनदो प्रमुख अंश हैं &str y String.

Un &str एक है अपरिवर्तनीय श्रृंखला का टुकड़ाकिसी स्थान पर संग्रहीत UTF-8 बाइट अनुक्रम का एक दृश्य। विशिष्ट उदाहरणों में शामिल हैं: "Hola"जो इस प्रकार के हैं &'static str (वे प्रोग्राम के सम्पूर्ण जीवनकाल के लिए विद्यमान रहते हैं तथा बाइनरी में सन्निहित होते हैं।) स्लाइस डेटा के स्वामी नहीं होते; वे केवल उस ओर संकेत करते हैं।

Stringदूसरी ओर, यह एक स्वयं का स्ट्रिंग, परिवर्तनीय और हीप में होस्ट किया गयाइसका आकार बदला जा सकता है, संयोजित किया जा सकता है, इसके गुण को स्थानांतरित करके कार्यों के बीच पारित किया जा सकता है, आदि। इसका उपयोग अक्सर तब किया जाता है जब आप गतिशील पाठ का निर्माण करना चाहते हैं या इसे संरचनाओं के भीतर दीर्घकालिक रूप से संग्रहीत करना चाहते हैं।

कई परिदृश्यों में आप एक से दूसरे के बीच रूपांतरण करेंगे: उदाहरण के लिए, आप एक बनाएंगे String::from("hola") एक टुकड़े सेया आप उधार लेंगे &str द्वारा String उन कार्यों को संदर्भ देकर जिन्हें केवल पढ़ने की आवश्यकता है।

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

फ़ंक्शन, नियंत्रण प्रवाह और टिप्पणियाँ

Rust में फ़ंक्शन निम्न के साथ परिभाषित किए गए हैं fn और प्रोग्राम को पुन: प्रयोज्य तार्किक इकाइयों में व्यवस्थित करने की अनुमति देते हैं। प्रत्येक फ़ंक्शन निर्दिष्ट करता है इसके पैरामीटर का प्रकार और इसका रिटर्न प्रकार एक तीर का अनुसरण करते हुए ->यदि यह कुछ भी सार्थक नहीं लौटाता है, तो एकात्मक प्रकार मान लिया जाता है। ().

एक महत्वपूर्ण विवरण यह है कि किसी फ़ंक्शन (या किसी भी ब्लॉक) में अर्धविराम के बिना अंतिम अभिव्यक्ति को अंतर्निहित वापसी मान के रूप में लिया जाता है। आप इसका उपयोग कर सकते हैं return जल्दी रिटर्न के लिएलेकिन मुहावरेदार कोड में, आप अक्सर अंतिम अभिव्यक्ति को बिना छोड़े छोड़ देते हैं। ;.

नियंत्रण प्रवाह को क्लासिक्स के साथ नियंत्रित किया जाता है if/elseछोरों loop, while y forजंग में, if यह एक अभिव्यक्ति है जो एक मान लौटाती हैतो आप इसे सीधे उपयोग कर सकते हैं letबशर्ते शाखाएँ एक ही प्रकार लौटाएँ। लूप्स for वे आम तौर पर श्रेणियों या संग्रह पुनरावर्तकों पर पुनरावृति करते हैं और मैनुअल अनुक्रमणिकाओं के बजाय अनुशंसित विकल्प हैं।

कोड का दस्तावेजीकरण करने और उसके बाद आने वाले लोगों (एक महीने में स्वयं सहित) के लिए जीवन को आसान बनाने के लिए, आप इसका उपयोग कर सकते हैं पंक्ति टिप्पणियाँ के साथ // या ब्लॉक करें /* ... */इसके अलावा, Rust दस्तावेज़ीकरण टिप्पणियाँ भी प्रदान करता है /// जो उत्पन्न दस्तावेज बन जाते हैं, हालांकि यह बड़ी परियोजनाओं में अधिक उपयुक्त होता है।

स्वामित्व, उधार और जीवनकाल: स्मृति सुरक्षा की नींव

यहाँ हम रस्ट के मेमोरी मॉडल के केंद्र तक पहुँचते हैं: की प्रणाली स्वामित्व, उधार और जीवनकालये नियम सुनिश्चित करते हैं कि संदर्भ हमेशा वैध रहें और मेमोरी को संचित कचरे के बिना सुरक्षित रूप से जारी किया जाए।

स्वामित्व के बुनियादी नियमों को बताना सरल है, यद्यपि उन्हें शुरू में आत्मसात करना कठिन हो सकता है: प्रत्येक मान का एक ही स्वामी होता है।एक समय में केवल एक ही स्वामी हो सकता है; और जब स्वामी अपने दायरे से बाहर चला जाता है, तो मान नष्ट हो जाता है और उसकी मेमोरी रिलीज़ हो जाती है। उदाहरण के लिए, यह एक String: जिस ब्लॉक पर इसे घोषित किया गया था, उसके पूरा होने पर, यह स्वचालित रूप से लागू हो जाता है drop जो हीप मेमोरी को मुक्त करता है।

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

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

ऋण के नियमों को संक्षेप में इस प्रकार बताया जा सकता है: किसी भी समय, आपके पास या तो कई अपरिवर्तनीय संदर्भ किसी मान पर, या एक एकल परिवर्तनीय संदर्भलेकिन दोनों एक साथ नहीं। इससे साझा मेमोरी में रेस कंडीशन खत्म हो जाती है: या तो कई रीडर होते हैं, या एक अलग राइटर होता है; एक ही डेटा पर एक ही समय पर रीडर और राइटर कभी एक साथ नहीं होते।

संयुक्त प्रकार: स्ट्रक्चर्स, एनम्स और स्मार्ट पॉइंटर्स

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

किसी स्ट्रक्चर का इंस्टेंस बनाने के लिए, आपको उसके सभी फ़ील्ड भरने होंगे, और आप उस वेरिएबल को परिवर्तनीय के रूप में चिह्नित कर सकते हैं जिससे बाद में उसके मान बदले जा सकें। स्ट्रक्चर अपडेट सिंटैक्स भी उपलब्ध है, जो आपको किसी मौजूदा इंस्टेंस के कुछ फ़ील्ड का पुन: उपयोग करके एक नया इंस्टेंस बनाने की अनुमति देता है। ..otro_struct.

L एन्यूम्स वे एक और ज़रूरी आधार हैं: वे आपको एक प्रकार निर्धारित करने की अनुमति देते हैं जो कई संभावित प्रकारों में से एक हो सकता है, प्रत्येक का अपना संबद्ध डेटा हो सकता है या नहीं भी हो सकता है। इसका एक उत्कृष्ट उदाहरण IP पतों के लिए एक enum है, जिसमें एक प्रकार होता है। V4 जो चार अष्टक और एक अन्य संग्रहीत करता है V6 जो IPv6 संकेतन के साथ एक स्ट्रिंग संग्रहीत करता है।

रस्ट के मानक पुस्तकालय में दो बहुत महत्वपूर्ण enums शामिल हैं: Option<T> y Result<T, E>पहला मान (कुछ या कुछ नहीं) की उपस्थिति या अनुपस्थिति को दर्शाता है, और इसका उपयोग शून्य पॉइंटर्स से बचने के लिए किया जाता है; दूसरा उन ऑपरेशनों को मॉडल करता है जो सही परिणाम या त्रुटि लौटाएँ, जिसके लिए यह आवश्यक है कि त्रुटि प्रबंधन स्पष्ट और सुरक्षित हो।

गतिशील मेमोरी का प्रबंधन करने और डेटा साझा करने के लिए, रस्ट ने स्मार्ट पॉइंटर्स जैसा Box<T>, जो एक मान को हीप में ले जाता है और अद्वितीय स्वामित्व बनाए रखता है; Rc<T>, एकल-थ्रेडेड वातावरण के लिए एक साझा संदर्भ गणना; और Arc<T>, के समान है Rc लेकिन कई थ्रेड्स के लिए सुरक्षित। डायनामिक मेमोरी को कॉन्करेंसी के साथ जोड़ते समय इनका सही इस्तेमाल ज़रूरी है।

कार्गो और क्रेट पारिस्थितिकी तंत्र

कार्गो वह गोंद है जो रस्ट पारिस्थितिकी तंत्र को एक साथ रखता है: संकलन, निर्भरता और परियोजना जीवनचक्र का प्रबंधन करता हैप्रत्येक परियोजना की एक फ़ाइल होती है Cargo.toml जो एक मैनिफ़ेस्ट के रूप में कार्य करता है, नाम, संस्करण, भाषा संस्करण और बाहरी निर्भरताओं की घोषणा करता है।

अनुभाग यह फ़ाइल आपको तृतीय-पक्ष क्रेटों को उनके संस्करणों के साथ सूचीबद्ध करने की अनुमति देती है। जब आप चलाते हैं cargo build o cargo runकार्गो इन क्रेटों को crates.io से स्वचालित रूप से डाउनलोड करता है, उन्हें संकलित करता है और आपके प्रोजेक्ट से लिंक करता है। उदाहरण के लिए, रैंडम नंबर जनरेटर, वेब फ्रेमवर्क या क्रिप्टोग्राफ़िक लाइब्रेरी जोड़ना इतना आसान है।

सबसे आम आदेशों में से हैं cargo new बाइनरी परियोजनाएं शुरू करने के लिए o cargo new --lib पुस्तकालयों के लिए; cargo build डिबग मोड में संकलित करने के लिए; cargo build --release एक अनुकूलित, उत्पादन-उन्मुख संस्करण प्राप्त करने के लिए; और cargo test परीक्षणों की श्रृंखला चलाने के लिए।

cargo check यह विशेष उल्लेख के योग्य है: यह बाइनरी उत्पन्न किए बिना कोड को एक मध्यवर्ती बिंदु तक संकलित करता है, जिससे यह संकलन त्रुटियों का पता लगाने में बहुत तेज़ होनायह शीघ्रता से पुनरावृत्ति करने के लिए एकदम उपयुक्त है, जबकि उधार परीक्षक गुणों, संदर्भों और जीवनकालों के साथ समस्याओं को इंगित करता है।

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

रस्ट में समवर्तीता: थ्रेड्स, म्यूटेक्स, चैनल और एटॉमिक्स

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

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

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

अंतर-थ्रेडेड संचार का एक अन्य सामान्य रूप, जिसे रस्ट में अत्यधिक प्रोत्साहित किया जाता है, वह है संदेश भेजना चैनलोंएक चैनल में एक भेजने वाला सिरा और एक प्राप्त करने वाला सिरा होता है; थ्रेड्स इसके माध्यम से संदेश (मान) भेजते हैं, जिससे परिवर्तनशील साझा मेमोरी का उपयोग कम हो जाता है और सिस्टम की स्थिति के बारे में तर्क करना सरल हो जाता है।

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

समवर्तीता और परमाणु सीखने के लिए प्रारंभिक चरण और संसाधन

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

अधिक आसानी के लिए, पहले स्वयं को इससे परिचित कर लेना उचित है पारंपरिक सूत्र, पारस्परिक बहिष्कार और संदेश प्रेषण Rust में। के उदाहरणों के साथ खेलें std::thread, std::sync::Mutex, std::sync::Arc और चैनल std::sync::mpsc इससे आपको यह समझने में मदद मिलती है कि कंपाइलर आपको किस प्रकार मार्गदर्शन करता है और किन त्रुटियों से बचाता है।

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

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

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

प्रकार, स्वामित्व, उधार, क्रेट, उपकरण और समवर्ती आदिम का यह संपूर्ण पारिस्थितिकी तंत्र एक ऐसी भाषा प्रदान करता है जिसमें लिखा जा सकता है तेज़, मज़बूत और रखरखाव योग्य सॉफ़्टवेयरइससे कई तरह की त्रुटियाँ कम हो जाती हैं जो ऐतिहासिक रूप से सिस्टम प्रोग्रामिंग को प्रभावित करती रही हैं। जैसे-जैसे आप छोटे प्रोजेक्ट्स, रस्टलिंग्स जैसे अभ्यासों और आधिकारिक दस्तावेज़ीकरण के साथ अभ्यास करेंगे, ये अवधारणाएँ सख्त नियमों जैसी लगने वाली चीज़ों से हटकर एक सहयोगी बन जाएँगी जो समस्या के उत्पादन तक पहुँचने से पहले ही आपको चेतावनी दे देंगी।