Pregunta Cómo y cuándo usar `async` y` await`


Desde mi punto de vista, una de las cosas principales que async y await Qué hacer es hacer que el código sea fácil de escribir y leer, pero los está usando igual que los hilos de fondo de desove para realizar una lógica de larga duración?

Actualmente estoy probando el ejemplo más básico. He agregado algunos comentarios en línea. ¿Puedes aclararlo por mí?

// I don't understand why this method must be marked as `async`.
private async void button1_Click(object sender, EventArgs e)
{
    Task<int> access = DoSomethingAsync();
    // task independent stuff here

    // this line is reached after the 5 seconds sleep from 
    // DoSomethingAsync() method. Shouldn't it be reached immediately? 
    int a = 1; 

    // from my understanding the waiting should be done here.
    int x = await access; 
}

async Task<int> DoSomethingAsync()
{
    // is this executed on a background thread?
    System.Threading.Thread.Sleep(5000);
    return 1;
}

726
2018-01-22 09:29


origen


Respuestas:


Cuando usas async y await el compilador genera una máquina de estado en el fondo.

Aquí hay un ejemplo en el que espero poder explicar algunos de los detalles de alto nivel que están sucediendo:

public async Task MyMethodAsync()
{
    Task<int> longRunningTask = LongRunningOperationAsync();
    // independent work which doesn't need the result of LongRunningOperationAsync can be done here

    //and now we call await on the task 
    int result = await longRunningTask;
    //use the result 
    Console.WriteLine(result);
}

public async Task<int> LongRunningOperationAsync() // assume we return an int from this long running operation 
{
    await Task.Delay(1000); // 1 second delay
    return 1;
}

OK, entonces, ¿qué pasa aquí?

  1. Task<int> longRunningTask = LongRunningOperationAsync(); comienza a ejecutar LongRunningOperation

  2. El trabajo independiente se lleva a cabo supongamos que el hilo principal (ID del hilo = 1) luego await longRunningTask es alcanzado.

    Ahora, si el longRunningTask no ha terminado y todavía está funcionando, MyMethodAsync() volverá a su método de llamada, por lo que el hilo principal no se bloquea. Cuando el longRunningTask hecho, un hilo del ThreadPool (puede ser cualquier hilo) volverá a MyMethodAsync() en su contexto anterior y continuar la ejecución (en este caso, imprimir el resultado a la consola).

Un segundo caso sería que el longRunningTask ya ha terminado su ejecución y el resultado está disponible. Al alcanzar el await longRunningTask ya tenemos el resultado, por lo que el código continuará ejecutándose en el mismo hilo. (en este caso, imprimir el resultado a la consola). Por supuesto, este no es el caso para el ejemplo anterior, donde hay una Task.Delay(1000) involucrado.


546
2017-11-14 18:55



Además de las otras respuestas, eche un vistazo a espera (referencia C #)

y más específicamente en el ejemplo incluido, explica su situación un poco

El siguiente ejemplo de Windows Forms ilustra el uso de await en un   método asíncrono, WaitAsynchronouslyAsync. Contraste el comportamiento de ese   método con el comportamiento de WaitSynchronously. Sin esperar   operador aplicado a una tarea, WaitSynchronously se ejecuta de forma sincronizada   a pesar del uso del modificador asíncrono en su definición y una llamada a   Thread. Sleep en su cuerpo.

private async void button1_Click(object sender, EventArgs e)
{
    // Call the method that runs asynchronously.
    string result = await WaitAsynchronouslyAsync();

    // Call the method that runs synchronously.
    //string result = await WaitSynchronously ();

    // Display the result.
    textBox1.Text += result;
}

// The following method runs asynchronously. The UI thread is not
// blocked during the delay. You can move or resize the Form1 window 
// while Task.Delay is running.
public async Task<string> WaitAsynchronouslyAsync()
{
    await Task.Delay(10000);
    return "Finished";
}

// The following method runs synchronously, despite the use of async.
// You cannot move or resize the Form1 window while Thread.Sleep
// is running because the UI thread is blocked.
public async Task<string> WaitSynchronously()
{
    // Add a using directive for System.Threading.
    Thread.Sleep(10000);
    return "Finished";
}

126
2018-01-22 09:39



Desde mi punto de vista, una de las cosas principales que se sincronizan y aguardan es hacer que el código sea fácil de escribir y leer.

Ellos deben hacer asincrónico código fácil de escribir y leer, sí.

¿Es lo mismo que engendrar hilos de fondo para realizar una lógica de larga duración?

De ningún modo.

// No entiendo por qué este método debe marcarse como "async".

los async palabra clave habilita await palabra clave. Entonces cualquier método usando await debe estar marcado async.

// esta línea se alcanza después de los 5 segundos de suspensión del método DoSomethingAsync (). ¿No debería ser alcanzado inmediatamente?

No porque async los métodos no se ejecutan en otro subproceso por defecto.

// ¿esto se ejecuta en un hilo de fondo?

No.


Puedes encontrar mi async/await intro servicial. los documentos oficiales de MSDN también son inusualmente buenos (particularmente el GRIFO sección), y el async equipo sacó un excelente Preguntas más frecuentes.


105
2018-01-22 13:17



Explicación

Aquí hay un ejemplo rápido de async / await en un nivel alto. Hay muchos más detalles para considerar más allá de esto.

Nota: Task.Delay(1000) simula hacer trabajo por 1 segundo. Creo que es mejor pensar en esto como esperar una respuesta de un recurso externo. Dado que nuestro código está esperando una respuesta, el sistema puede establecer la tarea de ejecución a un lado y volver a ella una vez que haya finalizado. Mientras tanto, puede hacer otro trabajo en ese hilo.

En el siguiente ejemplo, el primer bloque está haciendo exactamente eso. Comienza todas las tareas de inmediato (el Task.Delay líneas) y los pone a un lado. El código se detendrá en el await a línea hasta que se complete el retraso de 1 segundo antes de pasar a la línea siguiente. Ya que b, c, dy e todo comenzó a ejecutarse casi a la misma hora que a (debido a la falta de la espera), deberían terminar más o menos al mismo tiempo en este caso.

En el siguiente ejemplo, el segundo bloque está comenzando una tarea y esperando que termine (eso es await lo hace) antes de comenzar las tareas siguientes. Cada iteración de esto toma 1 segundo. los await está pausando el programa y esperando el resultado antes de continuar. Esta es la principal diferencia entre el primer y el segundo bloque.

Ejemplo

Console.WriteLine(DateTime.Now);

// This block takes 1 second to run because all
// 5 tasks are running simultaneously
{
    var a = Task.Delay(1000);
    var b = Task.Delay(1000);
    var c = Task.Delay(1000);
    var d = Task.Delay(1000);
    var e = Task.Delay(1000);

    await a;
    await b;
    await c;
    await d;
    await e;
}

Console.WriteLine(DateTime.Now);

// This block takes 5 seconds to run because each "await"
// pauses the program until the task finishes
{
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
    await Task.Delay(1000);
}
Console.WriteLine(DateTime.Now);

SALIDA:

5/24/2017 2:22:50 PM
5/24/2017 2:22:51 PM (First block took 1 second)
5/24/2017 2:22:56 PM (Second block took 5 seconds)

Información adicional sobre SynchronizationContext

Nota: Aquí es donde las cosas se ponen un poco confusas, así que si me equivoco en algo, por favor corrígeme y actualizaré la respuesta. Es importante tener una comprensión básica de cómo funciona esto, pero puedes salir adelante sin ser un experto siempre y cuando nunca uses ConfigureAwait(false), aunque es probable que pierda alguna oportunidad de optimización, supongo.

Hay un aspecto de esto que hace que el concepto async / await sea algo más difícil de captar. Ese es el hecho de que en este ejemplo, todo esto sucede en el mismo hilo (o al menos lo que parece ser el mismo hilo en lo que respecta a SynchronizationContext). Por defecto, await restablecerá el contexto de sincronización del subproceso original en el que se estaba ejecutando. Por ejemplo, en ASP.NET tiene un HttpContext que está vinculado a un hilo cuando entra una solicitud. Este contexto contiene cosas específicas para la solicitud Http original, como el objeto Request original que tiene cosas como lenguaje, dirección IP, encabezados, etc. Si cambia los hilos a la mitad del procesamiento de algo, podría terminar tratando de extraer información de este objeto en un HttpContext diferente que podría ser desastroso. Si sabe que no usará el contexto para nada, puede elegir "no importarle". Esto básicamente permite que su código se ejecute en un hilo separado sin traer el contexto alrededor.

¿Cómo lo logras? Por defecto, el await a; En realidad, el código es suponer que DESEA capturar y restaurar el contexto:

await a; //Same as the line below
await a.ConfigureAwait(true);

Si desea permitir que el código principal continúe en un nuevo hilo sin el contexto original, simplemente use falso en lugar de verdadero para que sepa que no necesita restaurar el contexto.

await a.ConfigureAwait(false);

Después de que el programa finalice en pausa, continuará potencialmente en un hilo completamente diferente con un contexto diferente. De aquí surgiría la mejora del rendimiento: podría continuar en cualquier hilo disponible sin tener que restaurar el contexto original con el que comenzó.

¿Esto es confuso? ¡Demonios si! ¿Puedes averiguarlo? ¡Probablemente! Una vez que tenga una comprensión de los conceptos, continúe con las explicaciones de Stephen Cleary, que tienden a orientarse más hacia alguien con una comprensión técnica de async / await ya.


82
2018-05-26 14:55



Mostrando las explicaciones anteriores en acción en un programa de consola simple -

class Program
{
    static void Main(string[] args)
    {
        TestAsyncAwaitMethods();
        Console.WriteLine("Press any key to exit...");
        Console.ReadLine();
    }

    public async static void TestAsyncAwaitMethods()
    {
        await LongRunningMethod();
    }

    public static async Task<int> LongRunningMethod()
    {
        Console.WriteLine("Starting Long Running method...");
        await Task.Delay(5000);
        Console.WriteLine("End Long Running method...");
        return 1;
    }
}

Y la salida es:

Starting Long Running method...
Press any key to exit...
End Long Running method...

Así,

  1. Principal inicia el método de larga ejecución a través de TestAsyncAwaitMethods. Eso vuelve inmediatamente sin detener el hilo actual e inmediatamente vemos el mensaje 'Presione cualquier tecla para salir'
  2. Mientras tanto, LongRunningMethod se ejecuta en segundo plano. Una vez que se completa, otro hilo de Threadpool toma este contexto y muestra el mensaje final

Por lo tanto, no hilo está bloqueado.


44
2017-08-13 09:32



Creo que has escogido un mal ejemplo con System.Threading.Thread.Sleep

Punto de una async La tarea es permitir que se ejecute en segundo plano sin bloquear el hilo principal, como hacer un DownloadFileAsync

System.Threading.Thread.Sleep no es algo que se "está haciendo", solo duerme, y por lo tanto, se llega a la siguiente línea después de 5 segundos ...

Lea este artículo, creo que es una gran explicación de async y await concepto: http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx


33
2018-01-22 09:32



Aquí hay un programa de consola rápido para dejar en claro a los que siguen. El método "TaskToDo" es su método de larga ejecución que desea sincronizar. Hacer que funcione Async se realiza mediante el método TestAsync. El método de bucles de prueba solo ejecuta las tareas de "Tarea para hacer" y las ejecuta Async. Puede ver eso en los resultados porque no se completan en el mismo orden desde la ejecución hasta la ejecución; informan al hilo de la interfaz de usuario de la consola cuando se completan. Simplista, pero creo que los ejemplos simplistas resaltan el núcleo del patrón mejor que los ejemplos más involucrados:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace TestingAsync
{
    class Program
    {
        static void Main(string[] args)
        {
            TestLoops();
            Console.Read();
        }

        private static async void TestLoops()
        {
            for (int i = 0; i < 100; i++)
            {
                await TestAsync(i);
            }
        }

        private static Task TestAsync(int i)
        {
            return Task.Run(() => TaskToDo(i));
        }

        private async static void TaskToDo(int i)
        {
            await Task.Delay(10);
            Console.WriteLine(i);
        }
    }
}

16
2017-07-17 15:36



Esta respuesta tiene como objetivo proporcionar información específica para ASP.NET.

Al utilizar async / await en el controlador MVC, es posible aumentar la utilización del grupo de subprocesos y lograr un rendimiento mucho mejor, como se explica en el siguiente artículo,

http://www.asp.net/mvc/tutorials/mvc-4/using-asynchronous-methods-in-aspnet-mvc-4

En las aplicaciones web que ve una gran cantidad de solicitudes simultáneas en   puesta en marcha o tiene una carga de ráfagas (donde la concurrencia aumenta repentinamente),   Hacer que estas llamadas al servicio web sean asincrónicas aumentará   capacidad de respuesta de su aplicación. Una solicitud asincrónica toma el   la misma cantidad de tiempo para procesar como una solicitud sincrónica. Por ejemplo,   si una solicitud realiza una llamada al servicio web que requiere dos segundos para   completo, la solicitud toma dos segundos si se realiza   sincrónica o asíncronamente. Sin embargo, durante una llamada asincrónica,   un hilo no está bloqueado para responder a otras solicitudes mientras   espera a que se complete la primera solicitud. Por lo tanto, asincrónico   las solicitudes evitan la cola de solicitudes y el crecimiento del grupo de subprocesos cuando hay   muchas solicitudes simultáneas que invocan operaciones de larga ejecución.


10
2017-09-08 02:06



Para ser sincero, sigo pensando que la mejor explicación es la del futuro y las promesas en la Wikipedia: http://en.wikipedia.org/wiki/Futures_and_promises

La idea básica es que tienes un conjunto separado de subprocesos que ejecutan tareas de forma asincrónica. Cuando lo usas Sin embargo, el objeto promete que ejecutará la operación en algún momento y le dará el resultado cuando lo solicite. Esto significa que se bloqueará cuando solicite el resultado y no haya finalizado, pero se ejecutará en el grupo de subprocesos de lo contrario.

Desde allí puede optimizar cosas: algunas operaciones se pueden implementar de manera sincronizada y puede optimizar cosas como el archivo I / O y la comunicación de red al agrupar las solicitudes subsiguientes y / o reordenarlas. No estoy seguro de si esto ya está en el marco de tareas de Microsoft, pero si no fuera eso, sería una de las primeras cosas que agregaría.

En realidad, puede implementar el patrón de clasificación futuro con rendimientos en C # 4.0. Si desea saber cómo funciona exactamente, puedo recomendar este enlace que hace un trabajo decente: http://code.google.com/p/fracture/source/browse/trunk/Squared/TaskLib/ . Sin embargo, si comienza a jugar con usted mismo, notará que realmente necesita soporte de idiomas si desea hacer todas las cosas interesantes, que es exactamente lo que hizo Microsoft.


9
2018-01-22 10:16



Todas las respuestas aquí usan Task.Delay () o alguna otra función incorporada asincrónica. Pero aquí está mi ejemplo que no usa ninguna de esas funciones asíncronas:

    // Starts counting to a large numbewr and then immediately displays message "i'm counting...". 
    // Then it waits for task to finish and displays "finished, press any key".
    static void asyncTest ()
    {
        Console.WriteLine("Started asyncTest()");
        Task<long> task = asyncTest_count();
        Console.WriteLine("Started counting, please wait...");
        task.Wait(); // if you comment this line you will see that message "Finished counting" will be displayed before we actually finished counting.
        //Console.WriteLine("Finished counting to " + task.Result.ToString()); // using task.Result seems to also call task.Wait().
        Console.WriteLine("Finished counting.");
        Console.WriteLine("Press any key to exit program.");
        Console.ReadLine();
    }

    static async Task<long> asyncTest_count()
    {
        long k = 0;
        Console.WriteLine("Started asyncTest_count()");
        await Task.Run(() =>
        {
            long countTo = 100000000;
            int prevPercentDone = -1;
            for (long i = 0; i <= countTo; i++)
            {
                int percentDone = (int)(100 * (i / (double)countTo));
                if (percentDone != prevPercentDone)
                {
                    prevPercentDone = percentDone;
                    Console.Write(percentDone.ToString() + "% ");
                }

                k = i;
            }
        });
        Console.WriteLine("");
        Console.WriteLine("Finished asyncTest_count()");
        return k;
    }

8
2017-07-15 08:03



Mira este violín https://dotnetfiddle.net/VhZdLU (y mejorarlo si es posible) para ejecutar un aplicación de consola simple que muestra los usos de Task, Task.WaitAll (), async y await operadores en el mismo programa.

Este violín debe borrar su concepto de ciclo de ejecución.

Aquí está el código de ejemplo

using System;
using System.Threading.Tasks;

public class Program
{
    public static void Main()
    {               
        var a = MyMethodAsync(); //Task started for Execution and immediately goes to Line 19 of the code. Cursor will come back as soon as await operator is met       
        Console.WriteLine("Cursor Moved to Next Line Without Waiting for MyMethodAsync() completion");
        Console.WriteLine("Now Waiting for Task to be Finished");       
        Task.WaitAll(a); //Now Waiting      
        Console.WriteLine("Exiting CommandLine");       
    }

    public static async Task MyMethodAsync()
    {
        Task<int> longRunningTask = LongRunningOperation();
        // independent work which doesn't need the result of LongRunningOperationAsync can be done here
        Console.WriteLine("Independent Works of now executes in MyMethodAsync()");
        //and now we call await on the task 
        int result = await longRunningTask;
        //use the result 
        Console.WriteLine("Result of LongRunningOperation() is " + result);
    }

    public static async Task<int> LongRunningOperation() // assume we return an int from this long running operation 
    {
        Console.WriteLine("LongRunningOperation() Started");
        await Task.Delay(2000); // 2 second delay
        Console.WriteLine("LongRunningOperation() Finished after 2 Seconds");
        return 1;
    }   

}

Rastreo proveniente de la ventana de salida: enter image description here


6
2018-01-24 12:45