क्या आप जावा थ्रेड्स चाहते हैं जो स्मृति को नहीं खाते हैं जैसे कि वे स्वयं में नहीं हैं और धीमा नहीं है? अच्छा क्रेडिट, और यह मुद्दा इस सवाल का जवाब देता है।

हम पिज्जा बक्से पर प्रोजेक्ट लूम के काम की व्याख्या करते हैं! चलो!

यह सब हटा दिया गया है और विशेष रूप से हैबर के लिए लिखा गया है।

संकेत कहते हैं

क्या आप अक्सर इस चित्र को अपनी वेब सेवा पर देखते हैं: पहले तो सब कुछ ठीक था, फिर एक लाख चीनी आपके पास आए, सेवा ने एक लाख सूत्र बना दिए और नरक में डूब गए?

क्या आप ऐसी अच्छी तस्वीर चाहते हैं?

दूसरे शब्दों में, क्या आप जावा थ्रेड्स चाहते हैं जो मेमोरी नहीं खाते हैं, लेकिन स्वयं में नहीं हैं और धीमा नहीं करते हैं? अच्छा क्रेडिट, और यह मुद्दा इस सवाल का जवाब देता है।

हम वास्तव में, नए ढांचे को खोलेंगे । याद रखें कि कैसे Wylsacom iPhones को अनपैक किया गया था? कुछ पहले से ही पुराने समीक्षकों को याद नहीं करते हैं, लेकिन क्यों? क्योंकि हबर एक मुख्यधारा का गढ़ है, और पेड विदोस, सॉरी, डायरिया की किरणें हैं । इस पोस्ट में हम विशेष रूप से तकनीकी कट्टर से निपटेंगे।

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

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

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

ऐसा न करें, इस लेख में लूम क्या है, या इस वीडियो को आगे पढ़ें, मैं सब कुछ समझाऊंगा।

तो, जटिलता क्या है। ऐसा एक दोस्त है, रॉन प्रेस्लर।

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

बहुत सारे गोवानोकॉडी का एक नरक है जो कुछ भी नहीं करते हैं, बस कहते हैं। खैर, ठीक है, मैं वही हूं। या ऐसे लोग हैं जो शांत इंजीनियर लगते हैं, लेकिन सामान्य तौर पर बेहोश में, वे ये कहते हैं: "जावा में, आपको थ्रेड्स में सुधार करने की आवश्यकता है।" क्या सुधार करना है? धागे क्या हैं?

लोग आमतौर पर सोचने के लिए बहुत आलसी होते हैं।

मजाक में:
पेट्का और वासिली इवानोविच एक विमान पर उड़ान भरते हैं।
वासिली इवानोविच पूछता है: - पेटका, उपकरण?
पेटका जवाब देती है: - २००!
वासिली इवानोविच: - और 200 के बारे में क्या?
पेटका: - उपकरणों के बारे में क्या?

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

और आपको क्या लगता है छह महीने भी नहीं बीते हैं कि लोग मेरी गाड़ी को खटखटाते हैं और कहते हैं कि देखो, हमने लिबर पर हल में ठेस लगा दी है, और मेरे पास पहले से ही बेलारूसी jfuture.by konf के बारे में एक रिपोर्ट है। यह दृष्टिकोण है। यह कुछ घटिया इंजीलवादी नहीं है, लेकिन एक दोस्त, एक सामान्य इंजीनियर है।

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

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

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

डेमो के साथ, प्रेस्लर ने सम्मेलन में बात की और इस वीडियो को जारी किया:

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

चर्चा तीन दर्दनाक विषयों के बारे में है:

• Continations
• रेशे
• टेल कॉल

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

यह एक साल पहले था, और तब से वे एक प्रोटोटाइप को देख रहे हैं। कुछ लोगों ने पहले ही उम्मीद खो दी है कि हम किसी दिन डेमो देखेंगे, लेकिन एक महीने पहले उन्होंने इसे जन्म दिया और दिखाया कि इस ट्वीट पर क्या दिखाई दे रहा है।

इस डेमो में सभी तीन दर्दनाक विषय या तो सीधे कोड में हैं, या कम से कम नैतिक रूप से मौजूद हैं। खैर, हां, उन्हें अभी तक पूंछ कॉल में महारत हासिल नहीं है, लेकिन वे चाहते हैं।

समस्याओं

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

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

(ठीक है, हाँ, इसका इस तथ्य से कुछ लेना-देना है कि जावा में सॉकेट्स को व्यवस्थित किया गया है, लेकिन यह एक अन्य वार्तालाप का विषय है)

कल्पना कीजिए कि आप किसी तरह के MMO लिख रहे हैं।

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

उस लड़ाई में प्रतिक्रिया का समय इतना लंबा था कि खिलाड़ी को शॉट के लिए कुछ मिनट इंतजार करना पड़ा। जहां तक ​​मुझे पता है, उस लड़ाई के लिए विशेष रूप से सीसीपी ने अपने क्लस्टर के विशाल हार्डवेयर संसाधनों को फेंक दिया।

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

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

हम विषय पर लौटते हैं।

दूसरी ओर, आप किसी प्रकार के अतुल्यकालिक ढांचे का उपयोग कर सकते हैं। यह स्केलेबल है। लेकिन हम तुरंत एक बहुत कठिन डिबगिंग में गिर जाएंगे, प्रदर्शन की जटिल रूपरेखा, हम इसे मूल रूप से विरासत के साथ एकीकृत करने में सक्षम नहीं होंगे, आपको बहुत सी चीजों को फिर से लिखना होगा, उन्हें घृणित आवरणों में लपेटना होगा, और आम तौर पर ऐसा महसूस होगा कि हमारे साथ सिर्फ बलात्कार हुआ था। कई बार एक पंक्ति में। दिनों के लिए, वास्तव में, हर समय जब हम इसे लिखते हैं, तो आपको ऐसा महसूस करना होगा।

मैंने विशेषज्ञ, प्रसिद्ध शिक्षाविद एस्कोबार से पूछा कि वह इस बारे में क्या सोचते हैं:

क्या करें? तथाकथित faybers बचाव के लिए भागते हैं।

सामान्य मामले में, फाइबर ऐसे हल्के धागे होते हैं जो पता स्थान के माध्यम से भी रगड़ते हैं (क्योंकि चमत्कार नहीं होते हैं, आप समझते हैं)। लेकिन साधारण धागे के विपरीत, वे प्रीमेप्टिव मल्टीटास्किंग का उपयोग नहीं करते हैं, लेकिन सहकारी मल्टीटास्किंग का। विकिपीडिया पर अधिक पढ़ें

फाइबर तुल्यकालिक और अतुल्यकालिक प्रोग्रामिंग दोनों के फायदों को महसूस कर सकता है। नतीजतन, लोहे का उपयोग बढ़ जाता है, और हम एक ही कार्य के लिए क्लस्टर में कम सर्वर का उपयोग करते हैं। ठीक है, इसके लिए हमारी जेब में हमें लैवेंडर मिलता है। Babosy। नहाना। मनी। खैर, आप बात करते हैं। सहेजे गए सर्वर के लिए।

चौराहे पर

पहली बात मैं चर्चा करना चाहता हूं। लोग निरंतरता और फाइबर के बीच अंतर को नहीं समझते हैं।
अब कल्ट ज्ञान होगा!

हम इस तथ्य की घोषणा करेंगे: निरंतरता और फाइबर दो अलग-अलग चीजें हैं।

निरंतरता

तंतुओं को एक मैकेनिक के ऊपर बनाया जाता है जिसे कॉन्टिन्यूशन कहा जाता है।

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

मैं "निरंतरता" शब्द का उपयोग करूंगा, न कि "निरंतरता" (जैसा कि विकिपीडिया पर लिखा गया है), क्योंकि हम सभी अंग्रेजी भाषा में संवाद करते हैं । सामान्य रूसी शब्दावली का उपयोग करते हुए, कोई भी आसानी से ऐसी स्थिति में आ सकता है जहां रूसी और अंग्रेजी शब्द के बीच अंतर बहुत बड़ा हो जाता है और कोई भी उस व्यक्ति के अर्थ को नहीं समझता है जो कहा गया था।

मैं कभी-कभी "उपज" के अंग्रेजी संस्करण के बजाय "बाहर भीड़" शब्द का उपयोग करूंगा। बस "उपज" शब्द - यह वास्तव में बुरा है। इसलिए "बाहर भीड़" होगी।

तो यहाँ है। यह बहुत महत्वपूर्ण है कि सातत्य के भीतर कोई प्रतिस्पर्धा न हो। यह अपने आप में इस प्रक्रिया का न्यूनतम आदिम है।

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

काम जारी रखने के साथ एक डेमो कहां प्राप्त करें - हम बहुत अंत में चर्चा करेंगे। अब बात करते हैं कि क्या है।

निरंतरता वर्ग स्वयं java.base पर स्थित है, सभी लिंक विवरण में होंगे। ( src/java.base/share/classes/java/lang/Continuation.java )। लेकिन यह वर्ग बहुत बड़ा है, बड़ा है, इसलिए यह केवल कुछ प्रकार से निचोड़ने के लिए समझ में आता है।

 public class Continuation implements Runnable { public Continuation(ContinuationScope scope, Runnable body); public final void run(); public static void yield(ContinuationScope scope); public boolean isDone(); protected void onPinned(Reason reason) { throw new IllegalStateException("Pinned: " + reason); } } 

ध्यान दें कि वास्तव में यह फ़ाइल लगातार बदल रही है। उदाहरण के लिए, पिछले दिन की तरह, निरंतरता ने Runnable इंटरफ़ेस को लागू नहीं किया। इसे एक तरह का स्केच मानते हैं।

कंस्ट्रक्टर पर नजर डालें। body - यह वह कोड है जिसे आप चलाने की कोशिश कर रहे हैं, और scope - एक प्रकार की खाल है जो आपको निरंतरता में घोंसला बनाने की अनुमति देती है।

तदनुसार, आप या तो इस कोड को run विधि के साथ पूर्व-शेड्यूल कर सकते हैं, या yield विधि का उपयोग करके कुछ विशिष्ट सरणी के साथ इसे दबा सकते हैं (नेस्टेड हैंडलर को कार्रवाई अग्रेषित करने के लिए कुछ के लिए यहां सरणी की आवश्यकता है, लेकिन हम उपयोगकर्ताओं की परवाह नहीं करते हैं)। आप isDone विधि का उपयोग करके पूछ सकते हैं कि क्या सब कुछ अंत तक पूरा हो गया है।

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

आप इसका उपयोग लगभग निम्नलिखित तरीके से कर सकते हैं:

 Continuation cont = new Continuation(SCOPE, () -> { while (true) { System.out.println("before"); Continuation.yield(SCOPE); System.out.println("after"); } }); while (!cont.isDone()) { cont.run(); } 

यह प्रेस्लर की प्रस्तुति का एक उदाहरण है। फिर से, यह "तुच्छ" कोड नहीं है, यह कुछ प्रकार का स्केच है।

यह एक निरंतरता है कि हम क्या कर रहे हैं, इस निरंतरता के बीच में हम बाहर भीड़ कर रहे हैं और फिर एक अंतहीन चक्र में हम पूछते हैं कि क्या निरंतरता ने अंत तक काम किया और क्या इसे जारी रखा जाना चाहिए।

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

और अब, निरंतरता के शीर्ष पर, फाइबर का निर्माण किया जाता है।

रेशे

तो, हमारे मामले में फाइबर का क्या मतलब है।

यह एक प्रकार की अमूर्तता है, जो है:

• हल्के धागे जेवीएम में ही संसाधित होते हैं, और ऑपरेटिंग सिस्टम में नहीं;
• कार्यों को बनाने, जीवन को बनाए रखने, स्विच करने के लिए बेहद कम ओवरहेड्स के साथ;
• जिसे लाखों बार चलाया जा सकता है।

कई तकनीकें एक या दूसरे तरीके से फाइबर बनाने की कोशिश कर रही हैं। उदाहरण के लिए, कोटलिन में बहुत स्मार्ट बाइटेकोड जनरेशन पर लागू किए गए कोरटाइन हैं। बहुत स्मार्ट । लेकिन ऐसी चीजों को लागू करने के लिए रनटाइम एक बेहतर जगह है।

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

तो फाइबर।

फाइबर में दो घटक होते हैं। यह है:

• निरंतरता (जारी)
• समयबद्धक (skedyuler)

वह है:

• Kontinuatsiya
• योजनाकार

आप तय कर सकते हैं कि योजनाकार यहां कौन है। मुझे लगता है कि यहाँ योजनाकार जे है।

• फाइबर उस कोड को लपेटता है जिसे आप एक निरंतरता में निष्पादित करना चाहते हैं
• शेड्यूलर ने उन्हें वाहक धागे के एक पूल पर लॉन्च किया

मैं उन्हें वाहक सूत्र कहूंगा।

वर्तमान प्रोटोटाइप java.util.concurrent.Executor का उपयोग करता है, और अंतर्निहित अनुसूचक ForkJoinPool । हमारे पास सब कुछ है। भविष्य में, वहाँ कुछ होशियार दिखाई दे सकता है, लेकिन अभी के लिए, इस तरह।

निरंतरता कैसे व्यवहार करती है:

• जब ताला होता है (उदाहरण के लिए, IO पर) तो यह बाहर निकलता है (उपज);
• जारी रखने के लिए तैयार होने पर जारी रहता है (उदाहरण के लिए, आईओ ऑपरेशन पूरा हो गया है और आप आगे बढ़ सकते हैं)।

कार्यों की वर्तमान स्थिति:

• दर्शन, अवधारणाओं पर मुख्य ध्यान;
• एपीआई तय नहीं है, यह "शो के लिए" है। यह एक शोध प्रोटोटाइप है;
• java.lang.Fiber क्लास का रेडीमेड एन्कोडेड वर्किंग प्रोटोटाइप है।

इस पर चर्चा होगी।

क्या पहले से ही फाइबर में देखा गया है:

• यह एक कार्य लॉन्च चलाता है;
• एक कार वाहक पर पार्किंग पार्किंग;
• फाइबर के पूरा होने का इंतजार है।

सर्किट आरेख

 mount(); try { cont.run(); } finally () { unmount(); } 

• हम एक धागा वाहक पर एक फाइबर माउंट कर सकते हैं;
• फिर निरंतरता चलाएं;
• और रुको जब तक वह बाहर भीड़ या ईमानदारी से बंद हो जाता है;
• अंत में, हम हमेशा धागा छोड़ते हैं।

इस छद्म कोड को ForkJoinPool या कुछ अन्य (जो अंततः अंतिम संस्करण में होगा) पर निष्पादित किया जाएगा।

वास्तविकता में उपयोग करें

 Fiber f = Fiber.execute( () -> { System.out.println("Good Morning!"); readLock.lock(); try { System.out.println("Good Afternoon"); } finally { readLock.unlock(); } System.out.println("Good Night"); }); 

देखिए, हम एक ऐसा फाइबर बना रहे हैं जिसमें:

• सभी का स्वागत है;
• हम रीक्रेंट लॉक पर रोक रहे हैं;
• लौटने पर, आपके दोपहर के भोजन पर बधाई;
• अंत में ताला जारी करें;
• और अलविदा कहो।

सब कुछ बहुत सरल है।

हम सीधे भीड़ का कारण नहीं बनते। प्रोजेक्ट लूम खुद जानता है कि जब readLock.lock(); ट्रिगर होता है readLock.lock(); उसे हस्तक्षेप करना चाहिए और निहितार्थ दमन करना चाहिए। उपयोगकर्ता यह नहीं देखता है, लेकिन यह वहां होता है।

हर जगह ढेर, ढेर!

आइए एक उदाहरण के रूप में पिज्जा स्टैक का उपयोग करके क्या हो रहा है।

शुरुआत में, वाहक धागा एक प्रतीक्षा स्थिति में है, और कुछ भी नहीं होता है।

शीर्ष पर स्टैक के शीर्ष, याद करते हैं।

तब फाइबर को निष्पादन के लिए निर्धारित किया गया था, और फाइबर कार्य चलना शुरू हो गया।

खुद के अंदर, वह स्पष्ट रूप से एक निरंतरता लॉन्च करता है, जिसमें वास्तविक कोड पहले से ही स्थित है।

उपयोगकर्ता के दृष्टिकोण से, हमने अभी तक यहां कुछ भी लॉन्च नहीं किया है।

स्टैक पर उपयोगकर्ता कोड का केवल पहला फ्रेम दिखाई दिया, और यह बैंगनी में चिह्नित है।

इसके अलावा, कोड को निष्पादित किया जाता है, निष्पादित किया जाता है, कुछ बिंदु पर कार्य लॉक को पकड़ने और उस पर ब्लॉक करने की कोशिश कर रहा है, जिससे स्वचालित भीड़ निकलती है।

सब कुछ जो निरंतरता स्टैक पर है, एक निश्चित जादुई जगह में संग्रहीत है। और गायब हो जाता है।

जैसा कि आप देख सकते हैं, धारा फाइबर पर लौटती है, इस निर्देश पर जो Continuation.run अनुसरण करती है। और यह फाइबर कोड का अंत है।

फाइबर कार्य समाप्त होता है, मीडिया कैरियर एक नई नौकरी की प्रतीक्षा कर रहा है।

फाइबर पार्क किया गया है, कहीं झूठ है, सातत्य पूरी तरह से भीड़ है।

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

• ReentrantLock.unlock
• LockSupport.unpark
• Fiber.unpark
• ForkJoinPool.execute

और हम जल्दी से स्टैक पर लौटते हैं, जो हाल ही में था।

इसके अलावा, वाहक धागा पूरी तरह से अलग हो सकता है। और यह समझ में आता है!

निरंतरता को फिर से चलाएं।

और यहाँ मैजिक आता है !!! स्टैक को पुनर्स्थापित किया जाता है, और Continuation.yield बाद अनुदेश के साथ निष्पादन जारी रहता है।

हम बस पार्क किए गए लॉक से बाहर निकलते हैं और जारी रहने वाले सभी कोड को निष्पादित करना शुरू करते हैं:

उपयोगकर्ता कार्य समाप्त हो जाता है, और निरंतरता के बाद फाइबर कार्य पर रिटर्न को नियंत्रित करता है। अनुदेश के बाद

उसी समय, फाइबर का निष्पादन समाप्त होता है, और हम फिर से खुद को स्टैंडबाय मोड में पाते हैं।

फाइबर का अगला लॉन्च फिर से ऊपर वर्णित पुनर्जन्म के पूरे चक्र को शुरू करता है।

जीवंत उदाहरण

और किसने कभी कहा कि यह सब काम करता है? क्या यह शाम को लिखे गए माइक्रोबैनचर्च के एक जोड़े के बारे में है?

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

मेरे पास इस सर्वर के लिए सटीक कोड नहीं है, लेकिन अगर इस पोस्ट को पर्याप्त लाइक्स और टिप्पणियां मिलीं, तो मैं स्वयं एक उदाहरण लिखने और वास्तविक ग्राफिक्स बनाने की कोशिश करूंगा।

समस्याओं

क्या यहां कोई समस्या है? हाँ बिल्कुल! Faybers के साथ पूरी कहानी निरंतर समस्याओं और tradeoffs के बारे में एक कहानी है।

दार्शनिक समस्याएँ

• क्या हमें थ्रेड्स को फिर से बनाने की आवश्यकता है?
• क्या सभी मौजूदा कोड को फाइबर के अंदर ठीक से काम करना चाहिए?

वर्तमान प्रोटोटाइप सीमाओं के साथ चलता है। जो रिलीज में जा सकता है, हालांकि मैं नहीं चाहूंगा। फिर भी, OpenJDK एक ऐसी चीज है जो अंतहीन अनुकूलता का सम्मान करती है।

तकनीकी सीमाएँ क्या हैं? सबसे स्पष्ट सीमाएं 2 टुकड़े हैं।

समस्या एक बार है - आप देशी फ्रेम को दबा नहीं सकते

 PrivilegedAction<Void> pa = () -> { readLock.lock(); // may park/yield try { // } finally { readLock.unlock(); } return null; } AccessController.doPrivileged(pa); //native method 

यहाँ doPrivileged मूल विधि को कॉल करता है।

आप doPrivileged कॉल करते हैं, VM से बाहर कूदते हैं, आपके स्टैक पर एक देशी फ्रेम दिखाई देता है, जिसके बाद आप readLock.lock() पर पार्क करने का प्रयास करते हैं। और उस पल में, जब तक यह अछूता नहीं रहेगा, तब तक वाहक धागा दागदार रहेगा। यही है, धागा गायब हो जाता है। इस मामले में, वाहक धागे समाप्त हो सकते हैं, और सामान्य तौर पर, यह फाइबर के पूरे विचार को तोड़ देता है।

इसे हल करने का तरीका पहले से ही ज्ञात है, और इस बारे में चर्चा चल रही है।

समस्या दो - सिंक्रनाइज़ किए गए ब्लॉक

यह बहुत अधिक गंभीर कचरा है

 synchronized (object) { //may park object.wait(); //may park } 

 synchronized (object) { //may park socket.getInputStream().read(); //may park } 

फाइबर में मॉनिटर कैप्चर के मामले में, वाहक धागे भी किक करते हैं।

यह स्पष्ट है कि एक पूरी तरह से नए कोड में आप मॉनिटर को सीधे ताले में बदल सकते हैं, बजाय प्रतीक्षा + सूचना के आप स्थिति वस्तुओं का उपयोग कर सकते हैं, लेकिन विरासत के साथ क्या करना है? यह एक समस्या है।

थ्रेड एपीआई? Thread.currentThread ()? थ्रेड लोकल?

वर्तमान प्रोटोटाइप में, Thread और Fiber ने Strand नामक एक सामान्य सुपरक्लास बनाया है।

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

अब थ्रेड एपीआई के साथ क्या हो रहा है?

• एक फाइबर में Thread.currentThread() का पहला उपयोग एक प्रकार का शैडो धागा, शैडो थ्रेड बनाता है;
• सिस्टम के दृष्टिकोण से, यह एक "असंबंधित" धागा है, और इसमें कोई वीएम मेटा-जानकारी नहीं है;
• ST हर उस चीज़ का अनुकरण करने की कोशिश करता है जो वह कर सकता है;
• लेकिन आपको यह समझना होगा कि पुराने एपीआई में बहुत सारा कचरा है;
• अधिक विशेष रूप से, थ्रेड एपीआई stop एपीआई को stop , suspend , resume और बिना किसी अपवाद के हैंडल करने के लिए लागू करता है।

धागा स्थानीय लोगों के साथ क्या करना है?

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

कितना खाती है सब

थ्रेड:

• स्टैक: कर्नेल डेटा संरचनाओं पर 1MB और 16KB;
• प्रति थ्रेड उदाहरण: VM मेटा जानकारी सहित 2300 बाइट्स।

फाइबर:

• निरंतरता स्टैक: सैकड़ों बाइट्स से किलोबाइट तक;
• प्रति फाइबर उदाहरण: 200-240 बाइट्स।

अंतर बहुत बड़ा है!
और ठीक वही है जो लाखों लोगों को आग देता है।

क्या पार्क कर सकते हैं

यह स्पष्ट है कि कुछ घटनाओं के होने पर सबसे जादुई चीज स्वचालित पार्किंग है। वर्तमान में क्या समर्थित है?

• थ्रेड.स्लीप, ज्वाइन करें;
• java.util.concurrent और LockSupport.lock;
• IO: सॉकेट्स पर नेटवर्क (सॉकेट पढ़ना, लिखना, कनेक्ट करना, स्वीकार करना), फाइलें, पाइप;
• यह सब अधूरा है, लेकिन सुरंग में रोशनी दिखाई देती है।

फाइबर के बीच संचार

एक और सवाल जो हर कोई पूछता है: वह है कि रेशों के बीच सूचनाओं का आदान-प्रदान कैसे किया जाए।

• वर्तमान प्रोटोटाइप Runnable में कार्यों को लॉन्च करता है, यदि इसे किसी भी कारण से आपकी आवश्यकता है, तो इसे CompletableFuture बदला जा सकता है;
• java.util.concurrent "बस काम करता है।" आप एक मानक तरीके से सब कुछ ठोकर कर सकते हैं;
• मल्टीथ्रेडिंग के लिए नए एपीआई हो सकते हैं, लेकिन यह सटीक नहीं है;
• छोटे सवालों का एक गुच्छा जैसे "फाइबर को मूल्यों को वापस करना चाहिए?" सब कुछ पर चर्चा की जाती है, वे प्रोटोटाइप में नहीं हैं।

प्रोटोटाइप में निरंतरता कैसे लागू की जाती है?

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

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

हमारे पास दो कुर्सियां ​​हैं ... मेरा मतलब है, दो ढेर। कूल्हे में दो जावा सरणियाँ। एक एक ऑब्जेक्ट सरणी है, जहां हम वस्तुओं के संदर्भों को संग्रहीत करेंगे। दूसरा है आदिम (उदाहरण के लिए, अंतरंग), जो बाकी सब कुछ संभाल लेगा।

अब हम एक ऐसी स्थिति में हैं जहां निरंतरता पहली बार प्रदर्शन की जाने वाली है।

कॉल कॉल एक आंतरिक विधि है जिसे enter कहा जाता है:

और फिर उपयोगकर्ता कोड निष्पादित किया जाता है, ठीक पहले भीड़ से बाहर तक।

इस बिंदु पर, एक वीएम कॉल किया जाता है, जो freeze कॉल करता है। इस प्रोटोटाइप में, यह सीधे शारीरिक रूप से किया जाता है - प्रतिलिपि का उपयोग करते हुए।

हम देशी स्टैक से जावा हिप तक क्रमिक रूप से कॉपी फ्रेम की प्रक्रिया शुरू करते हैं।

यह जांचना आवश्यक है कि क्या मॉनिटर वहां आयोजित किए जाते हैं या देशी कोड का उपयोग किया जाता है, या कुछ और जो वास्तव में हमें काम जारी रखने की अनुमति नहीं देगा।

और अगर सब ठीक है, तो हम पहले एक आदिम सरणी में कॉपी करते हैं:

तब हम वस्तुओं के संदर्भों को अलग करते हैं और इसे ऑब्जेक्ट एरे में सहेजते हैं:

दरअसल, इस जगह पर पढ़ने वाले सभी लोगों को दो चाय!

इसके अलावा हम देशी स्टैक के अन्य सभी तत्वों के लिए इस प्रक्रिया को जारी रखते हैं।

हुर्रे! हमने कूल्हे में घोंसले के लिए सब कुछ कॉपी किया। आप सुरक्षित रूप से कॉल के स्थान पर बिना किसी डर के कूद सकते हैं कि हमने कुछ खो दिया है। सब कुछ हिप है।

अब, जल्दी या बाद में, कॉलिंग कोड हमारी निरंतरता को फिर से कॉल करेगा। और उसे उस जगह से जारी रखना चाहिए जहां उसे पिछली बार छोड़ा गया था। यह हमारा काम है।

जाँच जारी है कि क्या निरंतरता चल रही थी, कहते हैं कि हाँ, यह चल रहा था। तो, आपको वीएम को कॉल करने की आवश्यकता है, स्टैक पर कुछ जगह को साफ करें और आंतरिक thaw वीएम फ़ंक्शन को कॉल करें। "थाव" का अनुवाद रूसी में "पिघलना", "अनफ़्रीज़" के रूप में किया गया है, जो काफी तार्किक लगता है। हमारे मुख्य देशी स्टैक में निरंतरता स्टैक से फ्रेम को अनफ्रीज करना आवश्यक है।

मुझे यकीन नहीं है कि चाय को ख़राब करना काफी स्पष्ट है। बुरा अमूर्त एक बिल्ली के समान एक दरवाजे के साथ है। लेकिन यह हमारे लिए करेगा।

हम काफी स्पष्ट प्रतियां बनाते हैं।

पहले एक आदिम सरणी के साथ:

फिर लिंक से:

आपको सही स्टैक प्राप्त करने के लिए कॉपी किए गए पैच को थोड़ा सा पैच करना होगा:

सभी फ़्रेमों के लिए अश्लीलता दोहराएं:

अब आप yield वापस जा सकते हैं और जारी रख सकते हैं जैसे कि कुछ भी नहीं हुआ था।

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

इसके बजाय, हमारे पास एक और विचार है - आलसी नकल।

आइए उस स्थान पर वापस जाएं जहां हमारे पास पहले से ही जमे हुए निरंतरता है।

हम पहले की तरह प्रक्रिया जारी रखते हैं:

पहले की तरह ही, हम देशी स्टैक पर जगह को साफ करते हैं:

लेकिन हम एक पंक्ति में सब कुछ कॉपी नहीं कर रहे हैं, लेकिन केवल एक या दो फ्रेम:

अब हैक। आपको विधि C के रिटर्न एड्रेस को पैच करना होगा ताकि यह एक निश्चित रिटर्न बैरियर की ओर इशारा करे:

अब आप सुरक्षित रूप से yield लौट सकते हैं:

जो बदले में C विधि में उपयोगकर्ता कोड के लिए कॉल करेगा:

अब कल्पना करें कि C उस कोड पर लौटना चाहता है जिसने इसे कॉल किया था। लेकिन उसका सारांश B , और वह स्टैक पर नहीं है! इसलिए, जब वह लौटने की कोशिश करता है, तो वह रिटर्न पते पर जाएगा, और यह पता अब रिटर्न बैरियर है। और, तुम्हें पता है, यह फिर से एक thaw कॉल आकर्षित करेगा:

और thaw निरंतरता स्टैक पर अगले फ्रेम को thaw करेगा, और यह B :

वास्तव में, हमने अनुरोध पर, इसे आलसी तरीके से कॉपी किया।

अगला, हम B को निरंतरता स्टैक से हटाते हैं और बाधा को फिर से सेट करते हैं (बाधा को सेट करने की आवश्यकता होती है क्योंकि निरंतर स्टैक पर कुछ बचा है)। और इतने पर और पर।

लेकिन मान लीजिए कि B कॉलिंग कोड में वापस नहीं जा रहा है, लेकिन पहले कुछ अन्य विधि D कॉल करता है D और यह नई विधि भी भीड़ से बाहर होना चाहती है।

इस मामले में, जब freeze करने का समय आता है, तो हमें निरंतर स्टैक पर केवल मूल ढेर के शीर्ष की प्रतिलिपि बनाने की आवश्यकता होगी:

इस प्रकार, किए गए कार्य की मात्रा स्टैक के आकार पर रैखिक रूप से निर्भर नहीं होती है। यह रैखिक केवल उन फ़्रेमों की संख्या पर निर्भर करता है जो हम वास्तव में काम में उपयोग करते थे।

क्या बचा है?

डेवलपर्स कुछ विशेषताओं को ध्यान में रखते हैं, लेकिन वे प्रोटोटाइप में नहीं आए।

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

अगले चरण:

• मानव एपीआई बनाएं;
• सभी लापता सुविधाएँ जोड़ें;
• प्रदर्शन में सुधार।

कहाँ से लाऊँ?

प्रोटोटाइप OpenJDK रिपॉजिटरी में एक ब्रंच के रूप में बनाया गया है। ब्रंच fibers स्विच करके आप यहां प्रोटोटाइप डाउनलोड कर सकते fibers ।

यह इस तरह किया जाता है:

 $ hg clone http://hg.openjdk.java.net/loom/loom $ cd loom $ hg update -r fibers $ sh configure $ make images 

जैसा कि आप जानते हैं, यह सब पूरे लानत ओपनजेडके की विधानसभा शुरू करेगा। इसलिए, सबसे पहले, आपके जीवन के अगले आधे घंटे में कुछ और करना होगा, जबकि यह सब होने जा रहा है।

दूसरे, आपको C ++ टूलकिन और GNU लिबास के साथ ठीक से कॉन्फ़िगर किया गया कंप्यूटर होना चाहिए। मैं संकेत कर रहा हूं कि यह अनुशंसित नहीं है कि आप विंडोज पर ऐसा करते हैं। सच में, यहां तक ​​कि वर्चुअलबॉक्स डाउनलोड करने और वहां एक नया उबंटू स्थापित करने के साथ, आप साइगविन या एमएसआईएस 64 से निर्माण करते समय एक और अमानवीय त्रुटि का एहसास करने की तुलना में कम समय के परिमाण के आदेशों को खर्च करेंगे। यह वह जगह है जहाँ msys Cygwin से भी बदतर में आता है।

हालाँकि, यह सब झूठ है, लेकिन मैं आपको विधानसभा निर्देश लिखने से थक गया ।

- , mercurial extension fsmonitor. , , hg help -e fsmonitor .
~/.hgrc :

 [fsmonitor] mode = on 

- . -, cp -R ./loom ./loom-backup .

, . , Java- , .

sh configure - . , Ubuntu, Autoconf ( sudo apt-get install autoconf ). — OpenJDK Ubuntu, , . Windows , .

, , hg diff --stat -r default:fibers .

, , , .

निष्कर्ष

«, ». «», . «Loom» — « ». Project Loom .

, . , «» , , — , , , — .

, , XIX , .

. -, .

, . IDE .

, , , « », «», « » .

? . .

आपका धन्यवाद