android - एंड्रॉइड: मुझे हैंडलर() का उपयोग कब करना चाहिए और मुझे थ्रेड का उपयोग कब करना चाहिए?




multithreading android-handler (6)

जब मुझे असीमित रूप से चलाने के लिए कुछ चाहिए, जैसे लंबे समय तक चलने वाला कार्य या नेटवर्क का उपयोग करने वाले तर्क, या किसी भी कारण से, एक नया थ्रेड शुरू करना और इसे चलाने से ठीक काम करता है। एक हैंडलर बनाना और इसे चलाना भी काम करता है। क्या फर्क पड़ता है? मुझे प्रत्येक का उपयोग कब करना चाहिए? Handler का उपयोग करने के फायदे / कारण क्या हैं और Thread नहीं?

पुनश्च। - इस सवाल के लिए, चलिए AsyncTask अनदेखा AsyncTask । - Handler().postDelayed उपयोग केस मुझे स्पष्ट है, इस सवाल के लिए मान लीजिए कि मुझे तुरंत शुरू करने के लिए कार्य की आवश्यकता है।


यदि आपको किसी नए थ्रेड से उपयोगकर्ता इंटरफ़ेस को अपडेट करने की आवश्यकता है, तो आपको उपयोगकर्ता इंटरफ़ेस थ्रेड के साथ सिंक्रनाइज़ करने की आवश्यकता है।

आप इसके लिए android.os. हैंडलर क्लास या AsyncTasks क्लास का उपयोग कर सकते हैं।

हैंडलर क्लास उपयोगकर्ता इंटरफ़ेस को अपडेट कर सकता है। एक हैंडलर संदेश या रनने योग्य वर्ग के उदाहरण प्राप्त करने के तरीकों को प्रदान करता है।

आप थ्रेड प्रेषण संदेश (संदेश संदेश) विधि के माध्यम से या sendEmptyMessage () विधि के माध्यम से संदेश पोस्ट कर सकते हैं।

... धागे आदि के बारे में अधिक जानकारी (इसमें विभिन्न थ्रेडिंग और सिंक तंत्र के लिए टूरियल शामिल हैं और कब उपयोग करें)


हैंडलर का उपयोग करने के फायदे / कारण क्या हैं और थ्रेड नहीं?

एक हैंडलर आपको थ्रेड के संदेश Runnable जुड़े संदेश और Runnable वस्तुओं को भेजने और संसाधित करने की अनुमति देता है। प्रत्येक Handler उदाहरण एक थ्रेड और उस थ्रेड के संदेश कतार से जुड़ा हुआ है।

जब आप एक नया Handler बनाते हैं, तो यह उस धागे के थ्रेड / संदेश कतार से जुड़ा होता है जो उस समय से बना रहा है - उस बिंदु से, यह संदेश संदेश और संदेश को उस संदेश कतार में वितरित करेगा और उन्हें संदेश से बाहर आने पर निष्पादित करेगा कतार।

हैंडलर के लिए दो मुख्य उपयोग हैं:

  1. भविष्य में किसी बिंदु के रूप में निष्पादित किए जाने वाले संदेशों और रननेबल्स को शेड्यूल करने के लिए
  2. अपने आप से अलग धागे पर एक क्रिया को निष्पादित करने के लिए।

यदि आप जावा धागे का उपयोग करते हैं, तो आपको अपने आप को कुछ संभालना होगा - मुख्य धागे के साथ सिंक्रनाइज़ करना, थ्रेड आदि को रद्द करना आदि।

यह एकल थ्रेड थ्रेड पूल नहीं बनाता है जब तक कि आप ThreadPoolExecutor या ExecutorService API का उपयोग नहीं करते।

(ब्लैकबल्ट उत्तर पर आपकी टिप्पणियों से इस क्वेरी को लिया गया)

एक निष्पादक का उपयोग क्यों नहीं करें? और यहां तक ​​कि अगर मैं ऐसा करने के लिए हैंडलर का उपयोग करना चाहता था, तो कैसे?

संदर्भ: थ्रेड प्रदर्शन लेख

कुछ प्रकार के काम होते हैं जिन्हें अत्यधिक समानांतर, वितरित कार्यों में कम किया जा सकता है। यह काम करता है कि काम पैकेट की भारी मात्रा के साथ, AsyncTask और HandlerThread उचित वर्ग नहीं हैं। AsyncTask की एकल-थ्रेडेड प्रकृति सभी AsyncTask काम को रैखिक प्रणाली में बदल देगी। दूसरी तरफ HandlerThread क्लास का उपयोग करने के लिए प्रोग्रामर को धागे के समूह के बीच लोड संतुलन को मैन्युअल रूप से प्रबंधित करने की आवश्यकता होगी।

ThreadPoolExecutor इस प्रक्रिया को आसान बनाने के लिए एक सहायक वर्ग है। यह वर्ग धागे के समूह के निर्माण का प्रबंधन करता है, उनकी प्राथमिकताओं को निर्धारित करता है, और प्रबंधन करता है कि उन धागे के बीच काम कैसे वितरित किया जाता है। जैसे वर्कलोड बढ़ता या घटता है, वर्कलोड में समायोजित करने के लिए कक्षा अधिक थ्रेड को फैलाती है या नष्ट कर देती है।

 BlockingQueue workQueue= new LinkedBlockingQueue<Runnable>(100); // Work pool size
 ThreadPoolExecutor executor = new ThreadPoolExecutor(
            Runtime.getRuntime().availableProcessors(),       // Initial pool size
            Runtime.getRuntime().availableProcessors(),       // Max pool size
            1, // KEEP_ALIVE_TIME
            TimeUnit.SECONDS, //  KEEP_ALIVE_TIME_UNIT
            workQueue);

अधिक जानकारी के लिए आप create-threadpool पर इस डेवलपर मार्गदर्शिका आलेख का संदर्भ ले सकते हैं।

एकाधिक रनने योग्य उदाहरण चलाने के लिए Handler उपयोग के लिए इस पोस्ट को देखें। इस मामले में, सभी Runnable कार्य एक थ्रेड में चलेंगे।

एंड्रॉइड: थ्रेड में टोस्ट


कतारबद्ध तंत्र बनाने के लिए Handler Thread संयोजन के साथ प्रयोग किया जा सकता है। यूओ Thread Looper पर कुछ पोस्ट करने के लिए handler का उपयोग कर सकते हैं


यदि आप जो भी कर रहे हैं वह "भारी" है तो आपको इसे थ्रेड में करना चाहिए। यदि आप इसे अपने स्वयं के धागे में स्पष्ट रूप से प्रारंभ नहीं करते हैं, तो यह मुख्य (UI) थ्रेड पर चलाएगा जो आपके उपयोगकर्ताओं द्वारा इंटरफ़ेस को प्रतिक्रिया देने में धीमा या धीमा हो सकता है।

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

एक सामान्य थ्रेड / हैंडलर इंटरैक्शन कुछ ऐसा दिख सकता है:

Handler h = new Handler(){
    @Override
    public void handleMessage(Message msg){
        if(msg.what == 0){
            updateUI();
        }else{
            showErrorDialog();
        }
    }
};

Thread t = new Thread() {
    @Override
    public void run(){
        doSomeWork();
        if(succeed){
            //we can't update the UI from here so we'll signal our handler and it will do it for us.
            h.sendEmptyMessage(0);
        }else{
            h.sendEmptyMessage(1);
        }
    }   
};

आम तौर पर, घर लेना यह है कि जब भी आप कुछ काम कर रहे हों तो आपको थ्रेड का उपयोग करना चाहिए जो लंबे समय तक चलने वाला या बहुत गहन हो सकता है (यानी कुछ भी नेटवर्क, फाइल आईओ, भारी अंकगणित, आदि)।


हैंडलर पृष्ठभूमि और यूआई थ्रेड के बीच संचार का सबसे अच्छा तरीका हैं। आम तौर पर हैंडलर संदेश के कतार के संदेश से जुड़े होते हैं और उनका उपयोग संदेश भेजने और संदेश के लिए चलाने योग्य होता है।

उपयोग:

थ्रेड: यूआई थ्रेड की तुलना में सस्ता (पृष्ठभूमि) धागे में कार्य करने के लिए। (यूआई थ्रेड को अनवरोधित करने में मदद करता है)

हैंडलर यूआई और पृष्ठभूमि धागे के बीच संवाद करने के लिए प्रयुक्त होता है।

इस article पर एक नज़र डालें


Handler और Thread दो अलग-अलग चीजें हैं, लेकिन वे एक-दूसरे से विरोधाभास नहीं करते हैं। आपके पास एक ही समय में एक Handler और Thread हो सकता है और वास्तव में प्रत्येक Handler Thread में चलाना चाहिए।

अधिक जानकारी के लिए, आप इस लेख को देखना चाह सकते हैं।





android-handler