Chạy song song hai tác vụ không đồng bộ và thu thập kết quả trong .NET 4.5

Tôi đã cố gắng trong một thời gian để có được thứ mà tôi nghĩ sẽ đơn giản làm việc với .NET 4.5

Tôi muốn loại bỏ hai tác vụ đang chạy dài cùng lúc và thu thập
kết quả theo cách tốt nhất C # 4.5 (RTM)

Những điều sau đây hoạt động nhưng tôi không thích nó vì:

• Tôi muốn Sleeptrở thành một phương thức không đồng bộ để nó có thể awaitcác phương thức khác
• Nó chỉ trông vụng về với Task.Run()
• Tôi không nghĩ rằng điều này thậm chí đang sử dụng bất kỳ tính năng ngôn ngữ mới nào cả!

Mã làm việc:

public static void Go()
{
    Console.WriteLine("Starting");

    var task1 = Task.Run(() => Sleep(5000));    
    var task2 = Task.Run(() => Sleep(3000));

    int totalSlept = task1.Result + task2.Result;

    Console.WriteLine("Slept for a total of " + totalSlept + " ms");
}

private static int Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    Thread.Sleep(ms);
    Console.WriteLine("Sleeping for " + ms + " FINISHED");
    return ms;
}

Mã không hoạt động:

Cập nhật: Điều này thực sự hoạt động và là cách chính xác để làm điều đó, vấn đề duy nhất là Thread.Sleep

Mã này không hoạt động vì lệnh gọi Sleep(5000)bắt đầu ngay tác vụ đang chạy nên Sleep(1000)không chạy cho đến khi nó hoàn thành. Điều này đúng cho dù Sleeplà asyncvà tôi không sử dụng awaithoặc gọi điện thoại .Resultquá sớm.

Tôi nghĩ có lẽ có một cách nào đó để gỡ lỗi không chạy Task<T>bằng cách gọi một asyncphương thức để sau đó tôi có thể gọi Start()hai tác vụ, nhưng tôi không thể tìm ra cách lấy một Task<T>phương thức không đồng bộ.

public static void Go()
{
    Console.WriteLine("Starting");

    var task1 = Sleep(5000);    // blocks
    var task2 = Sleep(1000);

    int totalSlept = task1.Result + task2.Result;

    Console.WriteLine("Slept for " + totalSlept + " ms");
}

private static async Task<int> Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    Thread.Sleep(ms);
    return ms;
}

Bạn nên sử dụng Task.Delay thay vì Sleep để lập trình không đồng bộ và sau đó sử dụng Task.WhenAll để kết hợp các kết quả tác vụ. Các nhiệm vụ sẽ chạy song song.

public class Program
    {
        static void Main(string[] args)
        {
            Go();
        }
        public static void Go()
        {
            GoAsync();
            Console.ReadLine();
        }
        public static async void GoAsync()
        {

            Console.WriteLine("Starting");

            var task1 = Sleep(5000);
            var task2 = Sleep(3000);

            int[] result = await Task.WhenAll(task1, task2);

            Console.WriteLine("Slept for a total of " + result.Sum() + " ms");

        }

        private async static Task<int> Sleep(int ms)
        {
            Console.WriteLine("Sleeping for {0} at {1}", ms, Environment.TickCount);
            await Task.Delay(ms);
            Console.WriteLine("Sleeping for {0} finished at {1}", ms, Environment.TickCount);
            return ms;
        }
    }

async Task<int> LongTask1() { 
  ...
  return 0; 
}

async Task<int> LongTask2() { 
  ...
  return 1; 
}

...
{
   Task<int> t1 = LongTask1();
   Task<int> t2 = LongTask2();
   await Task.WhenAll(t1,t2);
   //now we have t1.Result and t2.Result
}

Trong khi Sleepphương pháp của bạn Thread.Sleeplà không đồng bộ , thì không. Toàn bộ ý tưởng của async là sử dụng lại một luồng duy nhất, không bắt đầu nhiều luồng. Bởi vì bạn đã chặn sử dụng một cuộc gọi đồng bộ tới Thread.Sleep, nó sẽ không hoạt động.

Tôi cho rằng đó Thread.Sleeplà sự đơn giản hóa những gì bạn thực sự muốn làm. Việc triển khai thực tế của bạn có thể được mã hóa dưới dạng các phương thức không đồng bộ không?

Nếu bạn cần chạy nhiều cuộc gọi chặn đồng bộ, tôi nghĩ rằng hãy tìm ở nơi khác!

Để trả lời điểm này:

Tôi muốn Sleep là một phương thức không đồng bộ để nó có thể chờ các phương thức khác

bạn có thể viết lại Sleephàm như thế này:

private static async Task<int> Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    var task = Task.Run(() => Thread.Sleep(ms));
    await task;
    Console.WriteLine("Sleeping for " + ms + "END");
    return ms;
}

static void Main(string[] args)
{
    Console.WriteLine("Starting");

    var task1 = Sleep(2000);
    var task2 = Sleep(1000);

    int totalSlept = task1.Result +task2.Result;

    Console.WriteLine("Slept for " + totalSlept + " ms");
    Console.ReadKey();
}

chạy mã này sẽ xuất ra:

Starting
Sleeping for 2000
Sleeping for 1000
*(one second later)*
Sleeping for 1000END
*(one second later)*
Sleeping for 2000END
Slept for 3000 ms

Đó là cuối tuần bây giờ!

    public async void Go()
    {
        Console.WriteLine("Start fosterage...");

        var t1 = Sleep(5000, "Kevin");
        var t2 = Sleep(3000, "Jerry");
        var result = await Task.WhenAll(t1, t2);

        Console.WriteLine($"My precious spare time last for only {result.Max()}ms");
        Console.WriteLine("Press any key and take same beer...");
        Console.ReadKey();
    }

    private static async Task<int> Sleep(int ms, string name)
    {
            Console.WriteLine($"{name} going to sleep for {ms}ms :)");
            await Task.Delay(ms);
            Console.WriteLine("${name} waked up after {ms}ms :(";
            return ms;
    }

Bài báo này đã giúp giải thích rất nhiều điều. Nó ở dạng FAQ.

Câu hỏi thường gặp về Async / Await

Phần này giải thích tại sao lại Thread.Sleepchạy trên cùng một chủ đề gốc - dẫn đến sự nhầm lẫn ban đầu của tôi.

Từ khóa “async” có khiến việc gọi một phương thức vào hàng đợi ThreadPool không? Để tạo một chủ đề mới? Để phóng tàu tên lửa lên sao Hỏa?

Không. Và không. Xem các câu hỏi trước. Từ khóa “async” cho trình biên dịch biết rằng “await” có thể được sử dụng bên trong phương thức, như vậy phương thức có thể tạm dừng tại một điểm đang chờ và việc thực thi của nó được tiếp tục không đồng bộ khi phiên bản chờ hoàn tất. Đây là lý do tại sao trình biên dịch đưa ra cảnh báo nếu không có "chờ" bên trong một phương thức được đánh dấu là "không đồng bộ".