मैश: मल्टीथ्रेडिंग, कोरटाइन, एसिंक्स और वेट

प्रस्तावना

आपको याद दिला दूं कि यह भाषा मेरे द्वारा शैक्षिक उद्देश्यों के लिए एक शौक के हिस्से के रूप में विकसित की गई थी। मैं इसे (फिलहाल) पूरी तरह से विकसित भाषा नहीं मानता, लेकिन कौन जानता है कि भविष्य क्या उम्मीद कर सकता है।

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

परिचय

हमारे समय में बहु-प्रसार और अतुल्यकालिकता आधुनिक प्रोग्रामिंग भाषाओं के सबसे महत्वपूर्ण घटकों में से एक हैं।

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

तेज बहाव

वे कोड निष्पादन को समानांतर बनाना आसान बनाते हैं।
इसके लिए, प्रक्षेपण: ... एंड कंस्ट्रक्शन को मैश में जोड़ा गया है

कोड उदाहरण:

uses <bf> uses <crt> proc main(): for(i ?= 1; i <= 10; i++): launch: sleep(random() * 100) println(i) end end inputln() end 

आउटपुट उदाहरण:

 9 1 2 7 5 3 10 4 6 8 

जब प्रोग्राम का निष्पादन लॉन्च तक पहुँच जाता है..तो, इस ब्लॉक के अंदर कोड को एक अलग थ्रेड में लॉन्च किया जाता है, और लॉन्च कोड का निष्पादन इस ब्लॉक में स्थानांतरित हो जाता है।

आप कोटलिन प्रोग्रामिंग भाषा में लगभग उसी भाषा के निर्माण को पूरा कर सकते हैं।

Async और प्रतीक्षा करें

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

Async आपको कोड निष्पादन को एक अलग थ्रेड में अनुवाद करने और मुख्य कोड का निष्पादन जारी रखने की अनुमति देता है।

प्रतीक्षा आपको उस क्षण की प्रतीक्षा करने की अनुमति देती है जब सभी आवश्यक async ब्लॉक पूरे हो जाते हैं।

कोड उदाहरण:

 uses <bf> uses <crt> proc main(): println("Hello!") async a: println("Test") sleep(1000) println("Test") sleep(1000) println("Test") sleep(1000) end async b: println("Test 2") sleep(300) println("Test 2") sleep(300) println("Test 2") sleep(300) end wait a, b println("End!") inputln() end 

निष्कर्ष:

 Hello! Test Test 2 Test 2 Test 2 Test Test End! 

क्लासिक मल्टीथ्रेडिंग

मल्टीथ्रेडिंग के लिए समर्थन प्रदान करने वाला मुख्य कोड आधार मॉड्यूल में केंद्रित है? <थ्रेड्स>।

मुख्य घटकों पर बाद में चर्चा की जाएगी:

1) TThread क्लास (केवल एक क्लास डिक्लेरेशन दिया जाता है, पूरा कोड मॉड्यूल में आगे स्थित होता है):

 class TThread: protected: var ThreadContext public: var Resumed, Terminated, FreeOnTerminate proc Create, Free proc Execute //for overriding proc Suspend, Resume, Terminate, WaitFor, ReJoin //Control proc's end 

2) टीसीआर राजनीतिक वर्ग (इसका विवरण):

 class TCriticalSection: protected: var Critical_Section_Controller public: proc Create, Free //Methods proc Enter, Leave func TryEnter end 

3) जल्दी से धागे बनाने और शुरू करने के लिए तरीके:

 func Async(method, ...) func Thread(method, ...) func Parallel(method, ...) 

4) थ्रेड-सुरक्षित परमाणु (क्रॉस-थ्रेड इंटरैक्शन के लिए चर वर्ग):

 class TAtomic: private: var Locker, Value public: proc Create, Free proc Set func Get end 

5)

 class TCoroutine(TThread): public: var NextCoroutine proc Create proc Yield, YieldFor end 

तो, आइए इसे क्रम में लें।

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

तुरंत नमूना कोड:

 uses <bf> uses <crt> uses <threads> class MyThreadClass(TThread): var Param proc Create, Execute end proc MyThreadClass::Create(Param): $Param ?= Param TThread::Create$(true) end proc MyThreadClass::Execute(): for(i ?= 0; i < 10; i++): PrintLn(i, ": ", $Param) end end proc main(): new MyThreadClass("Thread #2!") InputLn() end 

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

कोड उदाहरण:

 uses <bf> uses <crt> uses <threads> proc class::MyThreadedProc(): for(i ?= 0; i < 10; i++): PrintLn(i, ": Threaded hello!") end end proc main(): Thr ?= new TThread(false) Thr->Execute ?= class::MyThreadedProc Thr->Resume() InputLn() end 

अगर हमें किसी नए थ्रेड में मापदंडों के साथ विधि को चलाने की आवश्यकता है, तो एसिंक्स (), थ्रेड () और समानांतर () विधियां ठीक वही हैं जो हमें चाहिए।

एक नए सूत्र में एक विधि शुरू करने का एक उदाहरण:

 uses <bf> uses <crt> uses <threads> proc ThreadedProc(Arg): for(i ?= 0; i < 10; i++): PrintLn(i, ": ", Arg) end end proc main(): Async(ThreadedProc, "Thread #1!") InputLn() end 

जैसा कि आपने पहले देखा होगा, ये 3 विधियां फ़ंक्शन हैं और वे वापस आती हैं - टीथ्रेड के समान कक्षाएं।

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

धागा सिंक्रनाइज़ेशन

ऐसा करने के लिए, मैंने मैश में TCriticalSection वर्ग जोड़ा।

कोड उदाहरण:

 uses <bf> uses <crt> uses <threads> var CSect = new TCriticalSection() proc ThreadedProc(Arg): while true: CSect -> Enter() PrintLn(Arg) CSect -> Leave() Sleep(10) gc() end end proc CriticalThreadedProc(): while true: Sleep(3000) CSect -> Enter() Sleep(1000) PrintLn("And now...") Sleep(1000) PrintLn("Time to...") Sleep(1000) PrintLn("Critical section!") Sleep(3000) CSect -> Leave() gc() end end proc main(): Async(ThreadedProc, "I'm thread #1!!!") Async(CriticalThreadedProc) InputLn() end 

परमाणु

किसी भी मान को संग्रहीत करने के लिए थ्रेड-सुरक्षित कंटेनर को लागू करें।

कोड उदाहरण:

 uses <bf> uses <crt> uses <threads> proc main(): MyThreadValue ?= new TAtomic(0) launch: while true: MyThreadValue -> Set(1) Sleep(8) gc() end end launch: while true: MyThreadValue -> Set(2) Sleep(3) gc() end end launch: while true: MyThreadValue -> Set(3) Sleep(11) gc() end end while true: PrintLn(MyThreadValue -> Get()) Sleep(100) gc() end end 

Coroutines

यह कार्यक्षमता आपको कोड के समानांतर निष्पादन को सिंक्रनाइज़ करने की अनुमति देती है।

कोड उदाहरण:

 uses <bf> uses <crt> uses <threads> proc class::Proc1(): while true: println("Hello world #1") sleep(100) gc() $yield() end end proc class::Proc2(): while true: println("Hello world #2") sleep(100) gc() $yield() end end proc class::Proc3(): while true: println("Hello world #3") sleep(100) gc() $yield() end end proc main(): cor3 ?= new TCoroutine(false, null) cor3 -> Execute ?= class::Proc3 cor2 ?= new TCoroutine(false, cor3) cor2 -> Execute ?= class::Proc2 cor1 ?= new TCoroutine(false, cor2) cor1 -> Execute ?= class::Proc1 cor3 -> NextCoroutine ?= cor1 cor1 -> Resume() InputLn() end 

निष्कर्ष:

 Hello world #1 Hello world #2 Hello world #3 Hello world #1 Hello world #2 Hello world #3 ... 

निष्कर्ष

मुझे उम्मीद है कि आपको यह लेख रोचक लगा होगा।

टिप्पणियों की प्रतीक्षा में :)

पुनश्च: आपकी टिप्पणियों के अनुसार, मैंने भाषा से निर्माण को हटा दिया। अब इसका स्थान निर्माण द्वारा लिया गया है:

 whilst <>: ... end 

यह एक नियमित रूप से लूप है, इस अंतर के साथ कि पुनरावृत्ति के बाद स्थिति की जांच की जाती है।