जावा लगभग 100 समांतर धागे, मेमोरी प्रबंधन

Question

मैं एक अनुकूलन एल्गोरिदम लिख रहा हूं जो लगभग 100 धागे बनाता है। वर्तमान में, मैं उन्हें एक बार (लूप-लूप) में शुरू करता हूं और इसके बाद मैं प्रत्येक धागे को बताता हूं कि इसमें शामिल होना चाहिए()।

मेरी समस्या अब है कि प्रत्येक धागा बहुत मेमोरी के लिए उपयोग करता है ताकि ढेर अंतरिक्ष अपवाद में अधिक समय लगेगा। मुझे कुछ प्रकार की शेड्यूलिंग चाहिए लेकिन यह नहीं पता कि इसे कैसे कार्यान्वित किया जाए।

मेरे पास इस तरह कुछ है: 10 धागे शुरू करें और हर बार इनमें से एक खत्म एक नया शुरू होता है। ताकि जब तक कोई धागा छोड़ा न जाए तब तक एक समय में 10 धागे चल रहे हों।

क्या कोई व्यक्ति कोई विचार है या जानता है कि इस तरह कुछ कैसे महसूस किया जाए?

एक उपयुक्त अधिकतम पूल आकार के साथ कोलोन

मार्को

Answer 1

मशीन का उपयोग करने वाले मशीन में कोर की संख्या पर विचार करें। प्रदर्शन सबसे अच्छा होगा यदि आपके द्वारा सामान्य रूप से चलने वाले धागे की संख्या कोर की संख्या के बराबर होती है। जैसा कि केएलई कहते हैं, थ्रेड पूल का उपयोग करें।

Answer 2

उपयोग एक ThreadPoolExecutor से बहुत ज्यादा और संबंध धन्यवाद।

Answer 3

इसके बजाय एक नया कार्य करने के लिए एक नया धागा शुरू करने की है, तो आप ज्यादा दूर करने के लिए बेहतर होते हैं:

• कार्यों की एक कतार (धागे के बजाय चलाने के लिए) पर अमल करने के लिए है
• एक छोटे का उपयोग इन कार्यों को संसाधित करने के लिए धागे के(जैसा कि माइकल द्वारा उल्लेख किया गया है)।

गति और स्मृति में अंतर बहुत बड़ा है, क्योंकि आपको प्रत्येक कार्य के लिए धागा शुरू करने और रोकने की आवश्यकता नहीं है।

पैकेज java.util.concurrent इस बारे में सबकुछ बताता है। किताब हालांकि :-(

Answer 4

यहाँ आप आरंभ करने के लिए एक उदाहरण है पढ़ने के लिए आसान होगा सबसे पहले, क्या आप आयात करना होगा:।

import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.TimeUnit; 

और फिर क्या तुम अंदर डाल करने के लिए की जरूरत है अपने विधि:

ExecutorService pool = Executors.newFixedThreadPool(10); 
    for(final Task task: tasks) { 
     pool.execute(new Runnable() { 
      @Override 
      public void run() { 
       task.execute(); 
      } 
     }); 
    } 
    pool.shutdown(); 
    while(!pool.awaitTermination(1, TimeUnit.SECONDS)) { 
     System.out.println("Waiting for tasks to shutdown"); 
    } 

ऊपर के बारे में कुछ नोट:

• आप अपनी खुद की लागू करने के लिए की आवश्यकता होगी टास्क वर्ग है कि वास्तव में लागू करता अपने एल्गोरिथ्म
• काम वर्ग सिर्फ एक (निष्पादित की है, विधि वास्तव में, Runnable लागू करने के लिए अपने कार्य करता है, तो यह है कि हस्ताक्षर, तो आप सिर्फ मिल सकता है और से बचने की जरूरत नहीं है अनाम आंतरिक कक्षा)
• आपको यह सुनिश्चित करना होगा कि आपके द्वारा उपयोग की जाने वाली सभी चीजें ठीक से सिंक्रनाइज़ हैं। java.util.concurrent.atomic में कक्षाएं काफी अच्छा है अगर आप राज्य आपको अवगत करवाने के (जैसे अगर आप चाहते कितने कार्यों आप प्रक्रिया कर दी है के लिए एक काउंटर के लिए) की जरूरत है साझा कर रहे हैं।
• आप आमतौर पर केवल थ्रेड निष्पादित करना चाहते हैं क्योंकि आपकी मशीन पर कोर /cpus हैं। प्रदर्शन अक्सर बढ़ता है जब धागे की संख्या नीचे जाती है। आम तौर पर आप पर अधिक थ्रेड का उपयोग करते हैं, तो आपके कार्य बहुत समय बिताते हैं अवरुद्ध।