Estoy buscando más información sobre cómo evitar la inanición/bloqueo/carrera de subprocesos en una aplicación o servicio que posiblemente podría ejecutar hasta 200 subprocesos simultáneamente en múltiples procesadores/núcleos.
La mayoría de los ejemplos que he encontrado en línea muestran cómo coordinar entre 3 o 4 subprocesos como máximo y estoy planeando una aplicación que tendrá cientos.
He creado aplicaciones que han ejecutado hasta 30 subprocesos, pero cuando voy más allá de eso, me preocupa que algunos subprocesos no obtengan tiempo de CPU, sin mencionar la sincronización.
¿Dónde puedo encontrar algunos artículos y blogs realmente buenos?
¿Cuáles son los mejores libros sobre el tema?
Hay muchos libros y artículos sobre el tema, estoy buscando los más informativos e instructivos, pero no presentados en un lenguaje de ingeniería superior a mi comprensión.
Se agradecen todas las sugerencias.
Solución 1
Hay demasiados escenarios que cubrir, por lo que es imposible responder a su pregunta.
Pero utilizar más subprocesos activos que el número de núcleos suele ser contraproducente. Puede beneficiarse del uso de más subprocesos que la cantidad de núcleos solo si la mayoría de los subprocesos normalmente quieren dormir, por ejemplo, esperando algunas operaciones de IO como la llamada recv() que recibe datos de la red. Incluso en ese caso, desea controlar activamente la cantidad de subprocesos que se ejecutan en paralelo, por lo que iniciar 200 subprocesos con la esperanza de que solo 4 de ellos *quieran* ejecutarse en paralelo si tiene 4 núcleos no es una buena práctica.
Si tiene que ejecutar 200 tareas paralelas que están activas todo el tiempo, entonces es mejor crear solo la misma cantidad de subprocesos que la cantidad de núcleos y dividir las tareas en trabajos pequeños. Estos pequeños trabajos se ejecutan en los subprocesos en el orden que desee, arrojándolos a una cola de trabajos de la cual los subprocesos los extraen uno por uno. Esto ya está cerca de tener su propio programador. Una técnica que a menudo resulta en una solución más sofisticada que la anterior es el uso de subprocesos/rutinas verdes (api ucontext POSIX obsoleta en algunas distribuciones de Linux y API de fibra en Windows).
Al utilizar subprocesos verdes, puede dividir un subproceso en muchos subprocesos verdes y realizar las tareas de conmutación/cooperación entre estos subprocesos verdes explícitamente en el espacio de usuario. Digamos que tienes 4 núcleos. Luego puede iniciar 4 subprocesos y si divide cada subproceso en 100 subprocesos verdes, tendrá 400 subprocesos verdes, pero solo 4 de ellos se ejecutan en paralelo en un momento dado y puede escribir su propio programador porque tiene control sobre la tarea cambia entre los hilos verdes.
Escribir, por ejemplo, un servidor web usando subprocesos verdes tiene el siguiente beneficio: el código para las implementaciones multiproceso normal y asíncrono/subproceso verde puede usar el mismo código de servlet si está bien escrito (porque puede poner el cambio de tareas en su propia implementación de lo contrario llamadas a funciones de bloqueo como funciones de lectura/escritura de socket y la implementación de las mismas llamadas a funciones de bloqueo en modo multiproceso en realidad están llamando a funciones equivalentes del sistema operativo de bloqueo).
コメント