थोड़ी देर के लिए C # के async / प्रतीक्षा पैटर्न से निपटने के बाद, मुझे अचानक यह पता चला कि मुझे वास्तव में यह नहीं पता है कि निम्नलिखित कोड में क्या होता है:
async void MyThread()
{
while (!_quit)
{
await GetWorkAsync();
}
}GetWorkAsync()Taskनिरंतरता निष्पादित होने पर एक थ्रेड स्विच का कारण हो सकता है या नहीं करने के लिए मान लिया जाता है।
अगर उलझन पाश के अंदर नहीं होती तो मैं भ्रमित नहीं होता। मैं स्वाभाविक रूप से उम्मीद करूंगा कि बाकी विधि (यानी निरंतरता) संभवतः दूसरे धागे पर निष्पादित होगी, जो ठीक है।
हालांकि, एक लूप के अंदर, "बाकी विधि" की अवधारणा मेरे लिए थोड़ी धूमिल हो जाती है।
यदि थ्रेड निरंतरता पर स्विच किया जाता है तो बनाम "लूप के बाकी" का क्या होता है अगर इसे स्विच नहीं किया जाता है? लूप के अगले पुनरावृत्ति को किस धागे पर निष्पादित किया जाता है?
मेरी टिप्पणियों से पता चलता है (निर्णायक रूप से सत्यापित नहीं) कि प्रत्येक पुनरावृत्ति एक ही धागे (मूल एक) पर शुरू होती है जबकि निरंतरता दूसरे पर चलती है। क्या यह वास्तव में हो सकता है? यदि हाँ, तो क्या यह अनपेक्षित समानांतरवाद की एक डिग्री है जिसे गेटवॉर्क्ससिनस्टैंड विधि के दृश्य-ए-विज़ थ्रेड-सुरक्षा के लिए जिम्मेदार होना चाहिए?
अद्यतन: मेरा प्रश्न डुप्लिकेट नहीं है, जैसा कि कुछ ने सुझाव दिया है। while (!_quit) { ... }कोड पैटर्न केवल अपने वास्तविक कोड का सरलीकरण है। वास्तव में, मेरा धागा एक लंबे समय तक रहने वाला लूप है जो नियमित अंतराल (हर 5 सेकंड में डिफ़ॉल्ट रूप से) पर अपने काम की वस्तुओं की इनपुट कतार को संसाधित करता है। सैंपल कोड द्वारा सुझाई गई वास्तविक वास्तविक स्थिति की जांच भी एक साधारण फील्ड चेक नहीं है, बल्कि एक इवेंट हैंडल चेक है।