रस्ट ट्यूटोरियल: मेमरी सेफ्टी आणि कन्करन्सी

रस्ट ही अशा भाषांपैकी एक बनली आहे जी प्रत्येक सिस्टीम डेव्हलपरला ते पुन्हा पुन्हा ऐकावे लागते.हे C आणि C++ इतकेच वेगवान आहे, परंतु मेमरी सेफ्टी आणि चांगल्या प्रकारे अंमलात आणलेल्या समवर्तीतेवर जवळजवळ लक्ष केंद्रित करते. हे केवळ रिक्त मार्केटिंग नाही: त्याची रचना कंपायलरला कंपायलरच्या वेळी त्रुटी शोधण्याभोवती फिरते - अशा त्रुटी ज्या इतर भाषांमध्ये तुम्हाला फक्त तेव्हाच दिसतात जेव्हा सिस्टम आधीच उत्पादनात असते... किंवा जेव्हा ती क्रॅश होते.

जर आपल्याला समजण्यास रस असेल तर कचरा गोळा न करता रस्ट सुरक्षित मेमरी कशी मिळवते आणि डेटा रन होण्याची भीती न बाळगता समांतरता कशी मिळवतेहे ट्यूटोरियल तुमच्यासाठी आहे. आम्ही भाषेच्या मूलभूत गोष्टी आणि तिच्या परिसंस्थेपासून ते मालकी, कर्ज घेणे, कंपाऊंड प्रकार, कार्गो सारखी साधने यासारख्या प्रमुख संकल्पनांपर्यंत सर्वकाही समाविष्ट करू आणि अगदी नवीन असलेल्यांसाठी अधिक सुलभ दृष्टिकोनातून अणु प्रकार आणि लॉकिंगवर एक नजर टाकू, सर्व काही सुरक्षितता आणि कार्यक्षमतेवर लक्ष केंद्रित करून.

रस्ट ट्यूटोरियल: कामगिरी, मेमरी सेफ्टी आणि कॉन्करन्सी

रस्ट ही एक प्रोग्रामिंग भाषा आहे. प्रोग्रामिंग सामान्य उद्देश आणि बहु-प्रतिमा, ज्यासाठी डिझाइन केलेले आहे कमी-स्तरीय प्रणाली प्रोग्रामिंग तसेच उच्च-स्तरीय प्रकल्पांसाठीपासून ऑपरेटिंग सिस्टमगेम इंजिन आणि ब्राउझरपासून ते उच्च-कार्यक्षमता असलेल्या वेब सेवांपर्यंत, ते Mozilla मध्ये सॉफ्टवेअर सुरक्षा सुधारण्याच्या उद्देशाने उद्भवले, विशेषतः ब्राउझर इंजिनसारख्या संवेदनशील घटकांमध्ये.

त्याचे निश्चित वैशिष्ट्य म्हणजे संकलन वेळी मेमरी सुरक्षिततेची हमी देते कचरा गोळा करणारा वापरल्याशिवाय. त्याऐवजी, रस्ट एक मालकी प्रणाली आणि कर्ज तपासक वापरते जे प्रत्येक मूल्याचे आयुष्य आणि त्याच्या संदर्भांचा मागोवा घेते. हे स्वयंचलित संदर्भ मोजणी किंवा कचरा गोळा करण्याची आवश्यकता न ठेवता लटकणारे पॉइंटर्स, बफर ओव्हरफ्लो किंवा मेमरी लीक सारख्या क्लासिक समस्या टाळते.

शिवाय, रस्ट हे सोपे करण्यासाठी डिझाइन केलेले आहे सुरक्षित समांतरतात्याचा प्रकार आणि मालकी मॉडेल थ्रेड्समधील डेटा शर्यतींना प्रतिबंधित करते, किमान सुरक्षित रस्ट कोडमध्ये राहून. याचा अर्थ असा की एक ओळ कार्यान्वित होण्यापूर्वी, कंपाइल वेळी अनेक धोकादायक परिस्थिती आढळतात.

या सर्व कारणांमुळे, मोठ्या कंपन्या आवडतात ड्रॉपबॉक्स, मायक्रोसॉफ्ट, अमेझॉन किंवा Google त्यांनी त्यांच्या पायाभूत सुविधांच्या महत्त्वाच्या भागांमध्ये रस्टचा अवलंब केला आहे. आणि हे योगायोग नाही की ते गेल्या काही वर्षांपासून स्टॅक ओव्हरफ्लो पोलमध्ये डेव्हलपर्सच्या "सर्वात आवडत्या" भाषांपैकी एक म्हणून अव्वल स्थानावर आहे: ते C++-शैलीतील कामगिरीला आधुनिक टूलसेट (कार्गो, crates.io) आणि एक अतिशय सक्रिय समुदाय, तथाकथित रस्टेशियन्ससह एकत्र करते.

मूलभूत संकल्पना: प्रोग्रामिंग भाषा, प्रकार आणि मेमरी

मेमरी सिक्युरिटी आणि कॉन्करन्सीच्या तपशीलांमध्ये खोलवर जाण्यापूर्वी, संपूर्ण जगात आढळणाऱ्या काही सामान्य संकल्पना स्पष्ट करणे योग्य आहे. अल टायम्पो रस्टसोबत काम करताना, विशेषतः जर तुम्ही इतर भाषांमधून आला असाल किंवा नुकतेच प्रोग्रामिंग सुरू करत असाल तर.

प्रोग्रामिंग भाषा म्हणजे, शेवटी, नियम आणि रचनांचा संच जो तुम्हाला अल्गोरिदमचे वर्णन करण्यास अनुमती देतो आणि त्यांना एक्झिक्युटेबल प्रोग्राममध्ये रूपांतरित करा. रस्ट त्याच्या कंपायलरचा वापर करून मूळ मशीन कोडमध्ये संकलित करतो. rustcम्हणून, तुम्हाला मिळणारा परफॉर्मन्स सहसा C आणि C++ च्या बरोबरीचा असतो.

मेमरी मॅनेजमेंट ही अशी प्रक्रिया आहे ज्याद्वारे प्रोग्राम चालू असताना मेमरीचे ब्लॉक राखून ठेवते आणि सोडतेया क्षेत्रातील चुका अनेकदा घातक असतात: मेमरी लीक (न वापरलेली मेमरी सोडण्यात अयशस्वी होणे), मर्यादेबाहेर लिहिण्यामुळे डेटा करप्शन किंवा मेमरी मोकळी झाल्यानंतर वापरणे. रस्ट हे एका अतिशय मजबूत प्रकारच्या प्रणाली आणि मालकी, कर्ज आणि आयुष्यभरासाठी औपचारिक नियमांसह सोडवते.

रस्टमध्ये असे शब्द देखील आहेत जसे की स्मार्ट प्रकार आणि पॉइंटर्सप्रकार हे वर्णन करतो की व्हेरिएबल कोणत्या प्रकारचा डेटा साठवतो (पूर्णांक, फ्लोट्स, स्ट्रिंग्ज, स्ट्रक्चर्स इ.) आणि तो कसा हाताळला जाऊ शकतो. स्मार्ट पॉइंटर्स (उदाहरणार्थ, Box, Rc y Arc) अशा रचना आहेत ज्या मेमरी अॅड्रेसेस एन्कॅप्स्युलेट करतात आणि संसाधने सुरक्षितपणे व्यवस्थापित करण्यासाठी अतिरिक्त लॉजिक जोडतात, जसे की सामायिक संदर्भ मोजणे किंवा व्हॅल्यूज हीपमध्ये हलवणे.

स्पर्धेच्या क्षेत्रात, संकल्पना जसे की शर्यतीच्या परिस्थिती, म्यूटेक्स आणि चॅनेल ते अपरिहार्य बनतात: जेव्हा अनेक थ्रेड्स योग्य समन्वयाशिवाय एकाच वेळी सामायिक संसाधनात प्रवेश करतात आणि सुधारित करतात तेव्हा रेस कंडिशन उद्भवते; म्युटेक्स (म्युच्युअल एक्सक्लुजन) हे सुनिश्चित करते की एका वेळी फक्त एकच थ्रेड गंभीर विभागात प्रवेश करतो; आणि चॅनेल थेट मेमरी शेअर न करता थ्रेड्समध्ये संदेश पाठविण्याची परवानगी देतात.

रस्ट का शिकावे: स्मृती सुरक्षितता आणि निर्भय सहसंधी

रस्टने त्याची प्रसिद्धी मिळवली आहे कारण ते देते आधुनिक प्रोग्रामिंगसाठी तीन अतिशय मौल्यवान आधारस्तंभकामगिरी, सुरक्षितता आणि सध्याची साधने. हे मुद्दे इतके संबंधित का आहेत ते पाहूया.

कामगिरीबद्दल, रस्ट थेट मूळ बायनरीजमध्ये संकलित करते व्हर्च्युअल मशीन किंवा इंटरप्रिटरची आवश्यकता नसताना. शून्य-खर्च अ‍ॅबस्ट्रॅक्शन्स मॉडेलचा उद्देश उच्च-स्तरीय अ‍ॅबस्ट्रॅक्शन्स रनटाइममध्ये ओव्हरहेड वाढवू नयेत याची खात्री करणे आहे. म्हणूनच, ते सिस्टम डेव्हलपमेंटसाठी आदर्श आहे. व्हिडिओ गेम, ब्राउझर घटक किंवा कमी-विलंब असलेल्या मायक्रोसर्व्हिसेस.

मेमरी सुरक्षा त्याच्यावर आधारित आहे मालकी आणि कर्ज प्रणालीकचरा गोळा करणारा कोणीही नाही, परंतु कंपायलरला प्रत्येक संसाधन कोणाचे आहे हे अचूकपणे माहित असते, त्याची कधी आवश्यकता नसते आणि ते केव्हा सोडता येते. हे गळती, लटकणारे पॉइंटर्स आणि पारंपारिकपणे C आणि C++ प्रोग्रामिंग इतके धोकादायक बनवणाऱ्या अनेक त्रुटींना प्रतिबंधित करते.

स्पर्धेच्या क्षेत्रात, रस्ट सामान्यतः ज्याला म्हणतात त्याचा पाठलाग करते "भीतीशिवाय एकरूपता"टाइप सिस्टीम स्वतःच डेटा रूट्सना सुरक्षित कोडमध्ये अस्तित्वात येण्यापासून प्रतिबंधित करते. जर तुम्हाला थ्रेड्समध्ये परिवर्तनीय डेटा शेअर करायचा असेल, तर तुम्हाला योग्य प्राइमिटिव्ह्ज वापरावे लागतील जसे की Mutex, RwLock o Arc, आणि कंपायलर खात्री करेल की अलियासिंग आणि म्युटेबिलिटी नियमांचे पालन केले जाईल.

आधुनिक साधनांसह विकास अनुभव वाढविला जातो जसे की मालवाहूयात एकात्मिक पॅकेज मॅनेजर आणि बिल्ड इन्फ्रास्ट्रक्चर आणि ग्रंथालयांची एक विस्तृत परिसंस्था (क्रेट्स) आहे जी असिंक्रोनस नेटवर्किंग (टोकियो) पासून वेब फ्रेमवर्क (अॅक्टिक्स, रॉकेट, अ‍ॅक्सम) पर्यंत सर्वकाही व्यापते. हे सर्व एका खुल्या, विपुल आणि संयमी समुदायाद्वारे समर्थित आहे, विशेषतः नवशिक्यांसाठी.

स्थापना आणि आवश्यक साधने: रस्टअप, रस्टक आणि कार्गो

रस्टमध्ये तुमचे पहिले प्रोग्राम लिहिण्यासाठी आणि चालवण्यासाठी, सुरुवात करण्याचा नेहमीचा मार्ग म्हणजे अधिकृत टूलचेन स्थापित करणे रस्टअप (पहा रस्टचा संपूर्ण परिचय), एक साधा इंस्टॉलर आणि आवृत्ती व्यवस्थापक जो सर्व प्रमुख ऑपरेटिंग सिस्टमवर कार्य करतो.

सह रस्टअप तुम्ही काहीही न बिघडवता रस्टच्या वेगवेगळ्या आवृत्त्या (स्थिर, बीटा, नाईटली) इन्स्टॉल, अपडेट आणि स्विच करू शकता. फक्त अधिकृत रस्ट टूल्स पेजवर जा आणि तुमच्या सिस्टमसाठी पायऱ्या फॉलो करा. एकदा इन्स्टॉल केल्यानंतर, कंपायलर उपलब्ध होईल. rustc, प्रकल्प व्यवस्थापक cargo आणि त्याचे स्वतःचे rustup आपल्या मध्ये टर्मिनल.

कंपाइलर rustc हेच तुमच्या सोर्स कोडचे एक्झिक्युटेबल बायनरीज किंवा लायब्ररीजमध्ये रूपांतर करते. जरी तुम्ही ते थेट वापरु शकता आज्ञा कसे 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 फोल्डर रचना आपोआप तयार होते a सह src/main.rs "हॅलो, वर्ल्ड" आणि फाईलसह आधीच तयार आहे Cargo.toml ज्यामध्ये मेटाडेटा आणि भविष्यातील अवलंबित्वे असतात. तिथून, cargo run बायनरी संकलित करा आणि चालवा.आणि जेव्हा ते बदल शोधते तेव्हाच ते पुन्हा कंपाइल करते.

काम करण्याची ही पद्धत केवळ सोयीस्कर नाही, तर सुरुवातीपासूनच तुम्हाला मानक रस्ट इकोसिस्टम वापरण्याची सवय लावते, जे तुम्ही कॉन्करन्सी, नेटवर्किंग, चाचणी किंवा तुम्हाला आवश्यक असलेल्या कोणत्याही गोष्टीसाठी क्रेट्स जोडण्यास सुरुवात करता तेव्हा खूप उपयुक्त ठरते.

// आम्ही मुख्य फंक्शन घोषित करतो: प्रोग्राम एंट्री पॉइंट fn main() { // आम्ही कन्सोलवर मजकूर प्रिंट करण्यासाठी println! मॅक्रो वापरतो println!("हॅलो, वर्ल्ड!"); }

चल, परिवर्तनशीलता आणि मूलभूत डेटा प्रकार

रस्टमध्ये, व्हेरिएबल्स कीवर्डसह घोषित केले जातात 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 फक्त वाचण्यासाठी आवश्यक असलेल्या फंक्शन्सचे संदर्भ देऊन.

मालकीच्या आणि उधार घेतलेल्या डेटामधील हे वेगळेपण मेमरी व्यवस्थापनासाठी महत्त्वाचे आहे आणि ते उर्वरित भाषेपर्यंत विस्तारते: संग्रह, रचना आणि एनम्स कोणाचे मालक आहेत आणि कोण फक्त पाहतो या समान कल्पनांचे अनुसरण करतात.

कार्ये, नियंत्रण प्रवाह आणि टिप्पण्या

रस्टमधील फंक्शन्स यासह परिभाषित केल्या आहेत fn आणि प्रोग्रामला पुन्हा वापरता येण्याजोग्या लॉजिकल युनिट्समध्ये व्यवस्थित करण्याची परवानगी द्या. प्रत्येक फंक्शन निर्दिष्ट करते त्याच्या पॅरामीटर्सचा प्रकार आणि त्याचा रिटर्न प्रकार बाणाचे अनुसरण करणे ->जर ते काहीही अर्थपूर्ण परत करत नसेल, तर एकात्मक प्रकार गृहीत धरला जातो. ().

एक महत्त्वाचा तपशील म्हणजे अर्धविराम नसलेल्या फंक्शनमधील (किंवा कोणत्याही ब्लॉकमध्ये) शेवटची अभिव्यक्ती अंतर्निहित परतावा मूल्य म्हणून घेतली जाते. तुम्ही वापरू शकता return लवकर परतफेडीसाठीपण मुहावरेदार कोडमध्ये, तुम्ही अनेकदा अंतिम अभिव्यक्ती न वापरताच सोडता. ;.

नियंत्रण प्रवाह क्लासिक्ससह हाताळला जातो if/elseलूप loop, while y forरस्ट मध्ये, if ही एक अभिव्यक्ती आहे जी मूल्य परत करते.जेणेकरून तुम्ही ते थेट a मध्ये वापरू शकता letजर शाखा त्याच प्रकारच्या परत आल्या तर. लूप for ते सामान्यतः रेंज किंवा कलेक्शन इटरेटर्सवर पुनरावृत्ती करतात आणि मॅन्युअल इंडेक्सऐवजी शिफारसित पर्याय आहेत.

कोडचे दस्तऐवजीकरण करण्यासाठी आणि नंतर येणाऱ्यांसाठी (एका महिन्यात स्वतःसह) जीवन सोपे करण्यासाठी, तुम्ही वापरू शकता यासह टिप्पण्या लिहा // किंवा ब्लॉक करा /* ... */याव्यतिरिक्त, रस्ट दस्तऐवजीकरण टिप्पण्या देते /// जे तयार केलेले दस्तऐवज बनतात, जरी ते मोठ्या प्रकल्पांमध्ये अधिक बसते.

मालकी, कर्ज देणे आणि आयुष्य: स्मृती सुरक्षेचा पाया

येथे आपण रस्टच्या मेमरी मॉडेलच्या केंद्रस्थानी पोहोचतो: सिस्टम ऑफ मालकी, कर्ज घेणे आणि आयुष्यभरहे नियम सुनिश्चित करतात की संदर्भ नेहमीच वैध असतात आणि कचरा जमा न होता मेमरी सुरक्षितपणे सोडली जाते.

मालकीचे मूलभूत नियम सांगणे सोपे आहे, जरी सुरुवातीला ते आत्मसात करणे कठीण असू शकते: प्रत्येक मूल्याचा एकच मालक असतो.एका वेळी फक्त एकच मालक असू शकतो; आणि जेव्हा मालक त्याची व्याप्ती सोडतो तेव्हा मूल्य नष्ट होते आणि त्याची स्मृती सोडली जाते. हे लागू होते, उदाहरणार्थ, a ला String: ज्या ब्लॉकची घोषणा केली होती ती पूर्ण झाल्यावर, ती आपोआप सुरू होते. drop जे हीप मेमरी मोकळी करते.

जेव्हा तुम्ही दुसऱ्या व्हेरिएबलला योग्य व्हॅल्यू देता किंवा ते फंक्शनला व्हॅल्यूनुसार पास करता तेव्हा प्रॉपर्टी हलवली जाते. याचा अर्थ असा की हलवल्यानंतर मूळ चल वैध राहणे बंद होते.या हालचालीचे अर्थशास्त्र दुहेरी रिलीझ टाळते, कारण कधीही दोन मालक समान संसाधन रिलीझ करण्याचा प्रयत्न करत नाहीत.

प्रोग्रामच्या अनेक भागांना मालकी बदलल्याशिवाय समान मूल्य मिळविण्यासाठी, रस्ट संदर्भ आणि कर्ज घेण्याची सुविधा सादर करतो. जेव्हा तुम्ही कर्ज घेता तेव्हा तुम्ही एक संदर्भ तयार करता. &T (अपरिवर्तनीय) किंवा &mut T (परिवर्तनीय) मालकी हस्तांतरित न करता मूल्यावर. कर्ज पडताळणीकर्त्याच्या नियमांनुसार कर्ज मर्यादित आहे., जे तपासते की संदर्भ ते दर्शविलेल्या डेटापेक्षा जास्त काळ टिकत नाहीत आणि परिवर्तनीय आणि सामायिक प्रवेश धोकादायकपणे मिसळलेले नाहीत.

कर्जाचे नियम खालीलप्रमाणे सारांशित केले जाऊ शकतात: कोणत्याही वेळी, तुम्ही एकतर अनेक अपरिवर्तनीय संदर्भ मूल्यापर्यंत, किंवा एकच बदलता येणारा संदर्भपण दोन्ही एकाच वेळी नाही. यामुळे सामायिक स्मृतीतील वंशविषयक परिस्थिती नष्ट होते: एकतर बरेच वाचक असतात, किंवा एक वेगळा लेखक असतो; एकाच वेळी एकाच डेटावर एकाच वेळी वाचक आणि लेखक कधीही नसतात.

संमिश्र प्रकार: स्ट्रक्चर्स, एनम्स आणि स्मार्ट पॉइंटर्स

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

स्ट्रक्चरचा एक उदाहरण तयार करण्यासाठी, तुम्ही त्याचे सर्व फील्ड भरता आणि तुम्ही त्यात असलेल्या व्हेरिएबलला नंतर त्याची व्हॅल्यूज सुधारण्यासाठी बदलण्यायोग्य म्हणून चिन्हांकित करू शकता. स्ट्रक्चर अपडेट सिंटॅक्स देखील आहे, जो तुम्हाला विद्यमान असलेल्या फील्डमधून काही फील्ड पुन्हा वापरून एक नवीन उदाहरण तयार करण्यास अनुमती देतो. ..otro_struct.

अगोदर निर्देश केलेल्या बाबीसंबंधी बोलताना एनम्स ते आणखी एक आवश्यक आधारस्तंभ आहेत: ते तुम्हाला अशा प्रकाराची व्याख्या करण्याची परवानगी देतात जो अनेक संभाव्य प्रकारांपैकी एक असू शकतो, प्रत्येकाचा स्वतःचा संबंधित डेटा असेल किंवा त्याशिवाय असेल. एक उत्कृष्ट उदाहरण म्हणजे IP पत्त्यांसाठी एक enum, ज्यामध्ये एक प्रकार आहे. V4 जे चार ऑक्टेट आणि दुसरे साठवते V6 जे IPv6 नोटेशनसह स्ट्रिंग साठवते.

रस्टच्या मानक लायब्ररीमध्ये दोन अतिशय महत्त्वाचे एनम्स समाविष्ट आहेत: 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 हे विशेष उल्लेखास पात्र आहे: ते बायनरी निर्माण न करता कोडला एका मध्यवर्ती बिंदूपर्यंत संकलित करते, ज्यामुळे ते संकलनातील त्रुटी शोधण्यात खूप जलद असणेकर्ज तपासक गुणधर्म, संदर्भ आणि जीवनकाळातील समस्या दर्शवित असताना ते जलद पुनरावृत्ती करण्यासाठी परिपूर्ण आहे.

या इकोसिस्टममुळे, तुमच्या प्रोजेक्ट्सची रचना लहान, चांगल्या प्रकारे परिभाषित केलेल्या क्रेट्समध्ये करणे, त्यांच्यामध्ये कोड शेअर करणे आणि समुदायाने तयार केलेल्या सोल्यूशन्सचा पुनर्वापर करणे सामान्य आहे. उदाहरणार्थ, प्रगत समवर्तीतेसाठी, तुमच्याकडे असिंक्रोनस प्रोग्रामिंगसाठी टोकियो किंवा उच्च-कार्यक्षमता समवर्ती डेटा स्ट्रक्चर्ससाठी क्रॉसबीम सारखे क्रेट्स असतील.

रस्टमधील समांतरता: धागे, म्युटेक्स, चॅनेल आणि अणुशास्त्र

रस्टमध्ये इतकी उत्सुकता निर्माण होण्याचे एक कारण म्हणजे कॉन्करन्सी: ते तुम्हाला मल्टी-कोर प्रोसेसरचा फायदा घेण्यास अनुमती देते. थ्रेड्स आणि शेअर्ड मेमरीच्या सामान्य चुकांमध्ये न पडताजर तुम्ही पहिल्यांदाच या विषयांवर चर्चा करत असाल, तर अनेक संकल्पनांमध्ये फरक करणे उपयुक्त ठरेल.

समवर्तीमध्ये एकाच वेळी किंवा अनेक कोरवर ओव्हरलॅप होणारी अनेक कार्ये अंमलात आणणे समाविष्ट असते. रस्टमध्ये, तुम्ही समांतर काम करण्यासाठी सिस्टम थ्रेड्स तयार करू शकता आणि भाषा तुम्हाला त्यांच्यामध्ये डेटा शेअरिंग सुरक्षित आहे याची खात्री करण्यासाठी मार्गदर्शन करते. एक क्लासिक त्रुटी म्हणजे रेस कंडिशन, जिथे दोन थ्रेड्स एकाच वेळी डेटा अॅक्सेस करतात आणि सुधारित करतात आणि परिणाम अंमलबजावणी क्रमावर अवलंबून असतो - डीबग करणे खूप कठीण असे काहीतरी.

सामायिक डेटाच्या प्रवेशाचे समन्वय साधण्यासाठी, रस्ट आदिम गोष्टींवर अवलंबून असतो जसे की म्युटेक्सजे परस्पर बहिष्काराची हमी देते: एका वेळी फक्त एकच धागा गंभीर विभागात प्रवेश करू शकतो. सह संयोजनात Arc<T> थ्रेड्समध्ये मालकी सामायिक करण्यासाठी, मालकी आणि कर्ज घेण्याच्या नियमांचे पालन करणारे सामायिक डेटा स्ट्रक्चर्स तयार करणे शक्य आहे.

रस्टमध्ये मोठ्या प्रमाणात प्रोत्साहित केलेल्या इंटर-थ्रेडेड कम्युनिकेशनचा आणखी एक सामान्य प्रकार म्हणजे संदेश पाठवणे चॅनेलचॅनेलला पाठवण्याचा आणि प्राप्त करण्याचा अंत असतो; थ्रेड्स त्यातून संदेश (मूल्ये) पाठवतात, ज्यामुळे परिवर्तनीय सामायिक मेमरीचा वापर कमी होतो आणि सिस्टमच्या स्थितीबद्दल तर्क करणे सोपे होते.

जेव्हा तुम्ही निम्न-स्तरीय समांतरतेमध्ये खोलवर जाता तेव्हा खालील गोष्टी दिसतात: अणु प्रकारथ्रेडच्या दृष्टिकोनातून अविभाज्य असलेल्या ऑपरेशन्सद्वारे अणु व्हेरिअबल्समध्ये प्रवेश केला जातो. हे शेअर्ड काउंटर, स्टेट फ्लॅग, लॉक-फ्री क्यू आणि बरेच काही अंमलात आणण्यास अनुमती देते. अणु व्हेरिअबल्समध्ये प्रभुत्व मिळविण्यासाठी मेमरी मॉडेल्स आणि अॅक्सेस कमांड समजून घेणे आवश्यक आहे, म्हणून बरेच डेव्हलपर्स या तपशीलांमध्ये जाण्यापूर्वी म्यूटेक्स आणि चॅनेलसह सुरुवात करण्यास प्राधान्य देतात.

समवर्ती आणि अणु शिकण्यासाठी पहिले टप्पे आणि संसाधने

जर तुम्ही कोणताही पूर्व अनुभव नसताना मैदानात उतरत असाल, तर सर्वात शहाणपणाचा मार्ग म्हणजे सामान्य संकल्पनांचा भक्कम पाया तयार करा रस्टच्या अणु प्रकारांसारख्या प्रगत साधनांचा वापर करण्यापूर्वी. "प्रोग्रामिंग रस्ट" सारखी पुस्तके हळूहळू परिचय देतात, परंतु अणु प्रकार आणि कुलूपांवर केंद्रित कामे सुरुवातीला दाट वाटणे सामान्य आहे.

अधिक सोयीसाठी, प्रथम स्वतःला परिचित करून घेणे उचित आहे पारंपारिक धागे, परस्पर बहिष्कार आणि संदेश पाठविणे रस्ट मध्ये. उदाहरणांसह खेळा std::thread, std::sync::Mutex, std::sync::Arc आणि च्या चॅनेल std::sync::mpsc हे तुम्हाला कंपायलर कसे मार्गदर्शन करते आणि कोणत्या चुका टाळते हे समजून घेण्यास मदत करते.

समांतरपणे, सर्वसाधारणपणे समवर्तीवरील प्रास्ताविक संसाधनांचा आढावा घेण्याची शिफारस केली जाते, जरी ते रस्टवर केंद्रित नसले तरीही: वंशाच्या परिस्थिती काय आहेत, ब्लॉकिंग म्हणजे काय, सामायिक मेमरी म्हणजे संदेश पासिंग विरुद्ध काय सूचित करते आणि लॉक कसे वापरले जातात हे समजून घेणे. एकदा त्या संकल्पना तुमच्यासाठी नैसर्गिक झाल्या की, अणुभौतिकशास्त्र "काळी जादू" राहात नाही. आणि ते फक्त दुसरे साधन बनतात, फक्त एक अतिशय नाजूक साधन.

जेव्हा तुम्ही रस्टमधील अणुशास्त्र आणि कुलूपांबद्दल अधिक प्रगत मजकुरांकडे परत जाल, तेव्हा प्रत्येक रचना कोणती समस्या सोडवण्याचा प्रयत्न करत आहे हे तुम्हाला आधीच समजले असेल तर तर्काचे अनुसरण करणे खूप सोपे होईल: साध्या थ्रेड-सेफ काउंटरपासून ते वाद कमी करणाऱ्या लॉक-फ्री स्ट्रक्चर्सपर्यंत.

शेवटी, रस्ट उच्च-स्तरीय आदिम आणि अत्यंत निम्न-स्तरीय साधने दोन्ही देते आणि मुख्य म्हणजे नेहमीच अ‍ॅटॉमिक कोडचा अवलंब करून तुमच्या समस्येचे निराकरण करणारा सर्वात सुरक्षित स्तराचा अ‍ॅब्स्ट्रॅक्शन निवडणे. unsafe जेव्हा ते खरोखरच मूल्य वाढवते आणि तुम्हाला त्याचे परिणाम पूर्णपणे समजतात तेव्हाच.

प्रकार, मालकी, कर्ज घेणे, क्रेट्स, साधने आणि समवर्ती आदिम अशा या संपूर्ण परिसंस्थेचे संयोजन लिहिण्यासाठी एक भाषा प्रदान करते. जलद, मजबूत आणि देखभाल करण्यायोग्य सॉफ्टवेअरयामुळे सिस्टम प्रोग्रामिंगमध्ये ऐतिहासिकदृष्ट्या त्रास देणाऱ्या अनेक प्रकारच्या त्रुटी कमी होतात. तुम्ही लहान प्रकल्प, रस्टलिंग्ज सारख्या व्यायाम आणि अधिकृत कागदपत्रांसह सराव करता तेव्हा, या संकल्पना कठोर नियमांसारख्या वाटण्यापासून ते उत्पादनापर्यंत पोहोचण्यापूर्वी तुम्हाला चेतावणी देणारे सहयोगी बनतील.