จำนวนเธรดสูงสุดต่อกระบวนการใน Linux?

จำนวนเธรดสูงสุดที่สามารถสร้างได้โดยกระบวนการภายใต้ Linux คือเท่าใด

จะแก้ไขค่านี้ได้อย่างไร (ถ้าเป็นไปได้)

ลีนุกซ์ไม่ได้มีการแยกเธรดต่อการ จำกัด กระบวนการ, เพียงแค่การ จำกัด จำนวนโพรเซสทั้งหมดในระบบ (เธรดนั้นเป็นเพียงแค่โพรเซสที่มีพื้นที่ที่อยู่ที่ใช้ร่วมกันบน Linux) ซึ่งคุณสามารถดูดังนี้:

cat /proc/sys/kernel/threads-max

ค่าเริ่มต้นคือจำนวนหน้าหน่วยความจำ / 4 คุณสามารถเพิ่มเช่นนี้:

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

นอกจากนี้ยังมีข้อ จำกัด เกี่ยวกับจำนวนกระบวนการ (และเธรดด้วยเหตุนี้) ที่ผู้ใช้รายเดียวอาจสร้างขึ้นดูulimit/getrlimitรายละเอียดเกี่ยวกับข้อ จำกัด เหล่านี้

นี่เป็นเรื่องที่ผิดที่จะบอกว่า LINUX ไม่มีเธรดแยกกันต่อการ จำกัด กระบวนการ

Linux ใช้จำนวนเธรดสูงสุดต่อกระบวนการทางอ้อม !!

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

ดังนั้นจำนวนเธรดต่อกระบวนการสามารถเพิ่มขึ้นได้โดยการเพิ่มหน่วยความจำเสมือนทั้งหมดหรือโดยการลดขนาดสแต็ก แต่การลดขนาดสแต็กมากเกินไปอาจนำไปสู่ความล้มเหลวของรหัสเนื่องจากสแตกล้นในขณะที่หน่วยความจำเสมือนสูงสุดเท่ากับหน่วยความจำสลับ

ตรวจสอบเครื่องของคุณ:

หน่วยความจำเสมือนทั้งหมด: ulimit -v(ค่าเริ่มต้นคือไม่ จำกัด ดังนั้นคุณต้องเพิ่มหน่วยความจำ swap เพื่อเพิ่มสิ่งนี้)

ขนาดสแต็ครวม: ulimit -s(ค่าเริ่มต้นคือ 8Mb)

คำสั่งเพื่อเพิ่มค่าเหล่านี้:

ulimit -s newvalue

ulimit -v newvalue

* แทนที่ค่าใหม่ด้วยค่าที่คุณต้องการให้เป็นขีด จำกัด

อ้างอิง:

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

ในแง่การปฏิบัติข้อ จำกัด มักจะถูกกำหนดโดยพื้นที่สแต็ค หากแต่ละเธรดได้รับสแต็ค 1MB (ฉันจำไม่ได้ว่าเป็นค่าเริ่มต้นบน Linux) จากนั้นระบบ 32- บิตของคุณจะหมดพื้นที่ที่อยู่หลังจาก 3000 เธรด (สมมติว่า gb สุดท้ายถูกสงวนไว้กับเคอร์เนล) .

อย่างไรก็ตามคุณอาจประสบกับประสิทธิภาพที่แย่มากหากคุณใช้เธรดมากกว่าสองสามเธรด ไม่ช้าก็เร็วคุณจะได้รับค่าโสหุ้ยการเปลี่ยนบริบทมากเกินไปค่าใช้จ่ายมากเกินไปในตัวกำหนดตารางเวลาและอื่น ๆ (การสร้างเธรดจำนวนมากจะยิ่งใหญ่กว่าการกินหน่วยความจำเพียงเล็กน้อย แต่เธรดจำนวนมากที่มีงานที่ต้องทำจริงๆ จะทำให้คุณช้าลงขณะที่พวกเขากำลังต่อสู้เพื่อเวลา CPU ที่พร้อมใช้งาน)

คุณกำลังทำอะไรที่ข้อ จำกัด นี้เกี่ยวข้องกับ?

หัวข้อ 100k ที่เหมาะสมบน 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

อัปเดต 2018 จาก @Thomas บนระบบ systemd:

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

@dragosrsupercool

Linux ไม่ได้ใช้หน่วยความจำเสมือนในการคำนวณจำนวนเธรดสูงสุด แต่มีการติดตั้งหน่วยความจำจริงบนระบบ

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

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

เคอร์เนล / 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 จะแตกต่างกันไปในทุกระบบเพราะ RAM ที่ติดตั้งมาจากหลายขนาดฉันรู้ว่า Linux ไม่จำเป็นต้องเพิ่มหน่วยความจำเสมือนเพราะใน 32 บิตเรามี 3 GB สำหรับพื้นที่ผู้ใช้และ 1 GB สำหรับเคอร์เนล บน 64 บิตเราได้หน่วยความจำเสมือน 128 TB ที่เกิดขึ้นบน Solaris ถ้าคุณต้องการเพิ่มหน่วยความจำเสมือนที่คุณต้องเพิ่มพื้นที่สว็อป

วิธีดึงข้อมูล:

cat /proc/sys/kernel/threads-max

วิธีตั้งค่า:

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

123456789 = # ของเธรด

การ จำกัด จำนวนเธรด:

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

มันคำนวณอย่างไร:

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

และ: ขนาดหน้า x86_64 (PAGE_SIZE) คือ 4K; เช่นเดียวกับสถาปัตยกรรมอื่น ๆ ทั้งหมด x86_64 มีเคอร์เนลสแต็กสำหรับทุกเธรดที่ใช้งานอยู่ กลุ่มสแต็กเหล่านี้มีขนาดใหญ่ THREAD_SIZE (2 * PAGE_SIZE)

สำหรับ mempages:

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

ดังนั้นจำนวนที่ไม่เกี่ยวข้องกับข้อ จำกัด ของขนาดหน่วยความจำของสแต็กเธรด ( ulimit -s)

PS: ข้อ จำกัด ของหน่วยความจำของเธรดสแต็กคือ 10M ใน rhel VM ของฉันและสำหรับหน่วยความจำ 1.5G, VM นี้สามารถจ่ายได้ 150 เธรดเท่านั้น?

สำหรับทุกคนที่ดูสิ่งนี้ในระบบ systemd (ในกรณีของฉันโดยเฉพาะ Ubuntu 16.04) มีข้อ จำกัด อื่นบังคับใช้โดยพารามิเตอร์ cgroup pids.max

นี้ถูกตั้งค่าเป็น 12,288 โดยค่าเริ่มต้นและสามารถ overriden ใน /etc/systemd/logind.conf

คำแนะนำอื่น ๆ ยังคงใช้รวมถึง pids_max, threads-max, max_maps_count, ulimits, ฯลฯ

ตรวจสอบขนาด stack ต่อ thread ด้วย ulimit ในกรณีของฉัน Redhat Linux 2.6:

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

แต่ละเธรดของคุณจะได้รับหน่วยความจำจำนวนนี้ (10MB) สำหรับสแต็กของมัน ด้วยโปรแกรม 32 บิตและพื้นที่ที่อยู่สูงสุด 4GB นั่นคือสูงสุดเพียง 4096MB / 10MB = 409 กระทู้ !!! ลบรหัสโปรแกรมลบฮีปพื้นที่อาจนำไปสู่การสูงสุดที่สังเกตได้ จาก 300 หัวข้อ

คุณควรจะสามารถยกระดับสิ่งนี้ได้โดยการคอมไพล์และรันบน 64 บิตหรือตั้งค่า ulimit -s 8192 หรือแม้กระทั่ง ulimit -s 4096 แต่ถ้าแนะนำให้ทำเช่นนี้จะเป็นการสนทนาอื่น ...

มันอาจไม่สำคัญ คุณจะได้รับประสิทธิภาพที่ดีขึ้นมากในการออกแบบอัลกอริทึมของคุณเพื่อใช้จำนวนเธรดที่แน่นอน (เช่น 4 หรือ 8 หากคุณมีโปรเซสเซอร์ 4 หรือ 8) คุณสามารถทำได้ด้วยคิวงานอะซิงโครนัส IO หรือสิ่งอื่นเช่น libevent

ใช้nbio ไลบรารี i / o ที่ไม่มีการบล็อกหรืออะไรก็ตามถ้าคุณต้องการเธรดเพิ่มเติมสำหรับการโทร I / O ที่บล็อกนั้น

ขึ้นอยู่กับระบบของคุณเพียงแค่เขียนโปรแกรมตัวอย่าง [โดยการสร้างกระบวนการในวง] และตรวจสอบการใช้ ps axo pid, ppid, rss, vsz, nlwp, cmd เมื่อไม่สามารถสร้างเธรดได้อีกต่อไปให้ตรวจสอบการนับ nlwp [nlwp คือเธรดตัวเลข] voila คุณจะได้คำตอบที่โง่เขลาแทนที่จะไปถึงหนังสือ

หากต้องการตั้งอย่างถาวร

vim /etc/sysctl.conf

และเพิ่ม

kernel.threads-max = "value"

เราสามารถดูจำนวนสูงสุดของเธรดที่กำหนดไว้ในไฟล์ต่อไปนี้ใน linux

cat / proc / sys / kernel / threads-max

(หรือ)

sysctl -a | grep threads-max

คุณสามารถดูค่าปัจจุบันได้โดย command- cat / proc / sys / kernel / threads-max ต่อไปนี้

คุณสามารถตั้งค่าเช่น

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

ค่าที่คุณตั้งไว้จะถูกตรวจสอบกับหน้า RAM ที่มีอยู่ หากโครงสร้างเธรดมีมากกว่า 1 ใน 8 ของเพจ RAM ที่มีอยู่ thread-max จะลดลงตามลำดับ

ใช่เพื่อเพิ่มจำนวนกระทู้คุณต้องเพิ่มหน่วยความจำเสมือนหรือลดขนาดสแต็ค ใน Raspberry Pi ฉันไม่พบวิธีเพิ่มหน่วยความจำเสมือนถ้าลดขนาดสแต็กจากค่าเริ่มต้น 8MB เป็น 1MB เป็นไปได้ที่อาจได้รับมากกว่า 1,000 เธรดต่อกระบวนการ แต่ลดขนาดสแต็กด้วยคำสั่ง "ulimit -s" ทำสิ่งนี้สำหรับหัวข้อทั้งหมด ดังนั้นทางออกของฉันคือใช้ "pthread_t" อินสแตนซ์ "คลาสเธรด" เนื่องจาก pthread_t ให้ฉันตั้งขนาดสแต็คต่อแต่ละเธรด ในที่สุดฉันก็สามารถเก็บมากกว่า 1,000 เธรดต่อกระบวนการใน Raspberry Pi แต่ละรายการด้วยสแต็ก 1MB