Maksymalna liczba wątków na proces w systemie Linux?

Jaka jest maksymalna liczba wątków, które można utworzyć w procesie pod Linuksem?

Jak (jeśli to możliwe) można zmodyfikować tę wartość?

Linux nie ma osobnego limitu wątków na limit procesów, a jedynie limit całkowitej liczby procesów w systemie (wątki to w zasadzie tylko procesy ze wspólną przestrzenią adresową w systemie Linux), które można wyświetlić w następujący sposób:

cat /proc/sys/kernel/threads-max

Domyślnie jest to liczba stron pamięci / 4. Możesz to zwiększyć w następujący sposób:

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

Istnieje również ograniczenie liczby procesów (a tym samym wątków), które może utworzyć pojedynczy użytkownik, zobacz ulimit/getrlimitszczegóły dotyczące tych ograniczeń.

Błędem jest twierdzenie, że LINUX nie ma osobnych wątków na limit procesu.

Linux implementuje maksymalną liczbę wątków na proces pośrednio !!

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

Tak więc liczbę wątków na proces można zwiększyć, zwiększając całkowitą pamięć wirtualną lub zmniejszając rozmiar stosu. Jednak zbyt duże zmniejszenie rozmiaru stosu może prowadzić do niepowodzenia kodu z powodu przepełnienia stosu, podczas gdy maksymalna pamięć wirtualna jest równa pamięci wymiany.

Sprawdź swoją maszynę:

Całkowita pamięć wirtualna: ulimit -v(domyślnie jest nieograniczona, dlatego musisz zwiększyć pamięć wymiany, aby to zwiększyć)

Całkowity rozmiar stosu: ulimit -s(domyślnie jest to 8 Mb)

Polecenie, aby zwiększyć te wartości:

ulimit -s newvalue

ulimit -v newvalue

* Zastąp nową wartość wartością, którą chcesz ustawić jako limit.

Bibliografia:

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

W praktyce limit jest zwykle określany przez przestrzeń stosu. Jeśli każdy wątek otrzyma stos 1 MB (nie pamiętam, czy jest to domyślny w systemie Linux), w systemie 32-bitowym zabraknie przestrzeni adresowej po 3000 wątków (przy założeniu, że ostatni GB jest zarezerwowany dla jądra) .

Jednak najprawdopodobniej doświadczysz strasznej wydajności, jeśli użyjesz więcej niż kilkudziesięciu wątków. Wcześniej czy później pojawi się zbyt wiele narzutu przełączania kontekstu, zbyt dużego narzutu w harmonogramie i tak dalej. (Utworzenie dużej liczby wątków nie tylko zużywa dużo pamięci. Ale wiele wątków przy faktycznej pracy spowolni cię, gdy będą walczyć o dostępny czas procesora)

Co robisz, gdy ten limit jest nawet istotny?

prawidłowe 100k wątków na Linuksie:

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

Aktualizacja 2018 od @ Thomas, na systemach systemowych:

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

@dragosrsupercool

Linux nie używa pamięci wirtualnej do obliczenia maksymalnej liczby wątków, ale fizyczny RAM zainstalowany w systemie

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

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

jądro / 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);

Tak więc maksymalna liczba wątków różni się w zależności od systemu, ponieważ zainstalowany RAM może mieć różne rozmiary, wiem, że Linux nie musi zwiększać pamięci wirtualnej, ponieważ w 32 bitach mamy 3 GB na miejsce użytkownika i 1 GB na jądro, w wersji 64-bitowej mamy 128 TB pamięci wirtualnej, co dzieje się w systemie Solaris, jeśli chcesz zwiększyć pamięć wirtualną, musisz dodać przestrzeń wymiany.

Aby go odzyskać:

cat /proc/sys/kernel/threads-max

Aby ustawić:

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

123456789 = Liczba wątków

Limit liczby wątków:

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

Jak to jest obliczane:

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

oraz: rozmiar strony x86_64 (PAGE_SIZE) to 4K; Podobnie jak wszystkie inne architektury, x86_64 ma stos jądra dla każdego aktywnego wątku. Te stosy wątków są duże THREAD_SIZE (2 * PAGE_SIZE);

dla wiadomości:

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

tak więc liczba ta nie jest związana z ograniczeniem rozmiaru stosu pamięci wątków ( ulimit -s).

PS: ograniczenie stosu pamięci wątków w mojej maszynie wirtualnej rhel wynosi 10 MB, a dla pamięci 1,5G ta maszyna wirtualna może sobie pozwolić tylko na 150 wątków?

Dla każdego, kto na to teraz patrzy, w systemach systemowych (w moim przypadku, szczególnie Ubuntu 16.04) istnieje inny limit narzucony przez parametr cgroup pids.max.

Domyślnie jest ustawiona na 12 288 i można ją przesłonić w /etc/systemd/logind.conf

Nadal obowiązują inne porady, w tym pids_max, thread-max, max_maps_count, ulimits itp.

sprawdź rozmiar stosu na wątek za pomocą ulimit, w moim przypadku Redhat Linux 2.6:

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

Każdy twój wątek otrzyma taką ilość pamięci (10 MB) przypisaną do stosu. Przy 32-bitowym programie i maksymalnej przestrzeni adresowej 4 GB, to maksymalnie 4096 MB / 10 MB = 409 wątków !!! Minusowy kod programu minus minus sterty prawdopodobnie doprowadzi do zaobserwowanego maks. z 300 wątków.

Powinieneś być w stanie to podnieść, kompilując i uruchamiając na 64bit lub ustawiając ulimit -s 8192 lub nawet ulimit -s 4096. Ale jeśli jest to wskazane, jest kolejna dyskusja ...

To chyba nie powinno mieć znaczenia. Będziesz uzyskiwać znacznie lepszą wydajność, projektując algorytm tak, aby używał stałej liczby wątków (np. 4 lub 8, jeśli masz 4 lub 8 procesorów). Możesz to zrobić za pomocą kolejek roboczych, asynchronicznego We / Wy lub czegoś takiego jak libevent.

Użyj nbio nieblokującej biblioteki we / wy lub cokolwiek innego, jeśli potrzebujesz więcej wątków do wykonywania wywołań tego bloku

Zależy od twojego systemu, po prostu napisz przykładowy program [tworząc procesy w pętli] i sprawdź używając ps axo pid, ppid, rss, vsz, nlwp, cmd. Gdy nie będzie już można tworzyć wątków, sprawdź liczbę nlwp [nlwp to liczba wątków] voila, masz głupią odpowiedź zamiast przechodzić przez książki

Aby ustawić na stałe,

vim /etc/sysctl.conf

i dodaj

kernel.threads-max = "value"

Widzimy maksymalną liczbę wątków zdefiniowanych w poniższym pliku w systemie Linux

cat / proc / sys / kernel / Thread-max

(LUB)

sysctl -a | grep wątki-max

Możesz zobaczyć bieżącą wartość za pomocą następującego polecenia cat / proc / sys / kernel / Thread-max

Możesz także ustawić wartość jak

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

Ustawiona wartość zostanie sprawdzona na podstawie dostępnych stron pamięci RAM. Jeśli struktury wątków zajmują więcej niż 1/8) dostępnych stron pamięci RAM, maksymalna liczba wątków zostanie odpowiednio zmniejszona.

Tak, aby zwiększyć liczbę wątków, musisz zwiększyć pamięć wirtualną lub zmniejszyć rozmiar stosu. W Raspberry Pi nie znalazłem sposobu na zwiększenie pamięci wirtualnej, jeśli zmniejszysz rozmiar stosu z domyślnych 8 MB do 1 MB Prawdopodobnie uzyskasz więcej niż 1000 wątków na proces, ale zmniejszysz rozmiar stosu za pomocą polecenia „ulimit -s” zrób to dla wszystkich wątków. Tak więc moim rozwiązaniem było użycie instancji „pthread_t” „klasa wątku”, ponieważ pthread_t pozwala mi ustawić rozmiar stosu dla każdego wątku. Wreszcie jestem w stanie zarchiwizować ponad 1000 wątków na proces w Raspberry Pi, każdy z 1 MB stosu.