Виконайте паралельно дві задачі на асинхронізацію та збирайте результати в .NET 4.5

Я деякий час намагався отримати щось, на що думав, що це буде просто працювати з .NET 4.5

Я хочу звільнити одночасно два тривалі завдання та збирати
результати найкращим чином C # 4.5 (RTM)

Наступні роботи, але це мені не подобається, тому що:

• Я хочу Sleepбути асинхронним методом, щоб він міг використовувати awaitінші методи
• Це просто виглядає незграбно Task.Run()
• Я не думаю, що для цього навіть не використовуються нові мовні функції!

Робочий код:

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

Не працює код:

Оновлення: це насправді працює і це правильний спосіб зробити це, єдина проблема - це Thread.Sleep

Цей код не працює, оскільки виклик Sleep(5000)негайно запустити виконану задачу, тому Sleep(1000)не запускається, поки не завершиться. Це вірно , навіть якщо Sleepце asyncі я не використовую awaitабо зателефонувавши по телефону .Resultзанадто рано.

Я подумав, що, можливо, є спосіб отримати не запущений Task<T>, зателефонувавши до asyncметоду, щоб я міг зателефонувати Start()за двома завданнями, але не можу зрозуміти, як отримати Task<T>від виклику методу асинхронізації.

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

Ви повинні використовувати Task.Delay замість Sleep для програмування асинхронізації, а потім використовувати Task.WhenAll для об'єднання результатів завдання. Завдання виконувались б паралельно.

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
}

Хоча ваш Sleepметод асинхронний, Thread.Sleepце не так. Вся ідея async полягає в повторному використанні однієї нитки, а не в запуску декількох потоків. Оскільки ви заблокували використання синхронного дзвінка до Thread.Sleep, це не спрацює.

Я припускаю, що Thread.Sleepце спрощення того, що ви насправді хочете зробити. Чи може ваша реальна реалізація бути кодована як методи асинхронізації?

Якщо вам потрібно запустити кілька синхронних блокуючих дзвінків, погляньте в іншому місці, я думаю!

Щоб відповісти на це питання:

Я хочу, щоб сон був асинхронним методом, щоб він міг чекати інших методів

ви можете, можливо, переписати Sleepфункцію так:

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

Запуск цього коду виведе:

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

Зараз вихідні !

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

Ця стаття допомогла пояснити багато речей. Це в стилі FAQ.

Асинхронізація / чекайте FAQ

Ця частина пояснює, чому Thread.Sleepпрацює на одній оригінальній нитці - це призводить до моєї первісної плутанини.

Чи викликає ключове слово "асинхронізація" виклик методу в чергу до ThreadPool? Щоб створити нову нитку? Для запуску ракетного корабля на Марс?

Ні. Ні. Дивіться попередні запитання. Ключове слово "асинхронізація" вказує компілятору, що "очікувати" може використовуватися всередині методу, таким чином, що метод може призупинити роботу в точці очікування та відновити його виконання асинхронно, коли очікуваний екземпляр завершиться. Ось чому компілятор видає попередження, якщо всередині методу, позначеного як "асинхроніка", немає "очікування".