Páginas asíncronas en ASP.NET

[Carlos Admirador]

Hola grupo!!

Jose Manuel Alarcón, en la extinta DotNetMania vía Paco Marín, en el número https://issuu.com/pacomarin3/docs/dnm_041/10 hablaba de Páginas asíncronas en ASP.NET 2.0.

Habla de conceptos interesantes, verdad 100 hilos de ejecución por procesador ?

"La programación asíncrona, como todo buen conocedor de los fundamentos de la plataforma .NET sabe, permite que un proceso disponga de múltiples subprocesos o hilos de ejecución que nos proporcionan la posibilidad de llevar a cabo más de una acción al mismo tiempo o ejecutar acciones en segundo plano. En el caso de las aplicaciones Web ASP.NET, la programación asíncrona se utiliza para mejorar enormemente la eficiencia de las páginas Web que tardan mucho en ejecutarse debido a operaciones de entrada/salida que pueden llegar a ser largas. Esta mejora viene del modo en que Internet Information Server procesa las peticiones de páginas que se realizan por parte de los distintos usuarios.

Un barniz de cómo procesa las peticiones IIS 

IIS solo es capaz de atender un número concreto de peticiones de páginas de manera simultánea, ya que a cada petición le asigna un hilo de ejecución propio. Estos hilos de ejecución los obtiene de un pool o repositorio que contiene una cantidad determinada de ellos. Por defecto se dispone de 100 hilos de ejecución por procesador, aunque esta cantidad es configurable, tal y como se indica en http://www.microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/6b46c077-49c2-40d5-a6bc- 56cdfa79d457.mspx?mfr=true. 

Cuando se alcanza ese límite y todos los hilos están ocupados, IIS encola las nuevas peticiones que lleguen para atenderlas en cuanto le sea posible. Mientras tanto, estas peticiones estarán pendientes y sin ofrecer respuesta a los usuarios. En casos extremos, los usuarios comenzarán a recibir códigos de estado 503 de “servicio no disponible” y no se procesarán las páginas. Cuando una petición termina de ser atendida, su hilo correspondiente se libera y se devuelve al pool y queda disponible para procesar otra petición. En condiciones normales, el tiempo que uno de estos hilos está ocupado es muy pequeño y se pueden atender muchas peticiones prácticamente simultáneas sin problema. Las dificultades comienzan cuando una de nuestras páginas realiza alguna operación que tarda mucho tiempo en ejecutarse. Mientras se ejecuta esta operación larga, el hilo estará bloqueado, y a medida que se realicen peticiones a ésta u otras páginas de ejecución larga quedarán bloqueados más hilos, disminuyendo notablemente la escalabilidad de la aplicación, puesto que no habrá subprocesos disponibles para atender más peticiones. Debemos intentar evitar esta situación en la medida de lo posible. Generalmente, estas operaciones largas se corresponden con operaciones de E/S, como esperar a que se procese una consulta larga en el servidor de datos o acceder a un servicio Web remoto que puede tener problemas de tráfico. 

Todas estas tareas tienen asociados métodos nativos para hacer llamadas asíncronas que podemos utilizar en nuestras páginas con la infraestructura de asincronía de ASP.NET que ahora veremos. Al ejecutar de forma asíncrona las llamadas a esos procesos largos, conseguimos que el subproceso principal que atiende la petición quede liberado y se devuelva al pool para poder atender nuevas peticiones de otros usuarios. Al terminar la ejecución asíncrona, se recupera un hilo del repositorio para devolver los resultados al cliente.


En general, nos beneficiaremos más de la ejecución asíncrona en situaciones en las que el proceso largo se ejecute en otro servidor, como en los ejemplos citados. El motivo es que si lo único que hace nuestro código es esperar a que termine alguna tarea remota en el servidor de datos o en otro servidor Web, mientras se espera en segundo plano el impacto sobre la capacidad de proceso es prácticamente nulo, por lo que devolver el proceso a IIS asegura que se gestionen nuevas peticiones de páginas sin mermar el rendimiento. Sin embargo, si el proceso largo implica realizar una tarea intensiva en nuestro propio servidor (procesar un archivo muy grande o acceder a la base de datos local), liberamos el subproceso para atender nuevas llamadas, pero hay un procedimiento ejecutándose en segundo plano que compite con IIS por los recursos de la máquina. En este caso, tendremos una mayor capacidad de respuesta a peticiones (escalabilidad), pero probablemente el aumento de rendimiento no sea apreciable. Es importante tener claro este concepto."

Qué opinan de Páginas asíncronas en ASP.NET ? cuándo utilizarlas ? casos real world ?

Alguna referencia más:

http://panicoenlaxbox.blogspot.com.es/2010/10/paginas-aspnet-asincronas.html

http://speakingin.net/2014/02/15/que-es-lo-que-no-hay-que-hacer-en-asp-net-y-que-hacer-en-su-lugar/

http://www.variablenotfound.com/2014/06/ejecutar-tareas-en-segundo-plano-en.html

Sería interesante una serie succinctly sobre ello :-)

The Succinctly series

This frustration translated into a deep desire to produce a series of concise technical books that would be targeted at developers working on the Microsoft platform.

We firmly believe, given the background knowledge such developers have, that most topics can be translated into books that are between 50 and 100 pages.

This is exactly what we resolved to accomplish with the Succinctly series. Isn’t everything wonderful born out of a deep desire to change things for the better?

[María NET Developer - Mírame a los ojos]

Estimados.

Aparte de la literatura sobre el tema, no hay mucho ejemplo real world al respecto...

Async Programming : Introduction to Async/Await on ASP.NET

https://msdn.microsoft.com/en-us/magazine/dn802603.aspx

https://blogs.msdn.microsoft.com/rickandy/2009/11/14/should-my-database-calls-be-asynchronous/

https://blogs.msdn.microsoft.com/webdev/2012/11/19/all-about-httpruntime-targetframework/

https://docs.microsoft.com/en-us/aspnet/web-forms/overview/performance-and-caching/using-asynchronous-methods-in-aspnet-45

You might need to increase the HTTP.sys queue limit from the default value of 1,000 to 5,000. If the setting is too low, you may see HTTP.sysreject requests with a HTTP 503 status. To change the HTTP.sys queue limit:

• If your application is using web services or System.NET to communicate with a backend over HTTP you may need to increase theconnectionManagement/maxconnection element. For ASP.NET applications, this is limited by the autoConfig feature to 12 times the number of CPUs. That means that on a quad-proc, you can have at most 12 * 4 = 48 concurrent connections to an IP end point. Because this is tied toautoConfig, the easiest way to increase maxconnection in an ASP.NET application is to setSystem.Net.ServicePointManager.DefaultConnectionLimit programmatically in the from Application_Start method in the global.asax file. See the sample download for an example.
• In .NET 4.5, the default of 5000 for MaxConcurrentRequestsPerCPU should be fine.

[María NET Developer - Mírame a los ojos]

No se encuentran muchos ejemplos REAL WORLD en codeproject o github:

PageAsyncTask task = new PageAsyncTask( BeginInvoke, 
             EndInvoke, EndTimeOutInvoke, null);
      Page.RegisterAsyncTask(task);

var slowTask1 = new _05_PageAsyncTasksSlowTask();
            var slowTask2 = new _05_PageAsyncTasksSlowTask();
            var slowTask3 = new _05_PageAsyncTasksSlowTask();

            PageAsyncTask task1 = new PageAsyncTask(slowTask1.OnBegin, slowTask1.OnEnd, slowTask1.OnTimeOut, null, false);
            PageAsyncTask task2 = new PageAsyncTask(slowTask2.OnBegin, slowTask2.OnEnd, slowTask2.OnTimeOut, null, false);
            PageAsyncTask task3 = new PageAsyncTask(slowTask3.OnBegin, slowTask3.OnEnd, slowTask3.OnTimeOut, null, false);

            RegisterAsyncTask(task1);
            RegisterAsyncTask(task2);
            RegisterAsyncTask(task3);

            Page.ExecuteRegisteredAsyncTasks();

OutputLabel.Text = slowTask1.GetData() + "<br />" + slowTask2.GetData() + "<br />" + slowTask3.GetData();

https://www.codeproject.com/Articles/13948/Practical-NET2-and-C-2-ASP-NET-2-0-Handling-a-page

Nos puede interesar un PageAsyncTaskManagerWrapper ?
https://github.com/webformsmvp/webformsmvp/blob/master/WebFormsMvp/WebFormsMvp/Web/PageAsyncTaskManagerWrapper.cs

o un PageAsyncTaskManager
https://github.com/chtoucas/Narvalo.NET/blob/077cd471bac68d2331d100c8b586cec02d61e777/src/Narvalo.Mvp.Web/Core/PageAsyncTaskManager.cs


REAL WORLD samples ? Demos are cool, but it is time to talk about the real world!

Sería interesante una serie succinctly sobre ello :-)