दिलचस्प पोस्ट
ngpattern के साथ प्राकृतिक इनपुट नंबर को मान्य करें जावास्क्रिप्ट का उपयोग करते हुए नई लाइनों वाले एक JSON स्ट्रिंग से बचने के लिए कैसे? विशिष्ट तत्व को जाने पर स्पर्श करते समय स्क्रॉल करना अक्षम करें प्रोजेक्ट ऑलर के साथ स्पीड की तुलना: सी बनाम पाइथन बनाम एर्लंग बनाम हास्केल फोन को जल्दी से 180 डिग्री घूमते हुए कैमरा पूर्वावलोकन उल्टा हो जाता है एएसपी.नेट और वेब टूल्स 2015 (आरसी 1 अपडेट 1) के स्थापित होने के बाद विजुअल स्टूडियो 2015 त्रुटि "ऑब्जेक्ट रेफ़रलेंस ऑब्जेक्ट के एक उदाहरण के लिए सेट नहीं है" यूनिट टेस्ट कैसे लिखूं? क्या हमें जावास्क्रिप्ट में ईलेमेंट्स BickClassName मिलता है? क्या उद्देश्य-सी में कुछ शाब्दिक शब्दकोश या सरणी सिंटैक्स है? गतिशील रूप से कोणीय 2 में एचटीएमएल टेम्पलेट लोड करें एचटीएमएल फार्म (2 जीबी से अधिक) के बावजूद बड़ी फ़ाइल अपलोड जावास्क्रिप्ट ऑब्जेक्ट सदस्य हैं जो प्रोटोटाइप हैं क्योंकि एरेज सभी क्लास इंस्टेंसेस द्वारा साझा किए जाते हैं मैं एक एंड्रॉइड ऐप कैसे प्रोग्राम "रीस्टार्ट" करूँ? क्रोम एक्सटेंशन सामग्री स्क्रिप्ट में, मुझे दस्तावेज़ की प्रतीक्षा करनी चाहिए। दस्तावेज को प्रोसेस करने से पहले ही? डबल में वैज्ञानिक न होने से कैसे बचें?

लिनक्स में प्रति प्रक्रिया की अधिकतम संख्या है?

लिनक्स के तहत एक प्रक्रिया द्वारा बनाया जा सकता है जो अधिकतम धागे की संख्या है?

कैसे (यदि संभव हो) क्या यह मान संशोधित किया जा सकता है?

Solutions Collecting From Web of "लिनक्स में प्रति प्रक्रिया की अधिकतम संख्या है?"

लिनक्स में प्रति प्रक्रिया सीमा अलग थ्रेड नहीं है, बस प्रणाली पर कुल प्रक्रियाओं की एक सीमा (थ्रेड अनिवार्य रूप से सिर्फ लिनक्स पर एक साझा पता स्थान के साथ प्रक्रिया होती है) जिसे आप इस तरह देख सकते हैं:

cat /proc/sys/kernel/threads-max 

डिफ़ॉल्ट स्मृति पृष्ठों / 4 की संख्या है आप इसे इस तरह बढ़ा सकते हैं:

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

प्रक्रियाओं की संख्या (और इसलिए थ्रेड्स) की एक सीमा भी है जो एक ही उपयोगकर्ता बना सकता है, इन सीमाओं के बारे में विवरण के लिए ulimit/getrlimit देखें।

यह कहना गलत है कि लिनक्स में प्रति प्रक्रिया सीमा अलग थ्रेड नहीं है।

लिनक्स अप्रत्यक्ष प्रति प्रक्रिया प्रति धागे की अधिकतम संख्या लागू करता है !!

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

इस प्रकार, प्रति प्रक्रिया में धागे की संख्या को कुल आभासी स्मृति में वृद्धि या स्टैक आकार घटकर बढ़ाया जा सकता है। लेकिन, स्टैक आकार को कम करने से स्टैक अतिप्रवाह के कारण कोड विफलता हो सकती है, जबकि अधिकतम वर्चुअल मेमोरी स्वैप मेमोरी के बराबर होती है।

आपको मशीन की जांच करें:

कुल आभासी स्मृति: ulimit -v (डिफ़ॉल्ट असीमित है, इस प्रकार आपको इसे बढ़ाने के लिए स्वैप मेमोरी में वृद्धि करने की आवश्यकता है)

कुल स्टैक आकार: ulimit -s (डिफ़ॉल्ट 8 एमबी है)

इन मूल्यों को बढ़ाने के लिए कमांड:

 ulimit -s newvalue ulimit -v newvalue 

* मूल्य के साथ नया मान बदलें जिसे आप सीमा के रूप में रखना चाहते हैं

संदर्भ:

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

व्यावहारिक रूप से, सीमा को आमतौर पर स्टैक स्पेस द्वारा निर्धारित किया जाता है। यदि प्रत्येक थ्रेड को 1 एमबी स्टैक मिलता है (मुझे याद नहीं है कि वह लिनक्स पर डिफ़ॉल्ट है), तो आप 3000 थ्रेड्स के बाद एक 32-बिट सिस्टम पता स्थान से बाहर निकल जाएंगे (यह सोचते हुए कि अंतिम जीबी कर्नेल के लिए आरक्षित है) ।

हालांकि, यदि आप कुछ दर्जन धागे से अधिक का उपयोग करते हैं तो आपको सबसे अधिक भयानक प्रदर्शन का अनुभव होगा। जल्दी या बाद में, आप बहुत ज्यादा संदर्भ-स्विचिंग ओवरहेड प्राप्त करते हैं, शेड्यूलर में बहुत ज्यादा ऊपरी भाग, और इसी तरह। (बड़ी संख्या में थ्रेड्स बनाने से बहुत मेमोरी खाई जाती है। लेकिन वास्तविक कार्य करने वाले कई थ्रेड्स आपको धीमा कर देते हैं क्योंकि वे उपलब्ध CPU समय के लिए लड़ रहे हैं)

आप क्या कर रहे हैं जहां यह सीमा भी प्रासंगिक है?

इसे पुनः प्राप्त करने के लिए:

 cat /proc/sys/kernel/threads-max 

इसे सेट करने के लिए:

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

123456789 = थ्रेड्स के #

@dragosrsupercool

लिनक्स अधिकतम थ्रेड की गणना करने के लिए वर्चुअल मेमोरी का उपयोग नहीं करता है, लेकिन भौतिक RAM सिस्टम पर स्थापित है

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

इसलिए धागा अधिकतम प्रत्येक सिस्टम के बीच अलग है, क्योंकि राम अलग-अलग आकार से स्थापित हो सकता है, मुझे पता है कि लिनक्स को वर्चुअल मेमोरी बढ़ाने की जरूरत नहीं है, क्योंकि 32 बिट पर हमें 3 जीबी उपयोगकर्ता स्थान और 1 जीबी कर्नेल के लिए मिला है, 64 बिट पर हमें 128 TB वर्चुअल मेमोरी मिली, जो सोलारिस पर होती है, यदि आप आभासी स्मृति में वृद्धि चाहते हैं तो आपको स्वैप स्पेस जोड़ने की आवश्यकता है।

लिनक्स पर उचित 100k धागा:

 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 

थ्रेड गिनती सीमा: $ 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 | ग्रेप फैला | awk '{totalpages = totalpages + $ 2} अंत {प्रिंट totalpages}';

तो वास्तव में संख्या धागा स्मृति स्टैक आकार (उलिमिट-एस) की सीमा से संबंधित नहीं है ps: थैरे मेमोरी स्टैक सीमा मेरे आरएचएल वीएम में 10 एम है, और 1.5 जी मेमोरी के लिए, इस वीएम में केवल 150 थ्रेड्स हैं?

यह शायद बात नहीं करना चाहिए आप अपने एल्गोरिथम को एक निश्चित संख्या के धागे का उपयोग करने के लिए बेहतर प्रदर्शन प्राप्त करने जा रहे हैं (जैसे, 4 या 8 यदि आपके पास 4 या 8 प्रोसेसर हैं)। आप इसे कार्य कतार, एसिंक्रोनस आईओ, या कुछ जैसे libevent के साथ कर सकते हैं।

nbio गैर-अवरुद्ध आई / ओ लाइब्रेरी या जो कुछ भी हो, यदि आपको ब्लॉक करने के लिए I / O कॉल करने के लिए अधिक थ्रेड्स की आवश्यकता है

आपके सिस्टम पर निर्भर करता है, बस एक नमूना कार्यक्रम [एक पाश में प्रक्रियाएं बनाने से] लिखें और ps axo pid, ppid, rss, vsz, nlwp, cmd का उपयोग करके जांच करें। जब यह थ्रेड नहीं बना सकता है nlwp गिनती की जांच [nlwp संख्या थ्रेड्स है] वोला आपको पुस्तकों के माध्यम से जाने के बजाए अपने बेवकूफ सबूत का जवाब मिला

यह देखने वाले किसी भी व्यक्ति के लिए, systemd सिस्टम पर (मेरे मामले में, विशेष रूप से Ubuntu 16.04) cgroup pids.max पैरामीटर द्वारा लागू एक और सीमा है।

यह डिफ़ॉल्ट रूप से 12,288 पर सेट है, और /etc/systemd/logind.conf में ओवरराइड किया जा सकता है

अन्य सलाह अभी भी pids_max, थ्रेड्स-अधिकतम, अधिकतम_मैप्स_count, उलमीट आदि सहित लागू होती है।

हम लिनक्स में निम्न फाइल में परिभाषित अधिकतम थ्रेड्स देख सकते हैं

cat / proc / sys / कर्नेल / धागे- अधिकतम

(या)

sysctl -a | | grep धागे-अधिकतम

स्थायी रूप से सेट करने के लिए,

 vim /etc/sysctl.conf 

और जोड़

 kernel.threads-max = "value" 

रिलेटेड लिनक्स 2.6: मेरे मामले में, उलटाइट के साथ ढेर आकार के स्टैक आकार की जांच करें।

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

आपके प्रत्येक थ्रेड्स को यह स्टेक के लिए आवंटित स्मृति (10 एमबी) मिलेगा। एक 32 बिट प्रोग्राम और 4 जीबी का अधिकतम पता स्थान है, जो कि अधिकतम 4096MB / 10MB = 40 9 थ्रेड्स है! न्यूनतम प्रोग्राम कोड, मापन हीप-स्पेस शायद एक अधिकतम मनाया जाता है 300 धागे का

आप इसे 64 बिट पर संकलन और चलाना और उलिमिट -8192 या उल्लिखित -40 9 6 पर भी सेट करने में सक्षम होना चाहिए। लेकिन अगर यह सलाह दी जाती है तो एक और चर्चा …