Task.Run với (các) Tham số?

Tôi đang làm việc trong một dự án mạng đa tác vụ và tôi là người mới Threading.Tasks. Tôi đã thực hiện một đơn giản Task.Factory.StartNew()và tôi tự hỏi làm thế nào tôi có thể làm điều đó với Task.Run()?

Đây là mã cơ bản:

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

Tôi đã xem xét System.Threading.Tasks.Tasktrong Trình duyệt đối tượng và tôi không thể tìm thấy Action<T>tham số like. Chỉ Actioncó voidtham số và không có loại .

Chỉ có 2 thứ giống nhau: static Task Run(Action action)và static Task Run(Func<Task> function)nhưng không thể đăng (các) tham số với cả hai.

Vâng, tôi biết tôi có thể tạo ra một phương pháp mở rộng đơn giản cho nó nhưng câu hỏi chính của tôi là chúng tôi có thể viết nó vào dòng duy nhất với Task.Run()?

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

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

Biên tập

Do nhu cầu phổ biến, tôi phải lưu ý rằng trình Taskkhởi chạy sẽ chạy song song với luồng gọi. Giả sử mặc định TaskSchedulerđiều này sẽ sử dụng .NET ThreadPool. Dù sao đi nữa, điều này có nghĩa là bạn cần tính đến bất kỳ (các) tham số nào được chuyển đến Taskcó khả năng được nhiều luồng truy cập cùng một lúc, làm cho chúng ở trạng thái chia sẻ. Điều này bao gồm việc truy cập chúng trên chuỗi gọi.

Trong đoạn mã trên của tôi, trường hợp đó được thực hiện hoàn toàn tranh luận. Chuỗi là bất biến. Đó là lý do tại sao tôi sử dụng chúng làm ví dụ. Nhưng nói rằng bạn không sử dụng String...

Một giải pháp là sử dụng asyncvà await. Điều này, theo mặc định, sẽ nắm bắt SynchronizationContextluồng đang gọi và sẽ tạo ra một phần tiếp theo cho phần còn lại của phương thức sau khi gọi tới awaitvà gắn nó vào phần đã tạo Task. Nếu phương thức này đang chạy trên chuỗi WinForms GUI thì nó sẽ thuộc loại WindowsFormsSynchronizationContext.

Phần tiếp theo sẽ chạy sau khi được đăng trở lại phần đã chụp SynchronizationContext- chỉ một lần nữa theo mặc định. Vì vậy, bạn sẽ trở lại chuỗi mà bạn đã bắt đầu sau awaitcuộc gọi. Bạn có thể thay đổi điều này theo nhiều cách khác nhau, đặc biệt là sử dụng ConfigureAwait. Nói tóm lại, phần còn lại của phương pháp đó sẽ không tiếp tục cho đến khi sau khi các Taskđã hoàn thành trên thread khác. Nhưng luồng gọi sẽ tiếp tục chạy song song, không chỉ là phần còn lại của phương thức.

Việc chờ đợi này để hoàn tất việc chạy phần còn lại của phương thức có thể mong muốn hoặc không. Nếu không có gì trong phương thức đó sau này truy cập vào các tham số được truyền đến Taskmà bạn có thể không muốn sử dụng await.

Hoặc có thể bạn sử dụng các tham số đó sau này trong phương thức. Không có lý do gì để awaitngay lập tức vì bạn có thể tiếp tục làm việc một cách an toàn. Hãy nhớ rằng, bạn có thể lưu trữ giá trị Tasktrả về trong một biến và awaittrên đó sau này - ngay cả trong cùng một phương thức. Ví dụ, một khi bạn cần truy cập các tham số đã truyền một cách an toàn sau khi thực hiện một số công việc khác. Một lần nữa, bạn không cần phải awaitở Taskbên phải khi bạn chạy nó.

Tuy nhiên, một cách đơn giản để làm cho chuỗi này an toàn đối với các tham số được truyền đến Task.Runlà thực hiện điều này:

Đầu tiên bạn phải trang trí RunAsyncbằng async:

private async void RunAsync()

Lưu ý quan trọng

Tốt hơn là phương thức được đánh dấu không được trả về giá trị vô hiệu, như tài liệu liên kết đã đề cập. Ngoại lệ phổ biến cho điều này là các trình xử lý sự kiện chẳng hạn như nhấp vào nút và tương tự. Chúng phải trả về giá trị vô hiệu. Nếu không, tôi luôn cố gắng trả về một hoặc khi sử dụng . Đó là một thực hành tốt vì một số lý do.async TaskTask<TResult>async

Bây giờ bạn có thể awaitchạy Tasknhư bên dưới. Bạn không thể sử dụng awaitmà không có 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

Vì vậy, nói chung, nếu bạn thực awaithiện nhiệm vụ, bạn có thể tránh coi các tham số được truyền vào như một tài nguyên được chia sẻ tiềm năng với tất cả các cạm bẫy của việc sửa đổi thứ gì đó từ nhiều luồng cùng một lúc. Ngoài ra, hãy cẩn thận với việc đóng cửa . Tôi sẽ không trình bày sâu về những vấn đề đó nhưng bài viết được liên kết thực hiện rất tốt.

Ghi chú bên lề

Hơi lạc đề một chút, nhưng hãy cẩn thận khi sử dụng bất kỳ loại "chặn" nào trên chuỗi GUI của WinForms do nó được đánh dấu bằng [STAThread]. Sử dụng awaitsẽ không chặn, nhưng đôi khi tôi thấy nó được sử dụng kết hợp với một số loại chặn.

"Block" nằm trong dấu ngoặc kép vì về mặt kỹ thuật, bạn không thể chặn luồng GUI WinForms . Có, nếu bạn sử dụng locktrên chuỗi WinForms GUI, nó sẽ vẫn bơm thông báo, mặc dù bạn nghĩ rằng nó bị "chặn". Nó không thể.

Điều này có thể gây ra các vấn đề kỳ lạ trong một số trường hợp rất hiếm. lockVí dụ, một trong những lý do bạn không bao giờ muốn sử dụng khi vẽ tranh. Nhưng đó là một trường hợp ngoài lề và phức tạp; tuy nhiên tôi đã thấy nó gây ra các vấn đề điên rồ. Vì vậy, tôi ghi nhận nó vì lợi ích hoàn chỉnh.

Sử dụng bắt biến để "chuyển vào" các tham số.

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

Bạn cũng có thể sử dụng rawDatatrực tiếp nhưng bạn phải cẩn thận, nếu bạn thay đổi giá trị rawDatabên ngoài của một tác vụ (ví dụ: một trình lặp trong forvòng lặp) thì nó cũng sẽ thay đổi giá trị bên trong của tác vụ.

Từ bây giờ bạn cũng có thể:

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

Tôi biết đây là một chủ đề cũ, nhưng tôi muốn chia sẻ một giải pháp mà tôi đã phải sử dụng vì bài đăng được chấp nhận vẫn gặp sự cố.

Vấn đề:

Như đã chỉ ra bởi Alexandre Severino, nếu param(trong hàm bên dưới) thay đổi ngay sau lệnh gọi hàm, bạn có thể nhận được một số hành vi không mong muốn trong MethodWithParameter.

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

Giải pháp của tôi:

Để giải thích cho điều này, tôi đã viết một cái gì đó giống như dòng mã sau:

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

Điều này cho phép tôi sử dụng tham số không đồng bộ một cách an toàn mặc dù thực tế là tham số đã thay đổi rất nhanh sau khi bắt đầu tác vụ (điều này gây ra sự cố với giải pháp đã đăng).

Sử dụng cách tiếp cận này, param(kiểu giá trị) nhận giá trị của nó, vì vậy ngay cả khi phương thức không đồng bộ chạy sau các paramthay đổi, psẽ có bất kỳ giá trị nào paramcó khi dòng mã này chạy.

Chỉ cần sử dụng Task.Run

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

Hoặc, nếu bạn muốn sử dụng nó trong một phương thức và chờ tác vụ sau

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

Không rõ vấn đề ban đầu có phải là vấn đề tương tự mà tôi gặp phải hay không: muốn tối đa hóa các luồng CPU khi tính toán bên trong vòng lặp trong khi vẫn giữ nguyên giá trị của trình vòng lặp và giữ nội tuyến để tránh truyền hàng tấn biến cho một hàm worker.

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

Tôi đã làm việc này bằng cách thay đổi trình vòng lặp bên ngoài và bản địa hóa giá trị của nó bằng một cổng.

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

Ý tưởng là tránh sử dụng một Tín hiệu như trên. Việc bơm các giá trị int vào một cấu trúc sẽ ngăn các giá trị đó thay đổi (trong cấu trúc). Tôi đã gặp sự cố sau: vòng lặp var tôi sẽ thay đổi trước khi DoSomething (i) được gọi (tôi đã tăng lên ở cuối vòng lặp trước khi () => DoSomething (i, i i) được gọi). Với các cấu trúc, điều đó không xảy ra nữa. Lỗi khó tìm: DoSomething (i, i i) trông rất tuyệt, nhưng không bao giờ chắc chắn liệu nó có được gọi mỗi lần với một giá trị khác nhau cho i (hoặc chỉ 100 lần với i = 100), do đó -> 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));
}