it-swarm.com.de

Maximale Anzahl von Threads pro Prozess in Linux?

Wie viele Threads können maximal von einem Prozess unter Linux erstellt werden?

Wie (wenn möglich) kann dieser Wert geändert werden?

206
user60008667

Linux hat keine separaten Threads pro Prozesslimit, nur eine Begrenzung der Gesamtzahl der Prozesse im System (Threads sind im Wesentlichen nur Prozesse mit einem gemeinsam genutzten Adressraum unter Linux), die Sie folgendermaßen anzeigen können:

cat /proc/sys/kernel/threads-max

Der Standardwert ist die Anzahl der Speicherseiten/4. Sie können dies wie folgt erhöhen:

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

Die Anzahl der Prozesse (und damit der Threads), die ein einzelner Benutzer erstellen kann, ist ebenfalls begrenzt. Weitere Informationen zu diesen Beschränkungen finden Sie unter ulimit/getrlimit.

213
Robert Gamble

Dies ist falsch, um zu sagen, dass LINUX keine separaten Threads pro Prozesslimit hat. 

Linux implementiert die maximale Anzahl von Threads pro Prozess indirekt !!

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

Daher kann die Anzahl der Threads pro Prozess erhöht werden, indem der gesamte virtuelle Speicher erhöht oder die Stapelgröße verringert wird. Wenn Sie die Stack-Größe zu stark verringern, kann dies zu Code-Fehlern aufgrund eines Stack-Überlaufs führen, während der maximale virtuelle Speicher dem Swap-Speicher entspricht.

Überprüfen Sie Ihre Maschine:

Gesamter virtueller Speicher: ulimit -v (Standardeinstellung ist unbegrenzt. Daher müssen Sie den Swap-Speicher erhöhen, um diesen Speicher zu erhöhen.)

Stack-Gesamtgröße: ulimit -s (Standardeinstellung ist 8 MB)

Befehl zum Erhöhen dieser Werte:

ulimit -s newvalue

ulimit -v newvalue

* Ersetzen Sie den neuen Wert durch den Wert, den Sie als Limit festlegen möchten.

Verweise:

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

62
codersofthedark

In der Praxis wird die Grenze normalerweise durch den Stapelraum bestimmt. Wenn jeder Thread einen 1-MB-Stack erhält (ich kann mich nicht erinnern, ob dies der Standard bei Linux ist), dann wird einem 32-Bit-System nach 3000 Threads der Adressraum ausgehen (vorausgesetzt, dass der letzte GB für den Kernel reserviert ist). .

Wenn Sie jedoch mehr als ein paar Dutzend Threads verwenden, werden Sie höchstwahrscheinlich eine schlechte Leistung erzielen. Früher oder später kommt es zu einem zu hohen Kontext für den Kontextwechsel, zu viel für den Scheduler usw. (Das Erstellen einer großen Anzahl von Threads ist wenig mehr als viel Arbeitsspeicher. Aber viele Threads mit tatsächlichen work zu erledigen, werden Sie verlangsamen, da sie um die verfügbare CPU-Zeit kämpfen.)

Was machen Sie dort, wo dieses Limit überhaupt relevant ist?

42
jalf

100k-Threads unter 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

Update 2018 von @Thomas auf systemd Systemen:

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

@dragosrsupercool

Linux verwendet den virtuellen Speicher nicht zur Berechnung des maximalen Threads, sondern den auf dem System installierten physischen RAM

 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);

Thread max ist also von System zu System unterschiedlich, da der installierte RAM von unterschiedlicher Größe sein kann. Ich weiß, dass Linux den virtuellen Speicher nicht vergrößern muss, da wir auf 32 Bit 3 GB für den Benutzerplatz und 1 GB für den Kernel haben. Bei 64 Bit haben wir 128 TB des virtuellen Speichers. Dies geschieht unter Solaris. Wenn Sie den virtuellen Speicher erhöhen möchten, müssen Sie Swap-Speicher hinzufügen.

13
c4f4t0r

Um es abzurufen:

cat /proc/sys/kernel/threads-max

Um es einzustellen:

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

123456789 = Anzahl der Threads

Thread-Zählgrenze:

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

Wie es berechnet wird:

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

und: x86_64-Seitengröße (PAGE_SIZE) ist 4K; Wie alle anderen Architekturen verfügt auch x86_64 über einen Kernel-Stack für jeden aktiven Thread. Diese Threadstapel sind THREAD_SIZE (2 * PAGE_SIZE) groß;

für Mempages:

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

die Anzahl steht also in keinem Zusammenhang mit der Beschränkung der Threadstapelgröße (ulimit -s).

P.S: Die Threadspeicherstapelbeschränkung beträgt 10 MB in meiner Rhel-VM, und für 1,5 G-Speicher kann diese VM nur 150 Threads leisten.

7
Albert Kong

Es sollte wahrscheinlich keine Rolle spielen. Sie werden eine viel bessere Leistung erhalten, wenn Sie Ihren Algorithmus so planen, dass er eine feste Anzahl von Threads verwendet (z. B. 4 oder 8, wenn Sie 4 oder 8 Prozessoren haben). Sie können dies mit Arbeitswarteschlangen, asynchroner E/A oder ähnlichem wie libevent tun. 

4
twk

Verwenden Sie die nbio Nicht blockierende E/A-Bibliothek oder was auch immer, wenn Sie weitere Threads benötigen, um E/A-Aufrufe dieses Blocks durchzuführen

3
wefeqfw

Überprüfen Sie die Stackgröße pro Thread mit ulimit, in meinem Fall Redhat Linux 2.6: 

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

Jedem Ihrer Threads wird diese für seinen Stack zugewiesene Speichermenge (10 MB) zugewiesen. Bei einem 32-Bit-Programm und einem maximalen Adressraum von 4 GB sind dies nur 4096 MB/10 MB = 409 Threads. Minus-Programmcode, minus Heap-Space führt wahrscheinlich zu einem beobachteten max. von 300 Fäden. 

Sie sollten in der Lage sein, dies durch Kompilieren und Ausführen von 64bit zu erhöhen oder ulimit -s 8192 oder sogar ulimit -s 4096 einzustellen.

3
Axel Podehl

Abhängig von Ihrem System, schreiben Sie einfach ein Beispielprogramm [durch Erstellen von Prozessen in einer Schleife] und überprüfen Sie es mit ps axo pid, ppid, rss, vsz, nlwp, cmd. Wenn es nicht mehr möglich ist, Threads zu erstellen, überprüfen Sie nlwp count [nlwp ist die Anzahl der Threads] voila, Sie haben Ihre idiotensichere Antwort erhalten, anstatt durch Bücher zu gehen

2
resultsway

Für jeden, der dies jetzt betrachtet, gibt es auf systemd-Systemen (in meinem Fall speziell für Ubuntu 16.04) einen weiteren Grenzwert, der durch den Parameter cgroup pids.max erzwungen wird.

Dies ist standardmäßig auf 12.288 festgelegt und kann in /etc/systemd/logind.conf überschrieben werden

Andere Hinweise gelten weiterhin, einschließlich pids_max, thread-max, max_maps_count, ulimits usw.

1
Trent Lloyd

Dauerhaft einstellen, 

vim /etc/sysctl.conf

und füge hinzu

kernel.threads-max = "value"
0
Matteo Zocca

Ja, um die Anzahl der Threads zu erhöhen, müssen Sie den virtuellen Speicher vergrößern oder die Stapelgröße verringern. In Raspberry Pi habe ich keine Möglichkeit gefunden, den virtuellen Speicher zu vergrößern, wenn die Stackgröße von standardmäßig 8 MB auf 1 MB verringert wird. Möglicherweise werden mehr als 1000 Threads pro Prozess erzielt, die Stackgröße wird jedoch mit dem Befehl "ulimit -s" verringert mache dies für alle Threads. Meine Lösung war also die Verwendung der "pthread_t" -Instanz "thread class", da mit pthread_t die Stapelgröße für jeden Thread festgelegt werden konnte. Schließlich kann ich mehr als 1000 Threads pro Prozess in Raspberry Pi mit jeweils 1 MB Stack archivieren.

0
Deulis

Wir können die maximale Anzahl von Threads sehen, die in der folgenden Datei in Linux definiert ist

cat/proc/sys/kernel/thread-max

(ODER)

sysctl -a | Grep-Threads-max

Den aktuellen Wert können Sie mit folgendem Befehl sehen: _ _ _ _ cat/proc/sys/kernel/thread-max

Sie können den Wert auch wie einstellen

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

Der von Ihnen eingestellte Wert wird mit den verfügbaren RAM -Seiten verglichen. Wenn die Thread-Strukturen mehr als 1/8 der verfügbaren RAM -Seiten einnehmen, wird Thread-Max entsprechend reduziert.

0
Arif