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




multithreading android-handler (8)

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

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


Answers

हैंडलर और थ्रेड वास्तव में 2 अलग-अलग चीजें हैं।

लंबी चल रही नौकरियों को निष्पादित करने के लिए एक थ्रेड बनाया जाना चाहिए।

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

तो आपके पास हैंडलर या थ्रेड के बीच विकल्प नहीं है। भारी नौकरियां करने के लिए धागे का प्रयोग करें! (यदि आप अपने पृष्ठभूमि धागे को किसी अन्य धागे में करने के लिए कुछ नौकरी ट्रिगर करेंगे तो आप एक हैंडलर का उपयोग कर सकते हैं - अधिकांश समय यूआई थ्रेड)


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

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

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

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

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


यदि आप जो भी कर रहे हैं वह "भारी" है तो आपको इसे थ्रेड में करना चाहिए। यदि आप इसे अपने स्वयं के धागे में स्पष्ट रूप से प्रारंभ नहीं करते हैं, तो यह मुख्य (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);
        }
    }   
};

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


एक Handler एक ही Thread पर चलता है, एक Thread एक अलग थ्रेड पर चलता है।

एक हैंडलर का उपयोग करें यदि आपको एक ही थ्रेड पर कुछ चलाने की ज़रूरत है , आमतौर पर एक जीयूआई तत्व या ऐसा कुछ।

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


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

एक हैंडलर आपको थ्रेड के संदेश 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 दो अलग-अलग चीजें हैं, लेकिन वे एक-दूसरे से विरोधाभास नहीं करते हैं। आपके पास एक ही समय में एक Handler और Thread हो सकता है और वास्तव में प्रत्येक Handler Thread में चलाना चाहिए।

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


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


कीबोर्ड को छुपाने के लिए मुझे एक और समाधान मिला:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);

यहां HIDE_IMPLICIT_ONLY की स्थिति में showFlag और 0 की स्थिति पर hiddenFlag । यह नरम कीबोर्ड को मजबूती से बंद कर देगा।





android multithreading android-handler