top - ¿Número máximo de hilos por proceso en Linux?

ver hilos de un proceso linux

Question

¿Cuál es el número máximo de subprocesos que puede crear un proceso en Linux?

¿Cómo (si es posible) se puede modificar este valor?

Answer 1

100k hilos apropiados en linux:

ulimit -s 256
ulimit -i 120000
echo 120000 > /proc/sys/kernel/threads-max
echo 600000 > /proc/sys/vm/max_map_count
echo 200000 > /proc/sys/kernel/pid_max
./100k-pthread-create-app

Actualización 2018 de @Thomas, en sistemas systemd:

/etc/systemd/logind.conf: UserTasksMax=100000

Answer 2

@dragosrsupercool

Linux no usa la memoria virtual para calcular el máximo de subprocesos, sino el ram físico instalado en el sistema

 max_threads = totalram_pages / (8 * 8192 / 4096);

http://kavassalis.com/2011/03/linux-and-the-maximum-number-of-processes-threads/

kernel / fork.c

/* The default maximum number of threads is set to a safe
* value: the thread structures can take up at most half
* of memory.
*/
max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);

Entonces, el hilo máximo es diferente entre cada sistema, ya que el ram instalado puede ser de diferentes tamaños, sé que Linux no necesita aumentar la memoria virtual, porque en 32 bits obtuvimos 3 GB de espacio de usuario y 1 GB para el kernel, en 64 bits obtuvimos 128 TB de memoria virtual, eso sucede en Solaris, si desea aumentar la memoria virtual que necesita para agregar espacio de intercambio.

Answer 3

Depende de su sistema, simplemente escriba un programa de muestra [creando procesos en un bucle] y verifique usando ps axo pid, ppid, rss, vsz, nlwp, cmd. Cuando ya no pueda crear subprocesos, compruebe el recuento de nlwp [nlwp es el número de subprocesos] voila, obtuvo su respuesta infalible en lugar de leer los libros.

Answer 4

En términos prácticos, el límite generalmente está determinado por el espacio de pila. Si cada hilo obtiene una pila de 1 MB (no puedo recordar si ese es el valor predeterminado en Linux), entonces un sistema de 32 bits se quedará sin espacio de direcciones después de 3000 hilos (suponiendo que el último gb está reservado para el núcleo) .

Sin embargo, lo más probable es que experimente un rendimiento terrible si utiliza más de unas pocas docenas de subprocesos. Tarde o temprano, obtienes demasiada sobrecarga de cambio de contexto, demasiada sobrecarga en el programador, etc. (Crear una gran cantidad de subprocesos hace poco más que consumir mucha memoria. Pero muchos de los subprocesos con trabajo real lo harán más lento ya que luchan por el tiempo de CPU disponible)

¿Qué estás haciendo donde este límite es incluso relevante?

Answer 5

Esto es INCORRECTO decir que LINUX no tiene subprocesos separados por límite de proceso.

Linux implementa el número máximo de hilos por proceso indirectamente !!

number of threads = total virtual memory / (stack size*1024*1024)

Por lo tanto, el número de subprocesos por proceso se puede aumentar al aumentar la memoria virtual total o al disminuir el tamaño de la pila. Pero, reducir demasiado el tamaño de la pila puede provocar un fallo del código debido al desbordamiento de la pila, mientras que la memoria virtual máxima es igual a la memoria de intercambio.

Compruebe su máquina:

Memoria virtual total: ulimit -v (el valor predeterminado es ilimitado, por lo tanto, debe aumentar la memoria de intercambio para aumentar esto)

Tamaño total de la pila: ulimit -s (el valor predeterminado es 8Mb)

Comando para aumentar estos valores:

ulimit -s newvalue
ulimit -v newvalue

* Reemplace el nuevo valor con el valor que desea poner como límite.

Referencias:

http://dustycodes.wordpress.com/2012/02/09/increasing-number-of-threads-per-process/

Answer 6

Límite de conteo de hilos:

$ cat /proc/sys/kernel/threads-max

Cómo se calcula:

max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);

y: el tamaño de página x86_64 (PAGE_SIZE) es 4K; Como todas las otras arquitecturas, x86_64 tiene una pila de kernel para cada hilo activo. Estas pilas de hilos son THREAD_SIZE (2 * PAGE_SIZE) grandes;

por mempages:

cat /proc/zoneinfo | grep spanned | awk ''{totalpages=totalpages+$2} END {print totalpages}'';

así que en realidad el número no está relacionado con la limitación del tamaño de la pila de memoria de hilos ( ulimit -s ).

PS: la limitación de la pila de memoria de subprocesos es 10M en mi rhel VM, y para la memoria de 1.5G, ¿esta VM solo puede pagar 150 subprocesos?

Answer 7

Linux no tiene un límite de subprocesos por proceso, solo un límite en el número total de procesos en el sistema (los subprocesos son esencialmente procesos con un espacio de direcciones compartido en Linux) que puede ver de la siguiente manera:

cat /proc/sys/kernel/threads-max

El valor predeterminado es el número de páginas de memoria / 4. Puedes aumentar esto como:

echo 100000 > /proc/sys/kernel/threads-max

También hay un límite en el número de procesos (y, por lo tanto, en subprocesos) que un solo usuario puede crear, consulte ulimit/getrlimit para obtener detalles sobre estos límites.

Answer 8

Para cualquiera que vea esto ahora, en sistemas systemd (en mi caso, específicamente Ubuntu 16.04) hay otro límite impuesto por el parámetro pids.max de cgroup.

Esto se establece en 12,288 de forma predeterminada, y se puede anular en /etc/systemd/logind.conf

Se siguen aplicando otros consejos, incluidos pids_max, threads-max, max_maps_count, ulimits, etc.

Answer 9

Para establecer de forma permanente,

vim /etc/sysctl.conf

y añadir

kernel.threads-max = "value"

Answer 10

Para recuperarlo:

cat /proc/sys/kernel/threads-max

Para configurarlo:

echo 123456789 > /proc/sys/kernel/threads-max

123456789 = # de hilos

Answer 11

Podemos ver el número máximo de hilos definidos en el siguiente archivo en Linux

cat / proc / sys / kernel / threads-max

(O)

sysctl -a | grep hilos-max

Answer 12

Probablemente no debería importar. Obtendrá un rendimiento mucho mejor al diseñar su algoritmo para usar un número fijo de subprocesos (por ejemplo, 4 u 8 si tiene 4 u 8 procesadores). Puede hacer esto con colas de trabajo, IO asíncronas o algo así como libevent.

Answer 13

Puede ver el valor actual en el siguiente comando: cat / proc / sys / kernel / threads-max

También puede establecer el valor como

echo 100500> / proc / sys / kernel / threads-max

El valor que establezca se comparará con las páginas RAM disponibles. Si las estructuras de subprocesos ocupan más de 1/8 de las páginas RAM disponibles, el subproceso máximo se reduciría en consecuencia.

Answer 14

Sí, para aumentar el número de hilos necesita aumentar la memoria virtual o disminuir el tamaño de la pila. En Raspberry Pi no encontré una forma de aumentar la memoria virtual, si disminuía el tamaño de la pila de 8MB a 1MB, posiblemente obtendría más de 1000 subprocesos por proceso, pero disminuiría el tamaño de la pila con el comando "ulimit -s" Hacer esto para todos los hilos. Por lo tanto, mi solución fue usar la instancia de "pthread_t" "clase de subproceso" porque pthread_t me permitió establecer el tamaño de pila para cada subproceso. Finalmente, estoy disponible para archivar más de 1000 subprocesos por proceso en Raspberry Pi, cada uno con 1 MB de pila.

Answer 15

Use la biblioteca de I / O sin bloqueo de nbio o lo que sea, si necesita más hilos para hacer llamadas de E / S que bloquean

Answer 16

verifique el tamaño de pila por hilo con ulimit, en mi caso Redhat Linux 2.6:

 ulimit -a
...
stack size (kbytes, -s) 10240

Cada uno de sus hilos obtendrá esta cantidad de memoria (10 MB) asignada para su pila. Con un programa de 32 bits y un espacio de direcciones máximo de 4 GB, ¡eso es un máximo de solo 4096MB / 10MB = 409 hilos! El código de programa en menos, menos espacio en el montón probablemente llevará a un máximo observado. de 300 hilos.

Debería poder aumentar esto compilando y ejecutando en 64 bits o configurando ulimit -s 8192 o incluso ulimit -s 4096. Pero si esto es recomendable es otra discusión ...