Zählt GNU / Linux Prozesse und Threads zusammen, wenn ich ihre Anzahl beschränke?

Ich möchte die Anzahl der Prozesse pro Benutzer auf meinem Computer mit /etc/security/limits.confund den Wert nproc begrenzen.

Ich habe hier gelesen , dass Linux nicht zwischen Prozessen und Threads unterscheidet.

Mein aktuelles nproc-Limit pro Benutzer beträgt 1024, aber wenn dies auch Threads enthält, ist es aus meiner Sicht zu niedrig. Die Manpage limits.conferwähnt nur "Prozess" für nproc und sonst nichts.

// bearbeite // Beispielcode in C ++ mit Boost // g ++ -o boost_thread boost_thread.cpp -lboost_thread

#include <unistd.h>
#include <iostream>
#include <boost/thread.hpp>
using namespace std;

int counter;

void print_thread(int i) {
    counter++;
    cout << "thread(" << i << ") counter " << counter << "\n";
    sleep(5);
    counter--;
}

int main() {
    int i = 0;
    int max = 1000000;

    while (i < max) {
        boost::thread(print_thread, i);
        i++;
    }

    return 0;
}

Test (einige Zeilen entfernt):

$ ulimit -u
1024
$ ./thread 
...
...
...
thread(828) counter 828
thread(829) counter 829
thread(830) counter 830
thread(831) counter 831
thread(832) counter 832
thread(610) counter thread(833833) counter 834

thread(834) counter 835
thread(835) counter 836
thread(836) counter 837
thread(837) counter 838
thread(838) counter 839
thread(839) counter 840
thread(840) counter 841
thread(841) counter 842
thread(842) counter 843
thread(843) counter 844
thread(844) counter 845
thread(845) counter 846
thread(846) counter 847
thread(847) counter 848
terminate called after throwing an instance of 'boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::thread_resource_error> >'
  what():  boost::thread_resource_error
Aborted (core dumped)

Mein Laptop verwendet im Leerlauf ca. 130 Prozesse. Daher unterscheidet nproc oder Linux im weiteren Sinne nicht zwischen Prozessen und Threads. Das erscheint mir vernünftig, denn Threads könnten auch anstrengend sein, nicht nur Prozesse.

Das nprocLimit, über das Sie sprechen, gilt für ausführbare Entitäten. Daher werden Threads (und damit Prozesse, die sie enthalten) begrenzt . Jeder Prozess hat mindestens einen Thread (das Primärgewinde), so dass nur noch Fäden werden können ausgeführt werden . Genau genommen sind Prozesse nicht "lauffähig".

Diese Antwort erklärt den wirklichen Unterschied zwischen Threads und Prozessen unter Linux.

Ich habe den Code in Dayas Antwort getestet (auch sleep(1);im Thread-Code hinzugefügt ) und im Gegensatz zu ihm (?!) Habe ich das Limit erreicht, als zu viele Threads erstellt wurden: pthread_create()kehrte zurück EAGAIN. In der pthread_create(3)Dokumentation wird Folgendes zu diesem Fehler angegeben:

EAGAIN

Es wurden nicht genügend Ressourcen zum Erstellen eines anderen Threads oder eine vom System auferlegte Begrenzung der Anzahl der Threads festgestellt. Der letztere Fall kann auf zwei Arten auftreten: Das RLIMIT_NPROC-Soft-Resource-Limit (festgelegt über setrlimit (2)), das die Anzahl der Prozesse für eine echte Benutzer-ID begrenzt, wurde erreicht. oder das systemweite Limit des Kernels für die Anzahl der Threads / proc / sys / kernel / threads-max wurde erreicht.

Ich sehe keine Erwähnung eines bestimmten Pro-Thread-Limits in der Kernelquelle , ich sehe nur RLIMIT_NPROCdort, welches Limit Sie in limits.conf(mit nproc) ulimit -uoder ändern können setrlimit(2).

ulimit begrenzt nur die Anzahl der Prozesse. Daher ein Wertesatz mit

ulimit -u 1024

begrenzt die Anzahl der Prozesse.

eg.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void* test(void *ptr){
   return 0;
}



int main()
{
        pthread_t thread[50];
        int i=0;

      for(i=0;i<50;i++){
      if(!pthread_create( &thread[i], NULL,test,NULL))
         printf("%d ",i);

       }


      for(i=0;i<50;i++)
       pthread_join( thread[i], NULL);
       return 0;
}

ulimit einstellen und prüfen

lab@x:/tmp$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 20
file size               (blocks, -f) unlimited
pending signals                 (-i) 16382
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) unlimited
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
lab@x:/tmp$ 
lab@x:/tmp$ 
lab@x:~$ cd /home/x
lab@x:/home/x$ ./thread 
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 lab@x:/home/x$ 
lab@x:/home/x$ 
lab@x:/home/x$ ulimit -u 10
lab@x:/home/x$ 

Prozesslimit ist auf 10 eingestellt

lab@x:/home/x$ ./thread 
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 lab@x:/home/x$ 
lab@x:/home/x$ 

Hier können 50 Threads erstellt werden.