क्या होता है यदि मैं किसी ऐसे कार्य का इंतजार करता हूं जो पहले से चल रहा है या दौड़ रहा है?

Question

एक कार्य चर है और कहता है कि कार्य अभी चल रहा है .. निम्न पंक्ति को निष्पादित करके।

await _task; 

मैं सोच रहा था क्या होता है जब मैं इस कोड लिखने:

await _task; 
await _task; 

यह कार्य दो बार अमल होगा? या एक अपवाद फेंक क्योंकि यह पहले से ही चल रहा है?

Answer 1

क्या यह कार्य दो बार निष्पादित करेगा? या एक अपवाद फेंक दें क्योंकि इसमें पहले से चल रहा है?

नहीं और नहीं। एकमात्र चीज await कॉल Task.GetAwaiter है, यह किसी भी चीज़ को चलाने का कारण नहीं बनती है। यदि कार्य पूरा होने के लिए पहले से ही चलाया गया है, तो यह Task<T> है, या तो Task है, तो अगली पंक्ति में सिंक्रनाइज़ रूप से चलाएं, क्योंकि पहले से ही पूरा किए गए कार्यों के लिए अनुकूलन है।

एक साधारण डेमो:

async Task Main() 
{ 
    var foo = FooAsync(); 
    await foo; 
    await foo; 

    var bar = BarAsync(); 
    var firstResult = await bar; 
    var secondResult = await bar; 

    Console.WriteLine(firstResult); 
    Console.WriteLine(secondResult); 
} 

public async Task FooAsync() 
{ 
    await Task.Delay(1); 
} 

public async Task<int> BarAsync() 
{ 
    await Task.Delay(1); 
    return 1; 
} 

आप राज्य मशीन ही थोड़ा गहराई में जाकर, तो आप इस देखेंगे:

this.<foo>5__1 = this.<>4__this.FooAsync(); 
taskAwaiter = this.<foo>5__1.GetAwaiter(); 
if (!taskAwaiter.IsCompleted) 
{ 
    this.<>1__state = 0; 
    this.<>u__1 = taskAwaiter; 
    M.<FooBar>d__0 <FooBar>d__ = this; 
    this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, M.<FooBar>d__0> 
                (ref taskAwaiter, ref <FooBar>d__); 
    return; 
} 

यह अनुकूलन पहला काम के पूरा होने की जांच करता है। यदि कार्य पूरा नहीं हुआ है, तो यह UnsafeOnCompleted पर कॉल करेगा जो निरंतरता पंजीकृत करेगा। यह पूरा हो गया है, तो यह switch टूट जाता है और करने के लिए चला जाता है:

this.<>1__state = -2; 
this.<>t__builder.SetResult(); 

कौन सा अंतर्निहित Task के लिए परिणाम सेट करता है, और इस तरह से आप वास्तव में तुल्यकालिक मूल्य मिलता है।

var i = 0; 
var task = Task.Run(() => { i++; Console.WriteLine(i); return i; }); 

var x = await task; 
var y = await task; 

Console.WriteLine(x); 
Console.WriteLine(y); 

यह लिखते हैं::

1 
1 
1 

तो, स्पष्ट रूप से, काम केवल एक बार चलाता है

Answer 2

मैं एक साथ इस त्वरित परीक्षण फेंक दिया।