Java Academy · पाठ

Structured Concurrency मॉडल

संबंधित tasks को एक इकाई मानें

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

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

संरचित समवर्तीता क्या है

संरचित समवर्तीता (JEP 453, पूर्वावलोकन) संबंधित समवर्ती कार्यों के समूह को कार्य की एक इकाई मानती है।

यदि मूल कार्य उप-कार्यों में विभाजित होता है, तो मूल कार्य के आगे बढ़ने से पहले उन सभी उप-कार्यों का पूरा होना आवश्यक है, ठीक वैसे ही जैसे साधारण कोड में ब्लॉक-दायरा होता है।

यह किस समस्या का समाधान करती है

साधारण एक्जीक्यूटर के साथ शुरू किया गया कार्य अपने बनाने वाले कार्य से अधिक समय तक चल सकता है, छूट सकता है या भुला दिया जा सकता है। एक शाखा की त्रुटियाँ अनदेखी रह सकती हैं, जबकि दूसरी शाखाएँ चलती रहती हैं।

इससे थ्रेड का रिसाव, अनाथ कार्य और विफलताओं को संभालने में भ्रम पैदा होता है।

वृक्ष के रूप में कार्य

संरचित समवर्तीता जनक-बालक संबंध लागू करती है। उप-कार्य उन्हें शुरू करने वाले कार्य से बने मूल वाले वृक्ष का रूप लेते हैं।

कोई उप-कार्य अपने मूल दायरे से अधिक समय तक नहीं चल सकता
मूल कार्य सभी बाल कार्यों के पूरा होने तक प्रतीक्षा करता है
रद्दीकरण वृक्ष में नीचे की ओर प्रवाहित होता है

क्रमिक कोड का प्रतिबिंब

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

इससे जीवनकाल स्पष्ट हो जाते हैं और त्रुटियों को समझना आसान होता है।

पुराना असंरचित तरीका

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

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            Future<String> user = exec.submit(() -> "Ada");
            Future<Integer> order = exec.submit(() -> 7);
            System.out.println(user.get() + " has " + order.get() + " orders");
        }
    }
}

समन्वय क्यों महत्वपूर्ण है

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

संरचित समवर्तीता इस समन्वय को स्वचालित करती है।

पूर्वावलोकन स्थिति

संरचित समवर्तीता java.util.concurrent पैकेज में पूर्वावलोकन एपीआई के रूप में उपलब्ध है। इसका उपयोग करने के लिए --enable-preview के साथ संकलित और चलाना होगा।

इसकी केंद्रीय क्लास StructuredTaskScope है, जिसके बारे में अगले पाठ में बताया गया है।

जीवनकाल की गारंटी

संरचित scope के भीतर:

scope से बाहर निकलने से पहले सभी उपकार्य पूरे होते हैं, विफल होते हैं या रद्द किए जाते हैं
कोई भी उपकार्य पृष्ठभूमि में नहीं छूटता
थ्रेड डंप में कॉल स्टैक वास्तविक कार्य-श्रेणी को दर्शाता है

निगरानी का लाभ

क्योंकि उपकार्यों का वृक्ष स्पष्ट होता है, JDK के उपकरण उसे दिखा सकते हैं। थ्रेड डंप उपकार्यों को उनके मूल scope के नीचे समूहित करता है, जिससे बिखरे हुए पूल थ्रेड की तुलना में समस्या का निदान बहुत स्पष्ट हो जाता है।

वर्चुअल थ्रेड के साथ अच्छी संगति

संरचित scope में प्रत्येक उपकार्य डिफ़ॉल्ट रूप से अपने वर्चुअल थ्रेड पर चलता है। वर्चुअल थ्रेड की कम लागत ही कई उपकार्यों में कार्य बाँटना व्यावहारिक बनाती है।

इन दोनों सुविधाओं को साथ मिलकर काम करने के लिए बनाया गया था।

मानसिक मॉडल

संरचित scope को समवर्तीता के लिए संसाधन-प्रबंधन वाले ब्लॉक जैसा समझें: आप इसे खोलते हैं, कार्य को fork करते हैं, join करते हैं और फिर बंद करते हैं। बंद करने वाला ब्रेस इस बात की गारंटी है कि कुछ भी चलता हुआ शेष नहीं है।

त्वरित जाँच

मुख्य सिद्धांत की अपनी समझ जाँचें।

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

पुनरावृत्ति

आपने संरचित समवर्तीता का मॉडल सीखा:

संबंधित कार्य scope के जीवनकाल से बंधा एक वृक्ष बनाते हैं
समवर्ती कोड क्रमिक कोड जैसा पढ़ा जाता है
यह एक पूर्वावलोकन एपीआई है, जिसके लिए --enable-preview आवश्यक है
यह वर्चुअल थ्रेड के साथ स्वाभाविक रूप से काम करता है

अगला विषय: स्वयं StructuredTaskScope एपीआई।

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

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

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

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

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

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

क्या “Structured Concurrency मॉडल” पाठ निःशुल्क है?

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

“Structured Concurrency मॉडल” में मैं क्या सीखूँगा?

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

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

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

“Structured Concurrency मॉडल” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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