Java Academy · पाठ

MemorySegment और Arena

ऑफ़-हीप memory आवंटित करें

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

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

ऑफ-हीप मेमोरी

FFM नेटिव, ऑफ-हीप मेमोरी को दो केंद्रीय प्रकारों के ज़रिए मॉडल करता है: MemorySegment मेमोरी के एक सन्निहित क्षेत्र को दर्शाता है और Arena उसके जीवनकाल को नियंत्रित करता है।

मिलकर ये पुराने समय के असुरक्षित, हाथ से किए जाने वाले बफ़र प्रबंधन का स्थान लेते हैं।

MemorySegment क्या है

MemorySegment मेमोरी के किसी ब्लॉक पर एक प्रकार-युक्त विंडो है। इसे अपना आकार और जीवनकाल पता होता है, और हर ऐक्सेस की सीमाओं की जाँच होती है।

सेगमेंट ऑफ-हीप (नेटिव) हो सकते हैं या ऑन-हीप ऐरे को रैप कर सकते हैं।

Arena क्या है

Arena सेगमेंट आवंटित करता है और यह निर्धारित करता है कि वे कब मुक्त होंगे। एरीना बंद होने पर उसके सभी सेगमेंट एक निश्चित चरण में अमान्य हो जाते हैं।

Arena.ofConfined(): एकल-थ्रेड, स्पष्ट रूप से बंद करना
Arena.ofShared(): मल्टी-थ्रेड ऐक्सेस
Arena.global(): कभी मुक्त नहीं होता
Arena.ofAuto(): GC द्वारा मुक्त किया जाता है

सेगमेंट आवंटित करना

try-with-resources में सीमित एरीना का उपयोग करना सामान्य तरीका है। बाइट्स आवंटित करें, उनका उपयोग करें, और बंद करने पर सब कुछ मुक्त हो जाएगा।

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment seg = arena.allocate(16);
            System.out.println("Allocated bytes: " + seg.byteSize());
        }
        System.out.println("Arena closed, memory freed");
    }
}

लिखना और पढ़ना

आप प्रकार-युक्त ऐक्सेसर के ज़रिए पढ़ते और लिखते हैं, जो एक ValueLayout और ऑफ़सेट लेते हैं। इससे ऐक्सेस का प्रकार सुरक्षित और सही संरेखित रहता है।

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment seg = arena.allocate(ValueLayout.JAVA_INT);
            seg.set(ValueLayout.JAVA_INT, 0, 42);
            int value = seg.get(ValueLayout.JAVA_INT, 0);
            System.out.println("Stored and read: " + value);
        }
    }
}

प्रकार-युक्त स्लॉट आवंटित करना

कच्ची बाइट संख्या के बजाय लेआउट के आधार पर आवंटन करें। arena.allocate(JAVA_INT) एक int के लिए पर्याप्त और उचित रूप से संरेखित बाइट आरक्षित करता है।

इससे आकार की गणना हाथ से करने की आवश्यकता नहीं रहती।

मानों के ऐरे

कई एलिमेंट संग्रहीत करने के लिए, सीक्वेंस लेआउट आवंटित करें या संख्या दें। इंडेक्स ऐक्सेस में एलिमेंट के आकार से गणना किया गया ऑफ़सेट उपयोग होता है।

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment ints = arena.allocate(ValueLayout.JAVA_INT, 5);
            for (int i = 0; i < 5; i++) {
                ints.setAtIndex(ValueLayout.JAVA_INT, i, i * 10);
            }
            System.out.println("Element 3: " + ints.getAtIndex(ValueLayout.JAVA_INT, 3));
        }
    }
}

सीमाओं की जाँच

सेगमेंट के बाहर पढ़ने या लिखने पर IndexOutOfBoundsException उत्पन्न होता है। एरीना बंद होने के बाद किसी सेगमेंट को ऐक्सेस करने पर IllegalStateException उत्पन्न होता है।

यही जाँच FFM की मेमोरी को JNI के विपरीत सुरक्षित बनाती है।

सीमाबद्धता

सीमित एरीना अपने सेगमेंट को बनाने वाले थ्रेड से बाँध देता है। किसी दूसरे थ्रेड द्वारा उन्हें ऐक्सेस करने पर WrongThreadException उत्पन्न होता है।

वास्तव में साझा मेमोरी के लिए Arena.ofShared() का उपयोग करें। इसकी थोड़ी लागत के बदले यह मल्टी-थ्रेड ऐक्सेस की अनुमति देता है।

स्ट्रिंग के साथ काम करना

FFM Java स्ट्रिंग और C स्ट्रिंग के बीच रूपांतरण के लिए सहायक विधियाँ देता है। allocateUtf8String (नया विकल्प: allocateFrom) नल-टर्मिनेटेड स्ट्रिंग लिखता है और getUtf8String उसे वापस पढ़ता है।

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment cString = arena.allocateUtf8String("hello");
            System.out.println("Read back: " + cString.getUtf8String(0));
        }
    }
}

एरीना चुनना

दिशा-निर्देश:

कम समय तक रहने वाले, एकल-थ्रेड बफ़र: ofConfined()
थ्रेड्स के बीच साझा: ofShared()
GC द्वारा प्रबंधित जीवनकाल: ofAuto()
पूरी प्रक्रिया में उपयोग होने वाले स्थिरांक: global()

त्वरित जाँच

याद करें कि नेटिव मेमोरी कब मुक्त होगी, यह किस बात से निर्धारित होता है।

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

पुनरावलोकन

आपने ऑफ-हीप मेमोरी प्रबंधन सीखा:

MemorySegment: सीमाओं की जाँच वाला मेमोरी क्षेत्र
Arena: जीवनकाल नियंत्रित करता है (सीमित, साझा, स्वचालित, वैश्विक)
ValueLayout के साथ get/set और getAtIndex के ज़रिए प्रकार-युक्त ऐक्सेस
सीमाओं की जाँच और सीमाबद्धता से सुरक्षा

अगला विषय: डाउनकॉल हैंडल के साथ नेटिव फ़ंक्शन कॉल करना।

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

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

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

पाठ्यक्रम: 104
पाठ: 374

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

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

क्या “MemorySegment और Arena” पाठ निःशुल्क है?

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

“MemorySegment और Arena” में मैं क्या सीखूँगा?

ऑफ़-हीप memory आवंटित करें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Java Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Java Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

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

“MemorySegment और Arena” पाठ पूरा करने में कितना समय लगता है?

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

क्या मैं इस Java Academy पाठ में कोड लिख और चला सकता हूँ?

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

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

← Java Academy पर वापस जाएँ