O GNU / Linux conta processos e encadeamentos quando limito o número deles?

Question

Eu quero limitar o número de processos por usuário na minha máquina, com /etc/security/limits.conf e o valor nproc.

Eu li aqui que o Linux não faz distinguir entre processos e threads?

Meu limite nproc atual por usuário é 1024, mas se isso incluir também threads, ele será muito baixo no meu ponto de vista. O man-page de limits.conf menciona apenas "processo" para nproc e nada mais.

// edite // exemplo de código em C ++ com 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;
}

teste de

(removeu algumas linhas):

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

Meu laptop usa ~ 130 processos enquanto está ocioso. Portanto, nproc , ou Linux em uma visão mais ampla, não separa processos e threads. O que parece razoável para mim, porque os tópicos também poderiam esgotar, não apenas processos.

    

Answer 1

O nproc limite ao qual você está se referindo se aplica a entidades executáveis , portanto, limita os encadeamentos (e, portanto, os processos que os contêm) . Todo processo tem pelo menos um thread (o thread primário), de forma que somente threads podem ser run . Estritamente falando, os processos não são "executáveis".

Esta resposta explica a diferença real entre os segmentos e processos no Linux.

Eu testei o código na resposta do daya (também adicionei sleep(1); no código da thread) e ao contrário dele (?!), eu atingi o limite quando muitos threads foram criados: pthread_create() estava retornando EAGAIN . A documentação de pthread_create(3) diz o seguinte sobre esse erro:

EAGAIN

Insufficient resources to create another thread, or a system-imposed limit on the number of threads was encountered. The latter case may occur in two ways: the RLIMIT_NPROC soft resource limit (set via setrlimit(2)), which limits the number of process for a real user ID, was reached; or the kernel's system-wide limit on the number of threads, /proc/sys/kernel/threads-max, was reached.

Não vejo menção a um limite específico por thread no origem do kernel , vejo apenas RLIMIT_NPROC lá, que é o limite que você pode alterar em limits.conf (com nproc ), ulimit -u ou setrlimit(2) .

    

Answer 2

ulimit limita o número de processos apenas. Portanto, um valor definido usando

ulimit -u 1024

limitará o número de processos.

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

defina ulimit e verifique

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$ 

o limite do processo é definido como 10

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$ 

aqui 50 tópicos podem ser criados.