todos - ver procesos de un usuario linux

Hilos vs Procesos en Linux (13)

Recientemente he escuchado a algunas personas decir que en Linux, casi siempre es mejor usar procesos en lugar de subprocesos, ya que Linux es muy eficiente en el manejo de procesos y porque hay muchos problemas (como el bloqueo) asociados con los subprocesos. Sin embargo, sospecho, porque parece que los subprocesos pueden dar un aumento de rendimiento bastante grande en algunas situaciones.

Entonces, mi pregunta es, cuando me enfrento a una situación en la que los subprocesos y los procesos podrían manejarse bastante bien, ¿debo usar procesos o subprocesos? Por ejemplo, si estuviera escribiendo un servidor web, ¿debería usar procesos o subprocesos (o una combinación)?

Érase una vez que había Unix y en este viejo Unix había muchos gastos generales para los procesos, así que lo que hicieron algunas personas inteligentes fue crear hilos, que compartirían el mismo espacio de direcciones con el proceso principal y solo necesitaban un contexto reducido. interruptor, lo que haría que el cambio de contexto sea más eficiente.

En un Linux contemporáneo (2.6.x) no hay mucha diferencia en el rendimiento entre un cambio de contexto de un proceso en comparación con un subproceso (solo el material MMU es adicional para el subproceso). Existe un problema con el espacio de direcciones compartido, lo que significa que un puntero defectuoso en un subproceso puede dañar la memoria del proceso principal u otro subproceso dentro del mismo espacio de direcciones.

Un proceso está protegido por la MMU, por lo que un puntero defectuoso solo causará una señal 11 y no se dañará.

En general, usaría procesos (no mucha sobrecarga de cambio de contexto en Linux, pero protección de memoria debido a MMU), pero pthreads si necesitaría una clase de planificador en tiempo real, que es una taza de té diferente.

¿Por qué crees que los hilos tienen una gran ganancia de rendimiento en Linux? ¿Tienes algún dato para esto, o es solo un mito?

¿Qué tan juntas están tus tareas?

Si pueden vivir independientemente el uno del otro, entonces use los procesos. Si confían el uno en el otro, entonces use hilos. De esa manera puede matar y reiniciar un proceso incorrecto sin interferir con el funcionamiento de las otras tareas.

En mi trabajo reciente con LINUX, una cosa es tener en cuenta las bibliotecas. Si está utilizando subprocesos, asegúrese de que las bibliotecas que pueda usar en todos los subprocesos sean seguras para subprocesos. Esto me quemó un par de veces. Cabe destacar que libxml2 no es seguro para subprocesos fuera de la caja. Se puede compilar con un hilo seguro, pero eso no es lo que se obtiene con la instalación de aptitude.

Eso depende de muchos factores. Los procesos son más pesados que los subprocesos y tienen un mayor costo de inicio y apagado. La comunicación entre procesos (IPC) también es más difícil y más lenta que la comunicación entre hilos.

A la inversa, los procesos son más seguros que los subprocesos, porque cada proceso se ejecuta en su propio espacio de direcciones virtuales. Si un proceso se bloquea o tiene un desbordamiento del búfer, no afecta a ningún otro proceso, mientras que si un subproceso se bloquea, elimina todos los otros subprocesos del proceso, y si un subproceso tiene un desbordamiento del búfer, se abre Un agujero de seguridad en todos los hilos.

Por lo tanto, si los módulos de su aplicación pueden ejecutarse de manera casi independiente con poca comunicación, probablemente debería usar procesos si puede pagar los costos de inicio y apagado. El impacto de rendimiento de IPC será mínimo, y estará un poco más seguro contra errores y agujeros de seguridad. Si necesita todo el rendimiento que puede obtener o tiene una gran cantidad de datos compartidos (como estructuras de datos complejas), vaya con hilos.

La decisión entre el proceso / subproceso depende un poco de a qué lo usará. Uno de los beneficios de un proceso es que tiene un PID y puede eliminarse sin terminar también al padre.

Para un ejemplo del mundo real de un servidor web, apache 1.3 solía soportar solo múltiples procesos, pero en 2.0 añadieron una abstracción para que pueda intercambiar entre ellos. Comments seems estar to acuerdo en que los procesos son más robustos, pero los subprocesos pueden ofrecer un rendimiento un poco mejor (a excepción de las ventanas donde el rendimiento de los procesos apesta y solo se quieren usar subprocesos)

Linux (y de hecho Unix) te da una tercera opción.

Opción 1 - procesos

Cree un archivo ejecutable independiente que maneje una parte (o todas las partes) de su aplicación, e invóquelo por separado para cada proceso, por ejemplo, el programa ejecuta copias de sí mismo para delegar tareas.

Opción 2 - hilos

Cree un ejecutable independiente que se inicie con un solo hilo y cree hilos adicionales para realizar algunas tareas

Opción 3 - tenedor

Solo disponible bajo Linux / Unix, esto es un poco diferente. Un proceso bifurcado realmente es su propio proceso con su propio espacio de direcciones; no hay nada que el niño pueda hacer (normalmente) para afectar el espacio de direcciones de sus padres o hermanos (a diferencia de un hilo), por lo que obtiene una mayor solidez.

Sin embargo, las páginas de la memoria no se copian, se copian en la escritura, por lo que normalmente se utiliza menos memoria de lo que usted podría imaginar.

Considere un programa de servidor web que consta de dos pasos:

Leer datos de configuración y tiempo de ejecución.
Servir solicitudes de página

Si usas hilos, el paso 1 se realizará una vez, y el paso 2 se realizará en varios hilos. Si usó procesos "tradicionales", los pasos 1 y 2 tendrían que repetirse para cada proceso, y la memoria para almacenar la configuración y los datos de tiempo de ejecución se duplicarán. Si usó fork (), entonces puede hacer el paso 1 una vez, y luego fork (), dejando los datos de tiempo de ejecución y la configuración en la memoria, sin tocar, sin copiar.

Así que realmente hay tres opciones.

Linux utiliza un modelo de subprocesos 1-1, con (al núcleo) sin distinción entre procesos y subprocesos: todo es simplemente una tarea ejecutable. *

En Linux, el sistema de clone llamadas clona una tarea, con un nivel configurable de uso compartido, entre los que se encuentran:

CLONE_FILES : comparte la misma tabla de descriptores de archivos (en lugar de crear una copia)
CLONE_PARENT : no establezca una relación padre-hijo entre la nueva tarea y la anterior (de lo contrario, getppid() del hijo = getpid() del padre)
CLONE_VM : comparte el mismo espacio de memoria (en lugar de crear una copia de COW )

fork() llama a clone( compartir menos ) y pthread_create() llama a clone( compartir más ) . **

fork cuesta un poco más que pthread_create debido a la copia de tablas y la creación de asignaciones COW para la memoria, pero los desarrolladores del kernel de Linux han intentado (y han tenido éxito) minimizar estos costos.

Cambiar entre tareas, si comparten el mismo espacio de memoria y varias tablas, será un poco más barato que si no se compartieran, ya que es posible que los datos ya estén cargados en la memoria caché. Sin embargo, el cambio de tareas sigue siendo muy rápido, incluso si no se comparte nada, esto es otra cosa que los desarrolladores del kernel de Linux intentan asegurar (y tener éxito en asegurar).

De hecho, si está en un sistema multiprocesador, no compartir puede ser realmente beneficioso para el rendimiento: si cada tarea se ejecuta en un procesador diferente, la sincronización de la memoria compartida es costosa.

* Simplificado. CLONE_THREAD hace que la entrega de señales se comparta (lo que necesita CLONE_SIGHAND , que comparte la tabla del manejador de señales).

** Simplificado. Existen SYS_fork y SYS_clone , pero en el kernel, sys_fork y sys_clone son envoltorios muy finos alrededor de la misma función do_fork , que a su vez es un envoltorio delgado alrededor de copy_process . Sí, los términos process , thread y task se usan de manera intercambiable en el kernel de Linux ...

Otros han discutido las consideraciones.

Quizás la diferencia importante es que en Windows los procesos son pesados y caros en comparación con los subprocesos, y en Linux la diferencia es mucho menor, por lo que la ecuación se equilibra en un punto diferente.

Para complicar aún más las cosas, existe el almacenamiento local de subprocesos y la memoria compartida Unix.

El almacenamiento local de subprocesos permite que cada subproceso tenga una instancia separada de objetos globales. La única vez que lo usé fue cuando construí un entorno de emulación en linux / windows, para el código de la aplicación que se ejecutó en un RTOS. En el RTOS, cada tarea era un proceso con su propio espacio de direcciones, en el entorno de emulación, cada tarea era un hilo (con un espacio de direcciones compartido). Al usar TLS para cosas como singletons, pudimos tener una instancia separada para cada hilo, al igual que en el entorno RTOS "real".

La memoria compartida puede (obviamente) brindarle los beneficios de rendimiento de tener múltiples procesos para acceder a la misma memoria, pero al costo / riesgo de tener que sincronizar los procesos correctamente. Una forma de hacerlo es hacer que un proceso cree una estructura de datos en la memoria compartida y luego envíe un identificador a esa estructura a través de la comunicación tradicional entre procesos (como una canalización con nombre).

Para la mayoría de los casos preferiría procesos sobre hilos. los subprocesos pueden ser útiles cuando tiene una tarea relativamente más pequeña (sobrecarga del proceso >> tiempo tomado por cada unidad de tarea dividida) y existe la necesidad de compartir la memoria entre ellos. Piense en una gran variedad. También (fuera de tema), tenga en cuenta que si la utilización de la CPU es del 100 por ciento o cercana a ella, no habrá beneficios por el subprocesamiento múltiple o el procesamiento. (De hecho empeorará)

Si necesitas compartir recursos, deberías usar hilos.

También considere el hecho de que los cambios de contexto entre hilos son mucho menos costosos que los cambios de contexto entre procesos.

No veo ninguna razón para ir explícitamente con procesos separados a menos que tenga una buena razón para hacerlo (seguridad, pruebas de rendimiento comprobadas, etc.)

Tendría que estar de acuerdo con lo que has estado escuchando. Cuando xhpl nuestro clúster ( xhpl y similares), siempre obtenemos un rendimiento significativamente mejor con los procesos en subprocesos. </anecdote>

Threads -> Threads comparte un espacio de memoria, es una abstracción de la CPU, es liviano. Procesos -> Los procesos tienen su propio espacio de memoria, es una abstracción de una computadora. Para paralelizar la tarea necesita abstraer una CPU. Sin embargo, las ventajas de usar un proceso sobre un subproceso son la seguridad, la estabilidad, mientras que un subproceso usa menos memoria que el proceso y ofrece menos latencia. Un ejemplo en términos de web sería chrome y firefox. En el caso de Chrome, cada pestaña es un nuevo proceso, por lo que el uso de la memoria de Chrome es mayor que el de Firefox, mientras que la seguridad y la estabilidad proporcionadas son mejores que las de Firefox. La seguridad proporcionada aquí por Chrome es mejor, ya que cada pestaña es un nuevo proceso. Una pestaña diferente no puede penetrar en el espacio de memoria de un proceso determinado.