tiempo - tareas asincronas c#

¿Es correcto esperar la misma tarea de varios subprocesos? ¿Es seguro esperar el subproceso?

Question

¿Es seguro esperar el hilo? Parece que la clase de tarea es segura para subprocesos, por lo que supongo que esperarla también es segura para subprocesos pero no he encontrado confirmación en ningún lado. También es la seguridad de subprocesos un requisito para un moderador personalizado. Me refiero a los métodos IsCompleted, GetAwaiter, etc. Es decir, si esos métodos no son seguros para subprocesos, ¿esperará que sean seguros para subprocesos? Sin embargo, no espero necesitar un camarero personalizado pronto.

Un ejemplo de escenario de usuario: digamos que tengo una tarea en segundo plano que devuelve un resultado de forma asíncrona, que luego se utiliza desde varios subprocesos:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace scratch1
{
class Foo
{
Task<int> _task;
public Foo()
{
_task = Task.Run(async () => { await Task.Delay(5000); return 5; });
}
// Called from multiple threads
public async Task<int> Bar(int i)
{
return (await _task) + i;
}
}
class Program
{
public static void Main(string[] args)
{
Foo foo = new Foo();
List<Task> tasks = new List<Task>();
foreach (var i in Enumerable.Range(0, 100))
{
tasks.Add(Task.Run(async () => { Console.WriteLine(await foo.Bar(i)); }));
}
Task.WaitAll(tasks.ToArray());
}
}
}

Answer 1

Como mencionaste, await es lo suficientemente delgado como para no ver hilos en primer lugar.

El código asociado con await (el código generado por el compilador dentro de la máquina de estado y las clases de soporte en el BCL) solo se ejecutará en un subproceso a la vez. (Puede cambiar a un subproceso diferente al volver de la espera, pero la ejecución anterior ya habrá finalizado)

La seguridad real del hilo depende del objeto que está esperando.
Debe tener una forma segura de subprocesos para agregar devoluciones de llamada (o await dos veces a la vez puede romperse).

Además, debe llamar a la devolución de llamada exactamente una vez, o puede romper la máquina de estados. (en particular, si ejecuta su devolución de llamada en dos subprocesos al mismo tiempo, las cosas irán terriblemente mal)

Task es segura para subprocesos.