Apakah GNU / Linux menghitung proses dan utas secara bersamaan ketika saya membatasi jumlahnya?

Saya ingin membatasi jumlah proses per pengguna di komputer saya, dengan /etc/security/limits.confdan nilai nproc.

Saya telah membaca di sini bahwa dosen Linux tidak membedakan antara proses dan utas?

Batas nproc saya saat ini per pengguna adalah 1024, tetapi jika ini juga termasuk utas, terlalu rendah dalam pandangan saya. Halaman manual limits.confhanya menyebutkan "proses" untuk nproc dan tidak ada yang lain.

// edit // kode sampel dalam C ++ dengan 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;
}

tes (menghapus beberapa baris):

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

Laptop saya menggunakan ~ 130 proses saat dalam keadaan idle. Jadi nproc , atau Linux dalam pandangan yang lebih luas, tidak membedakan antara proses dan utas. Yang menurut saya masuk akal, karena utas juga bisa melelahkan, tidak hanya proses.

The nprocbatas Anda berbicara tentang berlaku untuk entitas runnable , itu sehingga membatasi benang (dan oleh karena itu, proses yang mengandung mereka) . Setiap proses memiliki setidaknya satu utas (utas utama), sehingga hanya utas yang dapat dijalankan . Sebenarnya, proses tidak "runnable".

Jawaban ini menjelaskan perbedaan nyata antara utas dan proses di Linux.

Saya menguji kode dalam jawaban daya (juga ditambahkan sleep(1);dalam kode utas) dan tidak seperti dia (?!), Saya mencapai batas ketika terlalu banyak utas dibuat: pthread_create()kembali EAGAIN. The pthread_create(3)dokumentasi mengatakan berikut tentang kesalahan ini:

EAGAIN

Sumber daya yang tidak mencukupi untuk membuat utas lain, atau batasan yang diberlakukan sistem pada jumlah utas ditemui. Kasus terakhir dapat terjadi dalam dua cara: batas sumber daya lunak RLIMIT_NPROC (ditetapkan melalui setrlimit (2)), yang membatasi jumlah proses untuk ID pengguna nyata, tercapai; atau batas sistem kernel pada jumlah utas, / proc / sys / kernel / threads-max, tercapai.

Saya tidak melihat menyebutkan batas per-utas spesifik di sumber kernel , saya hanya melihat di RLIMIT_NPROCsana, yang merupakan batas yang dapat Anda ubah limits.conf(dengan nproc), ulimit -uatau setrlimit(2).

ulimit membatasi jumlah proses saja. Oleh karena itu nilai yang ditetapkan menggunakan

ulimit -u 1024

akan membatasi jumlah proses.

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

atur ulimit dan periksa

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$ 

batas proses diatur ke 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$ 

di sini 50 utas dapat dibuat.