जावा अनुप्रयोगों को लॉन्च करने और विकसित करने के लिए उपकरण, संकलन, जेवीएम पर निष्पादन

यह कोई रहस्य नहीं है कि इस समय जावा दुनिया की सबसे लोकप्रिय प्रोग्रामिंग भाषाओं में से एक है। जावा के लिए आधिकारिक रिलीज की तारीख 23 मई, 1995 है।

यह लेख मूल बातें के लिए समर्पित है: यह भाषा की बुनियादी विशेषताओं को रेखांकित करता है, जो शुरुआती "जाविस्ट्स" के लिए काम में आएगा, और अनुभवी जावा डेवलपर्स अपने ज्ञान को ताज़ा करने में सक्षम होंगे।

* यह लेख यूजीन फ्रीमैन की एक रिपोर्ट के आधार पर तैयार किया गया था - IntexSoft के जावा डेवलपर।
लेख में बाहरी सामग्रियों के लिंक शामिल हैं ।

1. जेडीके, जेआरई, जेवीएम

जावा डेवलपमेंट किट एक जावा एप्लीकेशन डेवलपमेंट किट है। इसमें जावा डेवलपमेंट टूल्स और जावा रनटाइम एनवायरनमेंट ( JRE ) शामिल हैं।

जावा डेवलपमेंट टूल्स में लगभग 40 अलग-अलग टूल शामिल हैं: javac (कंपाइलर), java (एप्लिकेशन लॉन्चर), javap (java class file disassembler), jdb (जावा डीबगर), आदि।

JRE रनटाइम एक संकलित जावा प्रोग्राम को चलाने के लिए आवश्यक सब कुछ का एक पैकेज है। जेवीएम वर्चुअल मशीन और जावा क्लास लाइब्रेरी शामिल है ।

JVM एक प्रोग्राम है जिसे bytecode को निष्पादित करने के लिए डिज़ाइन किया गया है। जेवीएम का पहला लाभ "एक बार लिखो, कहीं भी चलाओ " का सिद्धांत है। इसका मतलब है कि जावा में लिखा गया एक एप्लिकेशन सभी प्लेटफार्मों पर समान काम करेगा। यह खुद JVM और Java का एक बड़ा फायदा है।

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

कई जेवीएम कार्यान्वयन हैं, दोनों वाणिज्यिक और खुले स्रोत। नए जेवीएम बनाने के लक्ष्यों में से एक विशिष्ट मंच के लिए प्रदर्शन को बढ़ाना है। प्रत्येक JVM को प्लेटफ़ॉर्म के लिए अलग से लिखा गया है, जबकि इसे लिखना संभव है ताकि यह एक विशिष्ट प्लेटफ़ॉर्म पर तेज़ी से काम करे। सबसे आम JVM कार्यान्वयन OpenJDK JVM हॉटस्पॉट है। IBM J9 , एक्सेलसियर JET के कार्यान्वयन भी हैं।

2. जेवीएम कोड निष्पादन

जावा एसई विनिर्देश के अनुसार, जेवीएम में कोड चलाने के लिए, आपको 3 चरण पूरे करने होंगे:

• Bytecode लोड हो रहा है और क्लास क्लास को इंस्टेंट करना है
  मोटे तौर पर, जेवीएम पर पाने के लिए, कक्षा को लोड किया जाना चाहिए। इसके लिए अलग लोडर कक्षाएं हैं, हम थोड़ी देर बाद उनके पास लौट आएंगे।
• जोड़ने या जोड़नेवाला
  कक्षा को लोड करने के बाद, लिंकिंग प्रक्रिया शुरू होती है, जिस पर बायटेकोड को पार्स और चेक किया जाता है। लिंकिंग प्रक्रिया, बदले में, 3 चरणों में होती है:
  
  - बाइटकोड का सत्यापन या सत्यापन: निर्देशों की शुद्धता, कोड के इस खंड पर स्टैक ओवरफ्लो की संभावना, चर प्रकार की संगतता की जांच की जाती है; प्रत्येक वर्ग के लिए एक बार चेक होता है;
  - तैयारी या तैयारी: इस स्तर पर, विनिर्देश के अनुसार, मेमोरी स्थिर क्षेत्रों के लिए आवंटित की जाती है और उनका आरंभ होता है;
  - रिज़ॉल्यूशन या रिज़ॉल्यूशन: प्रतीकात्मक लिंक का रिज़ॉल्यूशन (जब बायटेकोड में हम एक्सटेंशन .class के साथ फाइल खोलते हैं, तो हम प्रतीकात्मक लिंक के बजाय संख्यात्मक मान देखते हैं)।
• परिणामी क्लास ऑब्जेक्ट को प्रारंभ करना
  अंतिम चरण में, हमने जो वर्ग बनाया है, उसे आरंभीकृत किया गया है, और जेवीएम इसे निष्पादित करना शुरू कर सकता है।

3. क्लास लोडर और उनके पदानुक्रम

क्लास लोडर पर वापस जाएं, ये विशेष वर्ग हैं जो जेवीएम का हिस्सा हैं। वे कक्षाओं को स्मृति में लोड करते हैं और उन्हें निष्पादन के लिए उपलब्ध कराते हैं। लोडर सभी वर्गों के साथ काम करते हैं: हमारा और जो सीधे जावा के लिए आवश्यक हैं, दोनों।

स्थिति की कल्पना करें: हमने अपना आवेदन लिखा था, और मानक कक्षाओं के अलावा, हमारी कक्षाएं हैं, और उनमें से बहुत सारे हैं। जेवीएम इसके साथ कैसे काम करेगा? जावा के कार्यान्वयन ने क्लास लोडिंग को दूसरे शब्दों में आलसी लोडिंग कह दिया। इसका मतलब यह है कि कक्षाओं को लोड करने का कार्य तब तक नहीं किया जाएगा जब तक कि आवेदन में कक्षा में कोई कॉल न हो।

कक्षा लोडर पदानुक्रम

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

अगला बूटलोडर एक्सटेंशन क्लास लोडर है । यह jre / lib / ext फ़ोल्डर से एक्सटेंशन क्लासेस को लोड करता है। मान लीजिए कि आप चाहते हैं कि जावा मशीन शुरू होने पर हर बार एक क्लास लोड हो। ऐसा करने के लिए, आप स्रोत श्रेणी फ़ाइल को इस फ़ोल्डर में कॉपी कर सकते हैं, और यह स्वचालित रूप से लोड हो जाएगा।

एक अन्य बूटलोडर सिस्टम क्लास लोडर है। यह हमारे द्वारा निर्दिष्ट क्लासपाथ से कक्षाओं को लोड करता है जब आवेदन शुरू हुआ था।

लोडिंग कक्षाओं की प्रक्रिया एक पदानुक्रम में होती है:

• सबसे पहले, हम सिस्टम क्लास लोडर कैश में खोज का अनुरोध करते हैं (सिस्टम लोडर कैश में ऐसी कक्षाएं होती हैं जिन्हें पहले से लोड किया गया है);
• यदि सिस्टम लोडर के कैश में वर्ग नहीं मिला, तो हम कैश एक्सटेंशन क्लास लोडर को देखते हैं;
• यदि क्लास को विस्तार लोडर कैश में नहीं मिला है, तो बूटस्ट्रैप लोडर से वर्ग का अनुरोध किया जाता है।

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

4. क्लास फ़ाइल संरचना और बूट प्रक्रिया

हम सीधे क्लास फाइलों की संरचना में आगे बढ़ते हैं।

जावा में लिखा गया एक वर्ग विस्तार के साथ एक फ़ाइल में संकलित किया गया है .class अगर हमारी जावा फ़ाइल में कई कक्षाएं हैं, तो इन कक्षाओं के एक्सटेंशन .class - bytecode फ़ाइलों के साथ एक जावा फ़ाइल को कई फाइलों में संकलित किया जा सकता है।

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

इस प्रकार, जब लोडिंग कक्षाएं:

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

5. JVM पर बायोटेक निष्पादन

सबसे पहले, बायटेकोड को निष्पादित करने के लिए, जेवीएम इसकी व्याख्या कर सकता है । व्याख्या एक धीमी प्रक्रिया है। व्याख्या की प्रक्रिया में, इंटरप्रिटर क्लास फाइल के माध्यम से लाइन से "रन" करता है और इसे जेवीएम द्वारा समझे जाने वाले कमांड में अनुवाद करता है।

इसके अलावा, JVM इसे प्रसारित कर सकता है , अर्थात मशीन कोड में संकलित करें जिसे सीधे सीपीयू पर निष्पादित किया जाएगा।

अक्सर निष्पादित होने वाले कमांड की व्याख्या नहीं की जाएगी, लेकिन तुरंत प्रसारित किया जाएगा।

6. संकलन

एक कंपाइलर एक प्रोग्राम है जो उच्च स्तरीय प्रोग्रामिंग भाषा में लिखे गए प्रोग्राम के स्रोत भागों को एक मशीन भाषा प्रोग्राम में परिवर्तित करता है जो कंप्यूटर के लिए "समझने योग्य" है।

संकलक में विभाजित हैं:

• अनुकूलन नहीं
• सरल अनुकूलन (हॉटस्पॉट क्लाइंट): जल्दी से काम करें, लेकिन गैर-इष्टतम कोड उत्पन्न करें
• जटिल अनुकूलन (हॉटस्पॉट सर्वर): बायटेकोड उत्पन्न करने से पहले जटिल अनुकूलन परिवर्तन करते हैं

संकलन समय द्वारा कंपाइलरों को भी वर्गीकृत किया जा सकता है:

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

7. जावा में मेमोरी का संगठन

एक स्टैक जावा में एक मेमोरी एरिया होता है जो LIFO स्कीम के अनुसार काम करता है - " लास्ट-इन Fisrt आउट " या " लास्ट इन, फर्स्ट आउट "।



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

जब किसी भी विधि को जावा में कहा जाता है, तो स्टैक पर एक फ्रेम या मेमोरी क्षेत्र बनाया जाता है, और विधि को इसके शीर्ष पर रखा जाता है। जब कोई विधि निष्पादन को पूरा करती है, तो इसे मेमोरी से हटा दिया जाता है, जिससे निम्नलिखित विधियों के लिए मेमोरी खाली हो जाती है। यदि स्टैक मेमोरी पूर्ण है, तो जावा एक java.lang.StackOverFlowError अपवाद फेंक देगा। उदाहरण के लिए, यह तब हो सकता है जब हमारे पास एक पुनरावर्ती फ़ंक्शन होता है जो खुद को कॉल करेगा और स्टैक पर पर्याप्त मेमोरी नहीं होगी।

स्टैक की मुख्य विशेषताएं:

• स्टैक को आबादी और मुक्त किया जाता है क्योंकि नए तरीकों को बुलाया जाता है और पूरा किया जाता है।
• इस मेमोरी क्षेत्र तक पहुंच ढेर से तेज है।
• स्टैक का आकार ऑपरेटिंग सिस्टम द्वारा निर्धारित किया जाता है।
• यह धागा सुरक्षित है, क्योंकि प्रत्येक स्टैक का अपना अलग स्टैक होता है।

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

ढेर को कई छोटे भागों में विभाजित किया जाता है जिन्हें पीढ़ियों कहा जाता है:

• युवा पीढ़ी - वह क्षेत्र जहाँ हाल ही में निर्मित वस्तुएँ स्थित हैं
• पुरानी (अवधि) पीढ़ी - वह क्षेत्र जहाँ "लंबे समय तक रहने वाली" वस्तुएं संग्रहीत होती हैं
• जावा 8 से पहले, एक और क्षेत्र था - स्थायी पीढ़ी - जिसमें कक्षाओं, विधियों और स्थैतिक चर के बारे में मेटा-जानकारी होती है। जावा 8 के आगमन के बाद, इस जानकारी को अलग से, ढेर के बाहर, अर्थात् मेटा स्पेस में संग्रहीत करने का निर्णय लिया गया

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

मेटा स्पेस का एक डायनामिक साइज़ है, और रनटाइम में यह JVM मेमोरी साइज़ तक विस्तृत हो सकता है।

मुख्य ढेर विशेषताएं:

• जब यह मेमोरी क्षेत्र भर जाता है, तो जावा java.lang.OutOfMemoryError फेंक देता है
• ढेर का उपयोग स्टैक एक्सेस की तुलना में धीमा है
• कचरा संग्रहकर्ता अप्रयुक्त वस्तुओं को इकट्ठा करने का काम करता है
• ढेर के विपरीत, ढेर सुरक्षित नहीं है, क्योंकि कोई भी धागा इसे एक्सेस कर सकता है

उपरोक्त जानकारी के आधार पर, एक साधारण उदाहरण का उपयोग करके स्मृति प्रबंधन कैसे किया जाता है, इस पर विचार करें:

public class App { public static void main(String[] args) { int id = 23; String pName = "Jon"; Person p = null; p = new Person(id, pName); } } class Person { int pid; String name; // constructors, getters/setters } 

हमारे पास एक ऐप वर्ग है जिसमें एकमात्र मुख्य विधि निम्नलिखित है:

- मान 23 के साथ टाइप इंट का आदिम आईडी चर
- मान जॉन के साथ स्ट्रिंग स्ट्रिंग का नाम संदर्भ चर
- प्रकार व्यक्ति का संदर्भ चर p



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

पिछले (मुख्य) कॉल के ऊपर, स्टैक पर मुख्य () विधि से व्यक्ति (स्ट्रिंग) मापदंडों के साथ कंस्ट्रक्टर को कॉल करने के लिए, स्टोर पर स्टैक पर एक अलग फ्रेम बनाया जाता है:

- यह - वर्तमान वस्तु से लिंक है
- आदिम आईडी मूल्य
- संदर्भ चर व्यक्तिनाम , जो स्ट्रिंग पूल में एक स्ट्रिंग को इंगित करता है।

जब हमने कंस्ट्रक्टर कहा जाता है, सेटपर्सननाम () कहा जाता है, जिसके बाद स्टैक पर फिर से एक नया फ्रेम बनाया जाता है, जहां एक ही डेटा संग्रहीत होता है: ऑब्जेक्ट संदर्भ, लाइन संदर्भ, चर मान।

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

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

8. कचरा इकट्ठा करने वाला

कचरा संग्रहकर्ता ढेर पर काम कर रहा है - जावा वर्चुअल मशीन पर चलने वाला एक प्रोग्राम जो उन वस्तुओं से छुटकारा पाता है जिन्हें एक्सेस नहीं किया जा सकता है।

विभिन्न JVM में अलग-अलग कचरा संग्रह एल्गोरिदम हो सकते हैं, अलग-अलग कचरा संग्रहकर्ता भी हैं।

हम सबसे सरल कलेक्टर सीरियल जीसी के बारे में बात करेंगे। हम System.gc () का उपयोग करके कचरा संग्रहण का अनुरोध करते हैं।



जैसा कि ऊपर उल्लेख किया गया है, ढेर 2 क्षेत्रों में विभाजित है: नई पीढ़ी और पुरानी पीढ़ी।

नई पीढ़ी (युवा पीढ़ी) में 3 क्षेत्र शामिल हैं: ईडन , सर्वाइवर 0 और सर्वाइवर 1 ।

पुरानी पीढ़ी में टेन्योर क्षेत्र शामिल है।

जब हम जावा में कोई ऑब्जेक्ट बनाते हैं तो क्या होता है?

सबसे पहले, ऑब्जेक्ट ईडन में गिर जाता है। यदि हमने पहले ही कई वस्तुओं का निर्माण कर लिया है और ईडन में अधिक जगह नहीं है, तो कचरा संग्रहकर्ता आग लगाता है और स्मृति को मुक्त करता है। यह तथाकथित छोटा कचरा संग्रह है - पहले पास पर, यह ईडन क्षेत्र को साफ करता है और उत्तरजीवी 0 क्षेत्र में "जीवित" वस्तुओं को डालता है। इस प्रकार, ईडन क्षेत्र पूरी तरह से मुक्त हो गया है।

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

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

जब टेनरेड में नई वस्तुओं के लिए पर्याप्त जगह नहीं है, तो एक पूरा कचरा संग्रह है - मार्क-स्वीप-कॉम्पैक्ट ।



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

निष्कर्ष

इस लेख में, हमने जावा भाषा के मूल उपकरणों की जांच की: जेवीएम, जेआरई, जेडडीके, जेवीएम कोड निष्पादन, संकलन, मेमोरी संगठन के सिद्धांत और चरणों, साथ ही साथ कचरा कलेक्टर के सिद्धांत।