Task.Run ด้วยพารามิเตอร์?

Threading.Tasksผมทำงานในโครงการเครือข่ายแบบมัลติทาสกิ้และฉันใหม่ ฉันใช้งานง่ายTask.Factory.StartNew()และฉันสงสัยว่าจะทำได้Task.Run()อย่างไร?

นี่คือรหัสพื้นฐาน:

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

ฉันตรวจสอบSystem.Threading.Tasks.TaskในObject Browserแล้วไม่พบAction<T>พารามิเตอร์ like มีเพียงActionที่ใช้voidพารามิเตอร์และไม่มีประเภท

มีเพียง 2 สิ่งที่คล้ายกัน: static Task Run(Action action)และstatic Task Run(Func<Task> function)แต่ไม่สามารถโพสต์พารามิเตอร์ด้วยทั้งสองอย่าง

ใช่ฉันรู้ว่าฉันสามารถสร้างวิธีการขยายแบบง่าย ๆ ได้ แต่คำถามหลักของฉันคือเราสามารถเขียนเป็นบรรทัดเดียวด้วยTask.Run()?

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

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

แก้ไข

เนื่องจากความต้องการที่เป็นที่นิยมฉันต้องทราบว่า Taskเปิดตัวจะทำงานควบคู่ไปกับเธรดการโทร สมมติว่าเริ่มต้นนี้จะใช้สุทธิTaskScheduler ThreadPoolอย่างไรก็ตามนี่หมายความว่าคุณต้องคำนึงถึงพารามิเตอร์ใด ๆ ที่ส่งผ่านไปยังTaskเธรดหลายเธรดที่อาจเข้าถึงได้พร้อมกันทำให้เป็นสถานะที่ใช้ร่วมกัน ซึ่งรวมถึงการเข้าถึงบนเธรดการโทร

ในรหัสด้านบนของฉันกรณีนี้ถูกสร้างขึ้นทั้งหมด สตริงไม่เปลี่ยนรูป นั่นเป็นเหตุผลที่ฉันใช้เป็นตัวอย่าง แต่บอกว่าคุณไม่ได้ใช้String...

ทางออกหนึ่งคือการใช้asyncและawait. โดยค่าเริ่มต้นจะจับSynchronizationContextเธรดการโทรและจะสร้างความต่อเนื่องสำหรับส่วนที่เหลือของวิธีการหลังจากการโทรไปที่awaitTaskและแนบไปกับที่สร้างขึ้น หากวิธีนี้ทำงานอยู่ใน 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คล้ายกันด้านล่าง คุณไม่สามารถใช้โดยไม่ต้องawaitasync

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ได้ ใช่ถ้าคุณใช้lockกับเธรด WinForms GUI มันจะยังคงปั๊มข้อความแม้ว่าคุณจะคิดว่า "ถูกบล็อก" ก็ตาม มันไม่ใช่.

ซึ่งอาจทำให้เกิดปัญหาแปลกประหลาดในบางกรณีที่เกิดขึ้นได้ยาก เหตุผลประการหนึ่งที่คุณไม่ต้องการใช้lockเมื่อวาดภาพเป็นต้น แต่นั่นเป็นกรณีที่ซับซ้อนและซับซ้อน อย่างไรก็ตามฉันเห็นว่ามันทำให้เกิดปัญหาที่บ้าคลั่ง ดังนั้นฉันจึงตั้งข้อสังเกตเพื่อความสมบูรณ์

ใช้การจับตัวแปรเพื่อ "ส่งผ่าน" พารามิเตอร์

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

นอกจากนี้คุณยังสามารถใช้ได้rawDataโดยตรง แต่คุณต้องระวังถ้าคุณเปลี่ยนค่าของrawDataภายนอกงาน (เช่นตัววนซ้ำในforลูป) มันจะเปลี่ยนค่าภายในงานด้วย

จากนี้คุณยังสามารถ:

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

ฉันรู้ว่านี่เป็นกระทู้เก่า แต่ฉันต้องการแบ่งปันวิธีแก้ปัญหาที่ฉันต้องใช้เนื่องจากโพสต์ที่ได้รับการยอมรับยังคงมีปัญหา

ปัญหา:

ในฐานะที่เป็นแหลมออกโดย Alexandre Severino ถ้าparam(ในการทำงานดังต่อไปนี้) MethodWithParameterการเปลี่ยนแปลงในไม่ช้าหลังจากการเรียกฟังก์ชั่นที่คุณอาจได้รับพฤติกรรมที่ไม่คาดคิดบางอย่างใน

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

ทางออกของฉัน:

เพื่ออธิบายสิ่งนี้ฉันลงเอยด้วยการเขียนโค้ดบรรทัดต่อไปนี้:

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

สิ่งนี้ทำให้ฉันสามารถใช้พารามิเตอร์แบบอะซิงโครนัสได้อย่างปลอดภัยแม้ว่าพารามิเตอร์จะเปลี่ยนเร็วมากหลังจากเริ่มงาน (ซึ่งทำให้เกิดปัญหากับโซลูชันที่โพสต์)

เมื่อใช้วิธีนี้param(ชนิดค่า) จะได้รับค่าที่ส่งผ่านดังนั้นแม้ว่าเมธอด async จะทำงานหลังจากparamการเปลี่ยนแปลงpจะมีค่าใดก็ตามที่paramมีเมื่อโค้ดบรรทัดนี้ทำงาน

เพียงแค่ใช้ 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;
}

ไม่ชัดเจนว่าปัญหาเดิมเป็นปัญหาเดียวกันกับที่ฉันมีหรือไม่: ต้องการเพิ่มเธรด CPU สูงสุดในการคำนวณภายในลูปในขณะที่รักษาค่าของตัววนซ้ำและรักษาอินไลน์เพื่อหลีกเลี่ยงการส่งผ่านตัวแปรจำนวนมากไปยังฟังก์ชันผู้ปฏิบัติงาน

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();
}

แนวคิดคือหลีกเลี่ยงการใช้ Signal เหมือนข้างบน การปั๊มค่า int ลงในโครงสร้างจะป้องกันไม่ให้ค่าเหล่านั้นเปลี่ยนแปลง (ในโครงสร้าง) ฉันมีปัญหาต่อไปนี้: loop var ฉันจะเปลี่ยนก่อนที่จะเรียก DoSomething (i) (ฉันถูกเพิ่มขึ้นที่ส่วนท้ายของลูปก่อน () => DoSomething (i, i i) ถูกเรียก) ด้วยโครงสร้างจะไม่เกิดขึ้นอีกต่อไป จุดบกพร่องที่น่าค้นหา: DoSomething (i, i i) ดูดี แต่ไม่แน่ใจว่าถูกเรียกทุกครั้งด้วยค่าที่แตกต่างกันสำหรับ i (หรือแค่ 100 ครั้งกับ i = 100) ดังนั้น -> struct

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));
}