आप समझ सकते हैं कि Looper GUI फ्रेमवर्क के संदर्भ में क्या है। लूपर को 2 काम करने के लिए बनाया गया है।
1) Looper एक सामान्य थ्रेड को रूपांतरित करता है , जो तब चलता है जब इसकी रन () विधि वापस आती है, एंड्रॉइड ऐप के चलने तक कुछ लगातार चलता रहता है , जिसे GUI फ्रेमवर्क में आवश्यक है (तकनीकी रूप से, यह अभी भी समाप्त होता है जब रन () विधि वापस आती है। स्पष्ट करें कि मेरा क्या मतलब है नीचे)।
2) लूपर एक कतार प्रदान करता है जहां नौकरी करने के लिए गणना की जाती है, जो कि GUI ढांचे में भी आवश्यक है।
जैसा कि आप जानते हैं, जब कोई एप्लिकेशन लॉन्च किया जाता है, तो सिस्टम एप्लिकेशन के लिए निष्पादन का एक थ्रेड बनाता है, जिसे "मुख्य" कहा जाता है, और एंड्रॉइड एप्लिकेशन आम तौर पर "मुख्य धागा" को डिफ़ॉल्ट रूप से एक ही धागे पर पूरी तरह से चलाते हैं। लेकिन मुख्य धागा कुछ गुप्त, विशेष धागा नहीं है । यह आपके द्वारा new Thread()कोड के साथ बनाए गए थ्रेड के समान एक सामान्य धागा है , जिसका अर्थ है कि जब इसकी रन () विधि वापस आती है तो यह समाप्त हो जाती है! नीचे के उदाहरण के बारे में सोचो।
public class HelloRunnable implements Runnable {
public void run() {
System.out.println("Hello from a thread!");
}
public static void main(String args[]) {
(new Thread(new HelloRunnable())).start();
}
}
अब, इस सरल सिद्धांत को Android ऐप्स पर लागू करते हैं। यदि एंड्रॉइड ऐप सामान्य धागे पर चलता है तो क्या होगा? एक धागा जिसे "मुख्य" या "यूआई" कहा जाता है या जो भी आपका आवेदन शुरू करता है, और सभी यूआई खींचता है। तो, पहली स्क्रीन उपयोगकर्ताओं के लिए प्रदर्शित की जाती है। तो अब क्या? मुख्य धागा समाप्त हो गया? नहीं, ऐसा नहीं होना चाहिए। यह तब तक इंतजार करना चाहिए जब तक उपयोगकर्ता कुछ करते हैं, ठीक है? लेकिन हम इस व्यवहार को कैसे प्राप्त कर सकते हैं? खैर, हम Object.wait()या के साथ कोशिश कर सकते हैंThread.sleep()। उदाहरण के लिए, मुख्य धागा पहली स्क्रीन, और नींद प्रदर्शित करने के लिए अपना प्रारंभिक काम पूरा करता है। यह जागता है, जिसका अर्थ है बाधित, जब एक नया काम करना है। अब तक बहुत अच्छा है, लेकिन इस समय हमें कई नौकरियों को रखने के लिए एक कतार जैसी डेटा संरचना की आवश्यकता है। उस मामले के बारे में सोचें जब कोई उपयोगकर्ता क्रमिक रूप से स्क्रीन को छूता है, और एक कार्य को समाप्त होने में अधिक समय लगता है। इसलिए, हमें पहले-पहले-आउट तरीके से कार्य करने के लिए डेटा संरचना रखने की आवश्यकता है। इसके अलावा, आप कल्पना कर सकते हैं कि कभी-कभी-चलने-और-प्रक्रिया-नौकरी-जब-तब आने वाले धागे को बीच में रोककर लागू करना आसान नहीं है, और जटिल और अक्सर अस्वीकार्य कोड की ओर जाता है। हम इस तरह के उद्देश्य के लिए एक नया तंत्र बनाना चाहते हैं, और यही लूपर के बारे में है । लूपर वर्ग का आधिकारिक दस्तावेजकहते हैं, "डिफ़ॉल्ट रूप से थ्रेड्स में उनके साथ एक संदेश लूप नहीं होता है", और लूपर एक वर्ग है "जिसका उपयोग थ्रेड के लिए एक संदेश लूप चलाने के लिए किया जाता है"। अब आप समझ सकते हैं कि इसका क्या मतलब है।
चीजों को अधिक स्पष्ट करने के लिए, आइए उस कोड की जांच करें जहां मुख्य धागा रूपांतरित होता है। यह सब एक्टिविटीट्रेड क्लास में होता है । इसकी मुख्य () विधि में, आप नीचे दिए गए कोड को पा सकते हैं, जो एक सामान्य मुख्य सूत्र को किसी ऐसी चीज में बदल देता है जिसकी हमें आवश्यकता है।
public final class ActivityThread {
...
public static void main(String[] args) {
...
Looper.prepareMainLooper();
Looper.loop();
...
}
}
और Looper.loop()विधि लूप असीम रूप से और एक बार में एक संदेश और प्रक्रिया को समाप्त करता है:
public static void loop() {
...
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
...
msg.target.dispatchMessage(msg);
...
}
}
तो, मूल रूप से लूपर एक वर्ग है जो GUI ढांचे में होने वाली समस्या को हल करने के लिए बनाया गया है। लेकिन इस तरह की जरूरतें अन्य परिस्थितियों में भी हो सकती हैं। वास्तव में यह मल्टी थ्रेड्स एप्लिकेशन के लिए एक बहुत प्रसिद्ध पैटर्न है, और आप इसके बारे में अधिक जान सकते हैं कि डॉग ली (विशेष रूप से, अध्याय 4.1.4 "वर्कर थ्रेड्स" से " जावा में समवर्ती प्रोग्रामिंग " में मदद मिलेगी)। इसके अलावा, आप कल्पना कर सकते हैं कि इस तरह का तंत्र एंड्रॉइड फ्रेमवर्क में अद्वितीय नहीं है, लेकिन सभी जीयूआई ढांचे को इसके समान होने की आवश्यकता हो सकती है। आप जावा स्विंग ढांचे में लगभग एक ही तंत्र पा सकते हैं।
