DIY Coroutines। भाग 1. आलसी जेनरेटर

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

स्रोत कोड

मैंने परियोजना को माइक्रोटयूटिन कहा, जो कि माइक्रो और कोरटाइन्स शब्द से आया है।

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

त्याग

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

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

कोरटाइन क्या हैं

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

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

जनरेटर

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

आइए अजगर में एक उदाहरण पर विचार करें, केवल इसलिए कि जनरेटर बॉक्स से बाहर हैं।

def generator(): k = 10 yield k k += 10 yield k k += 10 yield k for i in generator(): print(i) 

चक्र कुछ इस तरह से सामने आता है (शायद ऐसा बिलकुल नहीं है, लेकिन सिद्धांत हमारे लिए महत्वपूर्ण है):

 gen = generator() while True: try: i = next(gen) print(i) except StopIteration: break 

generator() लिए एक कॉल generator() जनरेटर नामक एक विशेष इट्रेटर बनाएगा। पहली कॉल टू next(gen) generator फंक्शन की शुरुआत से पहली yield तक कोड को निष्पादित करता yield , और genertator() से स्थानीय चर k का मान i चर को लिखा genertator() है। प्रत्येक अगली कॉल next करने के लिए तुरंत पिछले yield बाद निर्देश के साथ कार्य निष्पादित करने के लिए जारी रहेगा yield और इसी तरह। इस मामले में, next कॉल के बीच, generator अंदर सभी स्थानीय चर के मूल्यों को बचाया जाता है।

यह उसी के बारे में है, लेकिन कोटलिन भाषा में।

 val seq = sequence { var i = 10 yield(i) i += 10 yield(i) i += 10 yield(i) } for (i in seq) { println(i) } 

जावा में, हम आलसी पीढ़ी को कुछ इस तरह से कर सकते हैं:

 Iterable<Integer> seq = DummySequence.first(() -> { final int i = 10; return DummySequence.next(i, () -> { final int i1 = i + 10; return DummySequence.next(i1, () -> DummySequence.end(i1 + 10)); }); }); for(int i: seq) { System.out.println(i); } 

 import org.junit.Assert; import org.junit.Test; import java.util.Iterator; import java.util.List; import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.StreamSupport; public class DummySequenceTest { @Test public void dummySequenceTest() { DummySequence<Integer> sequence = DummySequence.first(() -> { final int i = 10; return DummySequence.next(10, () -> { final int i1 = i + 10; return DummySequence.next(i1, () -> DummySequence.end(i1 + 10)); }); }); List<Integer> list = StreamSupport.stream(sequence.spliterator(), false) .collect(Collectors.toList()); Assert.assertEquals(10, ((int) list.get(0))); Assert.assertEquals(20, ((int) list.get(1))); Assert.assertEquals(30, ((int) list.get(2))); } private static class DummySequence<T> implements Iterable<T>, Iterator<T> { private Step<T> step; public DummySequence(Step<T> step) { this.step = step; } @Override public Iterator<T> iterator() { return this; } @Override public boolean hasNext() { if (step instanceof EndStep) return false; step = step.nextStep(); return true; } @Override public T next() { return step.getValue(); } public static <T> DummySequence<T> first(Supplier<Step<T>> next) { return new DummySequence<>(new FirstStep<T>(next)); } public static <T> Step<T> next(T value, Supplier<Step<T>> next) { return new IntermediateStep<>(value, next); } public static <T> Step<T> end(T value) { return new EndStep<>(value); } } private interface Step<T> { T getValue(); Step<T> nextStep(); } public static class FirstStep<T> implements Step<T> { Supplier<Step<T>> nextStep; public FirstStep(Supplier<Step<T>> next) { this.nextStep = next; } @Override public T getValue() { throw new IllegalStateException(); } @Override public Step<T> nextStep() { return nextStep.get(); } } public static class IntermediateStep<T> implements Step<T> { T value; Supplier<Step<T>> nextStep; public IntermediateStep(T value, Supplier<Step<T>> nextStep) { this.value = value; this.nextStep = nextStep; } @Override public T getValue() { return value; } @Override public Step<T> nextStep() { return nextStep.get(); } } public static class EndStep<T> implements Step<T> { T value; public EndStep(T value) { this.value = value; } @Override public T getValue() { return value; } @Override public Step<T> nextStep() { throw new IllegalStateException(); } } } 

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

 Sequence<Integer> sequence = new Sequence<Integer>(() -> { int i = 10; yield(i); i += 10; yield(i); i += 10; yield(i); }); 

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

Kontinuatsii

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

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

मान लीजिए कि हमारे पास पहले से ही किसी तरह का जादुई तरीका है, जो निरंतरता के तंत्र को लागू करता है, जिसे निम्नलिखित इंटरफ़ेस द्वारा दर्शाया गया है। run विधि इसके निष्पादन को रोक सकती है। प्रत्येक बाद की कॉल अंतिम yield से निष्पादन को फिर से शुरू करती yield । हम एक Runnable रूप में जारी रखने के बारे में सोच सकते हैं जिसे भागों में निष्पादित किया जा सकता है।

 interface Continuation<T> { void run(SequenceScope<T> scope); } 

हम इस तरह से निरंतरता का उपयोग करेंगे:

 Sequence<Integer> sequence = new Sequence<>(new Continuation<>() { void run(SequenceScope<Integer> scope) { int i = 1; System.out.println("Continuation start"); scope.yield(i++); System.out.println("Continuation resume"); scope.yield(i++); System.out.println("Continuation resume"); scope.yield(i++); System.out.println("Continuation end"); } }); for(Integer i: sequence) { System.out.println("Next element :" + i); } 

और हम इस निष्कर्ष को पाने की उम्मीद करते हैं:

 Continuation start Next element: 1 Continuation resume Next element: 2 Continuation resume Next element: 3 Continuation end 

अगले तत्व के अनुरोध पर Sequence Continuation.run(scope) को कॉल करेगा, जो अगली उपज तक कोड के एक ब्लॉक को निष्पादित करेगा और भीड़ से बाहर हो जाएगा। Continuation.run(scope) की अगली कॉल अंतिम भीड़ के स्थान से काम शुरू करेगी और अगली yield तक कोड निष्पादित करेगी। Sequence कोड इस तरह हो सकता है:

 class Sequence implements Iterator<T>, SequenceScope<T>, Iterable<T> { private static final Object STOP = new Object(); private Object next = STOP; private Continuation<T> nextStep; public Sequence(Continuation<T> nextStep) { this.nextStep = nextStep; } @Override public boolean hasNext() { if (next == STOP) { nextStep.run(this); } return next != STOP; } @Override public T next() { if (next == STOP) { if (!hasNext()) { throw new NoSuchElementException(); } } T result = (T) next; next = STOP; return result; } @Override void yield(T t) { next = t; } public Iterator<T> iterator() { //  ,       return this; } } interface SequenceScope<T> { void yield(T t); } 

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

 class IntegerSequenceContinuation implements Continuation<Integer> { private int label = 0; private int i = 0; void run(SequenceScope<Integer> scope) { int i = this.i; switch (label) { case 0: System.out.println("Continuation start"); scope.yield(i++); label = 1; this.i = i; return; case 1: System.out.println("Continuation resume"); scope.yield(i++); label = 2; this.i = i; return; case 2: System.out.println("Continuation resume"); scope.yield(i++); label = 3; this.i = i; return; case 3: System.out.println("Continuation end"); label = 4; default: throw new RuntimeException(); } } } 

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

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

सस्पेंडेबल और कंटीन्यू

यदि निरंतरता ने काम पूरा कर लिया है या निलंबित कर दिया है तो हम कैसे समझेंगे? निलंबन के मामले में run विधि को एक विशेष SUSPEND ऑब्जेक्ट वापस करने दें।

 public interface Continuation<T> { Object SUSPEND = new Object() { @Override public String toString() { return "[SUSPEND]"; } }; T run(); } 

ध्यान दें कि मैंने इनपुट पैरामीटर को निरंतरता से हटा दिया है। हमें यह सुनिश्चित करना चाहिए कि पैरामीटर कॉल से कॉल में परिवर्तित न हों, ऐसा करने का सबसे अच्छा तरीका उन्हें हटाना है। उपयोगकर्ता, इसके विपरीत, scope पैरामीटर की आवश्यकता होती है (इसका उपयोग बहुत सारी चीजों के लिए किया जाएगा, लेकिन अब SequenceScope को इसके स्थान पर पारित किया जाता है, जहां से हमारी yield कहा जाता है)। इसके अलावा, उपयोगकर्ता किसी भी SUSPEND बारे में जानना नहीं चाहता है और कुछ भी वापस नहीं करना चाहता है। Suspendable इंटरफ़ेस का परिचय Suspendable ।

 public abstract class Suspendable<C extends Scope> { abstract public void run(C scope); } interface Scope {} 

डिजाइन समय में Suspendable Continuation है, जबकि Suspendable में Continuation Suspendable । उपयोगकर्ता Suspendable स्तर पर कोड लिखता है, और लाइब्रेरी का निम्न-स्तरीय कोड Continuation साथ काम करता है। यह बाइटकोड के संशोधन के बाद एक में बदल जाता है।

इससे पहले कि हम yield को कॉल करने के बाद प्रीमेच करने की बात करें, लेकिन भविष्य में हमें कुछ अन्य तरीकों के बाद प्रीमीम करने की आवश्यकता होगी। हम ऐसे तरीकों को चिह्नित करेंगे, जैसे @Suspend टिप्पणी। यह स्वयं yield पर लागू होता है:

 public class SequenceScope<T> implements Scope { @Suspend public void yield(T t) {...} } 

याद रखें कि हमारी निरंतरता परिमित ऑटोमेटा पर बनाई जाएगी। आइए हम यहां अधिक विस्तार से बताएं। इसे एक परिमित राज्य मशीन कहा जाता है क्योंकि इसमें राज्यों की सीमित संख्या होती है। वर्तमान स्थिति को संग्रहीत करने के लिए, हम एक विशेष लेबल फ़ील्ड का उपयोग करेंगे। प्रारंभ में, लेबल 0 है - एक शून्य (प्रारंभिक) स्थिति। Continuation.run लिए प्रत्येक कॉल किसी प्रकार के कोड को निष्पादित करेगा और प्रारंभिक अवस्था के अलावा किसी भी स्थिति (किसी अन्य में) में जाएगा। प्रत्येक परिवर्तन के बाद, निरंतरता को सभी स्थानीय चर, वर्तमान स्थिति संख्या को बचाना चाहिए और return SUSPEND निष्पादित करना चाहिए। अंतिम स्थिति में परिवर्तन को return null द्वारा निरूपित किया जाएगा (निम्नलिखित लेखों में हम केवल null नहीं लौटेंगे)। अंतिम स्थिति से Continuation.run कॉल एक ContinuationEndException अपवाद के साथ समाप्त होनी चाहिए।

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

 Sequence<Integer> seq = new Sequence(new Suspendable() {...}); 

लेकिन जनरेटर को निरंतरता की आवश्यकता होती है, क्योंकि उसे Continuation<T> nextStep; को इनिशियलाइज़ करने की आवश्यकता होती है Continuation<T> nextStep; । कोड में Suspendable से Suspendable पाने के लिए, मैंने एक विशेष Magic क्लास लिखी।

 package microutine.core; import microutine.coroutine.CoroutineScopeImpl; import java.lang.reflect.Field; public class Magic { public static final String SCOPE = "scope$S"; private static <C extends Scope, R> Continuation<R> createContinuation(Suspendable<C> suspendable, C scope) { try { Field contextField = suspendable.getClass().getDeclaredField(SCOPE); contextField.setAccessible(true); if (contextField.get(suspendable) != null) throw new IllegalArgumentException("Continuation already created"); contextField.set(suspendable, scope); } catch (Exception e) { throw new RuntimeException(e); } return getContinuation(suspendable); } public static <R, C extends Scope> Continuation<R> getContinuation(Suspendable suspendable) { if (getScope(suspendable) == null) throw new RuntimeException("No continuation created for provided suspendable"); //noinspection unchecked return ((Continuation<R>) suspendable); } private static Scope getScope(Suspendable suspendable) { try { Field contextField = suspendable.getClass().getDeclaredField(SCOPE); contextField.setAccessible(true); return (Scope) contextField.get(suspendable); } catch (Exception e) { throw new RuntimeException(e); } } } 

यह जादू कैसे काम करता है? scope पैरामीटर के साथ, scope$S क्षेत्र को प्रतिबिंब (सिंथेटिक क्षेत्र जिसे हम बायटेकोड में बनाएंगे) के माध्यम से शुरू किया जाता है। एक निरंतरता createContinuation में केवल एक बार आरंभीकृत की createContinuation , और प्रारंभ में एक दूसरे प्रयास के परिणामस्वरूप निष्पादन होगा। इसके बाद Continuation लिए सामान्य टाइप कास्ट आता है। सामान्य तौर पर, मैंने आपको धोखा दिया, सभी जादू यहां नहीं है। चूंकि इस तरह का रूपांतरण संभव है, इसलिए विशिष्ट Suspendable पहले से लागू किए गए Continuation । और संकलन के दौरान ऐसा हुआ।

परियोजना की संरचना

परियोजना में तीन भाग शामिल होंगे:

• लाइब्रेरी कोड (निम्न स्तर और उच्च स्तरीय एपीआई)
• परीक्षण (वास्तव में, केवल उन में अब आप इस पुस्तकालय का उपयोग कर सकते हैं)
• सस्पैंडेबल

चूंकि कनवर्टर वर्तमान में buildSrc में है, इसलिए इसे लाइब्रेरी के बाहर कहीं और उपयोग करना असंभव होगा। लेकिन अभी के लिए, हमें इसकी आवश्यकता नहीं है। भविष्य में, हमारे पास दो विकल्प होंगे: इसे एक अलग प्लगइन बनाएं, या अपना स्वयं का जावा एजेंट बनाएं (जैसा कि क्वासर करता है) और रनटाइम में रूपांतरण करते हैं।

 plugins { id "java" } group 'microutines' version '1.0-SNAPSHOT' sourceCompatibility = 1.8 task processYield(type: microutine.ProcessSuspendableTask) { classPath = compileJava.outputs.files + compileJava.classpath inputs.files(compileJava.outputs.files) } task processTestYield(type: microutine.ProcessSuspendableTask) { classPath = compileJava.outputs.files + compileTestJava.classpath inputs.files(compileTestJava.outputs.files) } compileJava.finalizedBy(processYield) //      compileTestJava.finalizedBy(processTestYield) repositories { mavenCentral() } dependencies { testCompile group: 'junit', name: 'junit', version: '4.12' compile group: 'junit', name: 'junit', version: '4.12' } 

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

बाइटकोड जेनरेशन

बायटेकोड के साथ काम करने के लिए, हम OW2 ASM लाइब्रेरी का उपयोग करेंगे। पुस्तकालय SAX पार्सर के सिद्धांत पर काम करता है। हम एक नया ClassReader बनाते हैं, इसे एक संकलित वर्ग को बाइट्स के एक सरणी के रूप में खिलाते हैं, और accept(ClassVisitor visitor) विधि कहते हैं। ClassReader bytecode को पार्स करेगा और उत्तीर्ण आगंतुक ( visitMethod , visitClass , visitInsn ) पर उपयुक्त तरीके से कॉल करेगा। आगंतुक एडॉप्टर मोड में काम कर सकता है और अगले आगंतुक को कॉल सौंप सकता है। आमतौर पर, अंतिम आगंतुक एक ClassWriter , जिसमें अंतिम ClassWriter उत्पन्न होता है। यदि कार्य गैर-रैखिक है (हमारे पास सिर्फ एक है), तो यह कक्षा से कई पास ले सकता है। एएसएम द्वारा प्रदान किया गया एक और तरीका यह है कि कक्षा को एक विशेष ClassNode पर लिखा जाए, और उस पर पहले से ही परिवर्तन किया जाए। पहला दृष्टिकोण तेज़ है, लेकिन ग़ैर-समस्या के समाधान के लिए उपयुक्त नहीं हो सकता है, इसलिए मैंने दोनों दृष्टिकोणों का उपयोग किया।

Suspendable टू Continuation को परिवर्तित करने में 3 वर्ग Suspendable :

• SuspendInfoCollector - Suspendable.run विधि का विश्लेषण करता है, सभी कॉल के बारे में @Suspend विधियों और उपयोग किए गए स्थानीय चर के बारे में जानकारी एकत्र करता है।
• SuspendableConverter - आवश्यक फ़ील्ड बनाता है, Continuation.run प्राप्त करने के लिए Suspendable.run विधि के हस्ताक्षर और हैंडल को Suspendable.run ।
• SuspendableMethodConverter - Suspendable.run विधि का कोड Suspendable.run है। स्थानीय चर को सहेजने और पुनर्स्थापित करने, label फ़ील्ड में वर्तमान स्थिति को सहेजने और इच्छित निर्देश पर जाने के लिए एक कोड जोड़ता है।

आइए कुछ बिंदुओं का अधिक विस्तार से वर्णन करें।

run विधि की खोज इस प्रकार है:

 MethodNode method = classNode.methods.stream() .filter(methodNode -> methodNode.name.equals("run") && (methodNode.access & Opcodes.ACC_BRIDGE) == 0) .findFirst() .orElseThrow(() -> new RuntimeException("Unable to find method to convert")); 

यह उम्मीद की जाती है कि परिवर्तनीय वर्ग में दो run विधियां होंगी, और उनमें से एक पुल संशोधक के साथ होगा (यह यहां क्या पढ़ा गया है )। हम एक संशोधक के बिना एक विधि में रुचि रखते हैं।

जेवीएम बायटेकोड में, एक सशर्त (और बिना शर्त) संक्रमण कहीं भी किया जा सकता है। एएसएम में एक विशेष Label एब्स्ट्रैक्शन (लेबल) होता है, जो कि बाइटकोड में एक स्थिति है। कोड के दौरान, @Suspend विधियों में से प्रत्येक कॉल के बाद, हम उन लेबलों को जगह देंगे, जिन्हें हम run विधि की शुरुआत में एक सशर्त छलांग लगाएंगे।

 @Override public void visitCode() { //    super.visitCode(); Label startLabel = new Label(); super.visitVarInsn(Opcodes.ALOAD, THIS_VAR_INDEX); //    this super.visitFieldInsn(Opcodes.GETFIELD, myClassJvmName, "label$S$S", "I"); //  label$S$S super.visitVarInsn(Opcodes.ISTORE, labelVarIndex); //      super.visitVarInsn(Opcodes.ILOAD, labelVarIndex); //   label   super.visitIntInsn(Opcodes.BIPUSH, 0); //  0   super.visitJumpInsn(Opcodes.IF_ICMPEQ, startLabel); //      startLabel        (label == 0) for (int i = 0; i < numLabels; i++) { //   ,     super.visitVarInsn(Opcodes.ILOAD, labelVarIndex); super.visitIntInsn(Opcodes.BIPUSH, i + 1); super.visitJumpInsn(Opcodes.IF_ICMPEQ, labels[i]); } super.visitTypeInsn(Opcodes.NEW, "microutine/core/ContinuationEndException"); // run      ,   super.visitInsn(Opcodes.DUP); super.visitMethodInsn(Opcodes.INVOKESPECIAL, "microutine/core/ContinuationEndException", "<init>", "()V", false); super.visitInsn(Opcodes.ATHROW); super.visitLabel(startLabel); // ,      } 

हम @Suspend विधियों के कॉल के बाद लेबल @Suspend ।

 @Override public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) { boolean suspendPoint = Utils.isSuspendPoint(classLoader, owner, name); super.visitMethodInsn(opcode, owner, name, descriptor, isInterface); if (suspendPoint) { super.visitVarInsn(Opcodes.ALOAD, THIS_VAR_INDEX); //    this super.visitIntInsn(Opcodes.BIPUSH, suspensionNumber); //   ,       super.visitFieldInsn(Opcodes.PUTFIELD, myClassJvmName, "label$S$S", "I"); //     label$S$S saveFrame(); //    suspend(); super.visitLabel(labels[suspensionNumber - 1]); // ,     restoreFrame(); //    suspensionNumber++; } } private void suspend() { super.visitFieldInsn(Opcodes.GETSTATIC, "microutine/core/Continuation", "SUSPEND", "Ljava/lang/Object;"); //    Continuation.SUSPEND super.visitInsn(Opcodes.ARETURN); //   } 

परीक्षण

हम एक जनरेटर लिखते हैं जो एक पंक्ति में तीन नंबर देता है।

 public class YieldTest { @Test public void testIntSequence() { Sequence<Integer> sequence = new Sequence<Integer>(new SequenceSuspendable<Integer>() { @Override public void run(SequenceScope<Integer> scope) { scope.yield(10); scope.yield(20); scope.yield(30); } }); List<Integer> list = new ArrayList<>(); for (Integer integer : sequence) { list.add(integer); } assertEquals(10, (int) list.get(0)); assertEquals(20, (int) list.get(1)); assertEquals(30, (int) list.get(2)); } } 

परीक्षण स्वयं कुछ भी दिलचस्प नहीं दर्शाता है, लेकिन यह वर्ग फ़ाइल को विघटित करने के लिए पर्याप्त दिलचस्प है।

 public class YieldTest { public YieldTest() { } @Test public void testIntSequence() { class NamelessClass_1 extends SequenceSuspendable<Integer> implements Continuation { private SequenceScope scope$S; NamelessClass_1() { } public Object run(Object var1) { int label = this.label$S$S; SequenceScope var2; if (label != 0) { if (label != 1) { if (label != 2) { if (label != 3) { throw new ContinuationEndException(); } else { var2 = this.scope$S; this.label$S$S = 4; return null; } } else { var2 = this.scope$S; this.yield(30); this.label$S$S = 3; this.scope$S = var2; return Continuation.SUSPEND; } } else { var2 = this.scope$S; this.yield(20); this.label$S$S = 2; this.scope$S = var2; return Continuation.SUSPEND; } } else { var2 = this.scope$S; this.yield(10); this.label$S$S = 1; this.scope$S = var2; return Continuation.SUSPEND; } } } Sequence<Integer> sequence = new Sequence(new NamelessClass_1()); List<Integer> list = new ArrayList(); Iterator var3 = sequence.iterator(); while(var3.hasNext()) { Integer integer = (Integer)var3.next(); list.add(integer); } Assert.assertEquals(10L, (long)(Integer)list.get(0)); Assert.assertEquals(20L, (long)(Integer)list.get(1)); Assert.assertEquals(30L, (long)(Integer)list.get(2)); } } 

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

 public class YieldTest { @Test public void fibonacci() { Sequence<Integer> sequence = new Sequence<>(new Suspendable<Integer>() { @Override public void run(SequenceScope<Integer> scope) { scope.yield(1); scope.yield(1); int a = 1; int b = 1; while (true) { b += a; scope.yield(b); a += b; scope.yield(a); } } }); //noinspection OptionalGetWithoutIsPresent Integer tenthFibonacci = StreamSupport.stream(sequence.spliterator(), false) .skip(9).findFirst().get(); assertEquals(55, ((int) tenthFibonacci)); } } 

उपरोक्त कोड एक अनंत फाइबोनैचि अनुक्रम उत्पन्न करता है। हम संकलन और विघटित करते हैं:

 public class YieldTest { public YieldTest() { } @Test public void fibonacci() { class NamelessClass_1 extends SequenceSuspendable<Integer> implements Continuation { private SequenceScope scope$S; private int aa$S; private int ba$S; NamelessClass_1() { } public Object run(Object var1) { int label = this.label$S$S; SequenceScope var2; if (label != 0) { if (label != 1) { int var3; int var4; if (label != 2) { if (label == 3) { var2 = this.scope$S; var3 = this.aa$S; var4 = this.ba$S; var3 += var4; var2.yield(var3); this.label$S$S = 4; this.scope$S = var2; this.aa$S = var3; this.ba$S = var4; return Continuation.SUSPEND; } if (label != 4) { throw new ContinuationEndException(); } var2 = this.scope$S; var3 = this.aa$S; var4 = this.ba$S; } else { var2 = this.scope$S; var3 = 1; var4 = 1; } var4 += var3; var2.yield(var4); this.label$S$S = 3; this.scope$S = var2; this.aa$S = var3; this.ba$S = var4; return Continuation.SUSPEND; } else { var2 = this.scope$S; var2.yield(1); this.label$S$S = 2; this.scope$S = var2; return Continuation.SUSPEND; } } else { var2 = this.scope$S; var2.yield(1); this.label$S$S = 1; this.scope$S = var2; return Continuation.SUSPEND; } } } Sequence<Integer> sequence = new Sequence(new NamelessClass_1()); Integer tenthFibonacci = (Integer)StreamSupport.stream(sequence.spliterator(), false).skip(9L).findFirst().get(); Assert.assertEquals(55L, (long)tenthFibonacci); } } 

समझ क्या एक विघटित वर्ग को काफी मुश्किल बनाता है। पिछली बार की तरह, अधिकांश निर्देश वहां स्थानीय चर चलाते हैं। कुछ असाइनमेंट बेकार हैं, और वेरिएबल्स को तुरंत अन्य मानों से अलग कर दिया गया है। , .

while, . . . , '' return SUSPEND .

सारांश

, , , . yield. , , — , . , ( ) . , JIT . yield yieldAll — , , , , . , , .

— — , . , . , : , .