कार्य (पैरामीटर) के साथ।

Question 1

मैं एक मल्टी-टास्किंग नेटवर्क प्रोजेक्ट पर काम कर रहा हूं और मैं नया हूं Threading.Tasks। मैंने एक सरल लागू किया Task.Factory.StartNew()और मुझे आश्चर्य है कि मैं इसे कैसे कर सकता हूंTask.Run() ?

यहाँ मूल कोड है:

Task.Factory.StartNew(new Action<object>(
(x) =>
{
    // Do something with 'x'
}), rawData);

मैंने ऑब्जेक्ट ब्राउज़रSystem.Threading.Tasks.Task में देखा और मुझे एक जैसा पैरामीटर नहीं मिला । केवल वही है जो पैरामीटर लेता है और कोई प्रकार नहीं है ।Action<T>Actionvoid

वहाँ केवल 2 चीजें हैं: static Task Run(Action action)और static Task Run(Func<Task> function)दोनों के साथ पैरामीटर पोस्ट नहीं कर सकते।

हाँ, मैं जानता हूँ कि मैं इसके लिए एक सरल विस्तार विधि बना सकते हैं, लेकिन मेरा मुख्य सवाल हम एक पंक्ति पर लिख सकते हैं है के साथ Task.Run()?

Question 2

private void RunAsync()
{
    string param = "Hi";
    Task.Run(() => MethodWithParameter(param));
}

private void MethodWithParameter(string param)
{
    //Do stuff
}

संपादित करें

लोकप्रिय मांग के कारण मुझे ध्यान देना चाहिए कि Taskलॉन्चिंग कॉलिंग थ्रेड के साथ समानांतर में चलेगा। डिफ़ॉल्ट मानकर TaskSchedulerयह .NET का उपयोग करेगा ThreadPool। वैसे भी, इसका मतलब है कि आपको जो भी पैरामीटर (ओं) को पारित करने की आवश्यकता हैTask ही समय में कई थ्रेड्स द्वारा एक्सेस किए जा रहे जितने , उन्हें साझा स्थिति बनाते हैं। इसमें उन्हें कॉलिंग थ्रेड पर एक्सेस करना शामिल है।

मेरे उपरोक्त कोड में उस मामले को पूरी तरह से बनाया गया है। तार अपरिवर्तनीय हैं। इसलिए मैंने उन्हें एक उदाहरण के रूप में इस्तेमाल किया। लेकिन कहते हैं कि तुम एक का उपयोग नहीं कर रहे हैंString ...

एक समाधान का उपयोग करना है asyncऔर await। यह, डिफ़ॉल्ट रूप से, SynchronizationContextकॉलिंग थ्रेड को कैप्चर करेगा और कॉल करने के बाद शेष विधि के लिए एक निरंतरता बनाएगा awaitऔर इसे बनाए गए से संलग्न करेगा Task। यदि यह विधि WinForms GUI थ्रेड पर चल रही है, तो यह प्रकार की होगीWindowsFormsSynchronizationContext ।

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

शेष विधि को पूरा करने के लिए यह प्रतीक्षा वांछनीय हो सकती है या नहीं भी हो सकती है। यदि उस पद्धति में कुछ भी नहीं है, तो बाद में Taskआपके पास दिए गए मापदंडों को एक्सेस करता है जो आप उपयोग नहीं करना चाहते हैं await।

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

वैसे भी, यह करने के लिए पारित मापदंडों के संबंध में इस धागे को सुरक्षित बनाने का एक सरल तरीका है Task.Run:

आप पहली बार सजाने चाहिए RunAsyncसाथ async:

private async void RunAsync()

महत्वपूर्ण लेख

अधिमानतः चिह्नित विधि को शून्य नहीं लौटना चाहिए , क्योंकि लिंक किए गए दस्तावेज़ में उल्लेख है। इसका सामान्य अपवाद ईवेंट हैंडलर जैसे बटन क्लिक और ऐसे हैं। उन्हें शून्य लौटना चाहिए। अन्यथा मैं हमेशा एक वापसी का उपयोग करते समय या कोशिश करता हूं । यह काफी कुछ कारणों से अच्छा अभ्यास है।async TaskTask<TResult>async

अब आप नीचे awaitकी Taskतरह चला सकते हैं। आप awaitबिना उपयोग नहीं कर सकते async।

await Task.Run(() => MethodWithParameter(param));
//Code here and below in the same method will not run until AFTER the above task has completed in one fashion or another

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

पक्षीय लेख

थोड़ा सा विषय, लेकिन WinForms GUI थ्रेड पर किसी भी प्रकार के "ब्लॉकिंग" का उपयोग करने से सावधान रहें क्योंकि इसे चिह्नित किया जा रहा है [STAThread]। उपयोग awaitकरना बिल्कुल भी ब्लॉक नहीं होगा, लेकिन मैं कभी-कभी इसे किसी प्रकार के अवरोधन के साथ संयोजन के रूप में उपयोग करते हुए देखता हूं।

"ब्लॉक" उद्धरण में है क्योंकि आप तकनीकी रूप से WinForms GUI थ्रेड को ब्लॉक नहीं कर सकते हैं । हां, अगर आप lockWinForms GUI थ्रेड का उपयोग करते हैं, तो यह अभी भी संदेशों को पंप करेगा , आपके सोचने के बावजूद कि यह "अवरुद्ध" है। यह।

यह बहुत दुर्लभ मामलों में विचित्र मुद्दों का कारण बन सकता है। lockउदाहरण के लिए, एक कारण जब आप कभी भी पेंटिंग का उपयोग नहीं करना चाहते हैं । लेकिन यह एक फ्रिंज और जटिल मामला है; हालाँकि मैंने देखा है कि यह पागल मुद्दों का कारण है। इसलिए मैंने इसे संपूर्णता के लिए नोट किया।

Question 3

"पास" मापदंडों में चर कैप्चर का उपयोग करें।

var x = rawData;
Task.Run(() =>
{
    // Do something with 'x'
});

आप rawDataसीधे भी उपयोग कर सकते हैं, लेकिन आपको सावधान रहना चाहिए, यदि आप rawDataकिसी कार्य के बाहर के मूल्य को बदलते हैं (उदाहरण के लिए एक forलूप में एक पुनरावृत्ति) तो यह कार्य के अंदर के मूल्य को भी बदल देगा।

Question 4

अब से आप भी कर सकते हैं:

Action<int> action = (o) => Thread.Sleep(o);
int param = 10;
await new TaskFactory().StartNew(action, param)

Question 5

मुझे पता है कि यह एक पुराना धागा है, लेकिन मैं एक समाधान साझा करना चाहता था जिसे मैंने स्वीकार कर लिया था क्योंकि स्वीकृत पोस्ट का अभी भी एक मुद्दा है।

समस्या:

जैसा कि अलेक्जेंड्रे सेवेरिनो द्वारा बताया गया है, अगर param(नीचे फ़ंक्शन में) फ़ंक्शन कॉल के तुरंत बाद बदलता है, तो आपको कुछ अप्रत्याशित व्यवहार मिल सकता है MethodWithParameter।

Task.Run(() => MethodWithParameter(param));

मेरा समाधान:

इस पर ध्यान देने के लिए, मैंने कोड की निम्नलिखित पंक्ति की तरह कुछ और लिखना समाप्त कर दिया:

(new Func<T, Task>(async (p) => await Task.Run(() => MethodWithParam(p)))).Invoke(param);

इसने मुझे इस तथ्य के बावजूद पैरामीटर को सुरक्षित रूप से अतुल्यकालिक रूप से उपयोग करने की अनुमति दी कि कार्य शुरू करने के बाद पैरामीटर बहुत जल्दी बदल गया (जो पोस्ट किए गए समाधान के साथ समस्या का कारण बना)।

इस दृष्टिकोण का उपयोग करते हुए, param(मूल्य प्रकार) इसके मूल्य में पारित हो जाता है, इसलिए भले ही async विधि paramपरिवर्तनों के बाद चलती है , कोड की यह रेखा चलने pपर जो कुछ भी मूल्य paramथा।

Question 6

बस Task.Run का उपयोग करें

var task = Task.Run(() =>
{
    //this will already share scope with rawData, no need to use a placeholder
});

या, यदि आप इसे एक विधि में उपयोग करना चाहते हैं और बाद में कार्य का इंतजार कर रहे हैं

public Task<T> SomethingAsync<T>()
{
    var task = Task.Run(() =>
    {
        //presumably do something which takes a few ms here
        //this will share scope with any passed parameters in the method
        return default(T);
    });

    return task;
}

Question 7

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

for (int i = 0; i < 300; i++)
{
    Task.Run(() => {
        var x = ComputeStuff(datavector, i); // value of i was incorrect
        var y = ComputeMoreStuff(x);
        // ...
    });
}

मुझे बाहरी इटर्चर को बदलने और एक गेट के साथ इसके मूल्य को स्थानीयकृत करने के लिए काम करने के लिए मिला।

for (int ii = 0; ii < 300; ii++)
{
    System.Threading.CountdownEvent handoff = new System.Threading.CountdownEvent(1);
    Task.Run(() => {
        int i = ii;
        handoff.Signal();

        var x = ComputeStuff(datavector, i);
        var y = ComputeMoreStuff(x);
        // ...

    });
    handoff.Wait();
}

Question 8

आइडिया ऊपर दिए सिग्नल की तरह इस्तेमाल करने से बचना है। एक संरचना में अंतर मूल्यों को पंप करना उन मूल्यों को बदलने से रोकता है (संरचना में)। मुझे निम्न समस्या थी: DoSomething (i) कहा जाता था से पहले लूप var i बदल जाएगा (i) लूप के अंत में वेतन वृद्धि हुई थी () => DoSomething (i, i i) कहा जाता था)। संरचनाओं के साथ यह अब नहीं होता है। खोजने के लिए गंदा बग: DoSomething (i, i i) बहुत अच्छा लग रहा है, लेकिन यह सुनिश्चित करने के लिए कि क्या यह हर बार i के लिए एक अलग मान के साथ नहीं मिलता है (या i = 100 के साथ सिर्फ 100 बार), इसलिए -> संरचना

struct Job { public int P1; public int P2; }
…
for (int i = 0; i < 100; i++) {
    var job = new Job { P1 = i, P2 = i * i}; // structs immutable...
    Task.Run(() => DoSomething(job));
}