infinite looper

Understanding LooperLooper is used to add a message queue (MessageQueue) to a thread, and to loop through a tool that, when there is a message, evokes a thread to process the message until the thread is finished. Looper is not normally used because, for system components such as Activity,service, frameworks has initialized a thread (commonly known as a UI thread or main thread) with a looper in it and a mes

message system and simple principle.Let's learn the fundamentals of the messaging system.The basic principle and composition of the two-message systemThe establishment of a generic message system model roughly consists of the following parts:L Message PrototypeL Message QueuingL Send a messageL message loopL Message AcquisitionL Message DistributionL Message ProcessingThe approximate model diagram is as follows:　　　　The message system model typically includes the above seven parts (message proto

The Hidden Trap of AsynctaskLet's take a look at an example This example is very simple, it shows the extreme use of asynctask, very strange. Copy Code code as follows: public class Asynctasktrapactivity extends activity { Private Simpleasynctask Asynctask; Private Looper Mylooper; Private TextView status; @Override public void OnCreate (Bundle icicle) { Super.oncreate (Icicle); Asynctask = null; New Thread (New Runnable () { @O

Message: messages, which contain message IDs, message processing objects, and processed data, are unified by MessageQueue, and eventually handled by handler. Handler: Processor, responsible for message delivery and processing. When using handler, you need to implement the Handlemessage (Message msg) method to handle a particular message, such as updating the UI. MessageQueue: Message Queuing, which is used to store messages sent by handler and executed in accordance with FIFO rules. Of course, s

first, take a look at the use of the process1. Using handler instances in child threads /*********** Child Threads Use Handler instance *********/ private class Looperthread extends thread {public Handler Handler; @Override public Void Run () { looper.prepare (); Handler = new Handler () { @Override public void Handlemessage (Message msg) { } };

Android Threading message passing mechanism--looper,handler,messageBefore introducing these concepts, let's look at the context in which these mechanisms are introduced.For performance optimizations, Android UI operations are not thread-safe (if you don't know what thread safety is, you can read Here's a question: What if your Android program wants to download a picture on the Web (we don't consider using Android-provided components for the moment), a

IntroductionWhen we do Android development, we often need to implement the asynchronous loading of images/Web pages/other. In fact, to implement asynchronous loading, you need to implement inter-thread communication, while in Android, using Handler, Looper, and Message enables different threads to communicate and complete asynchronous tasks. Although Android has provided us with the Asynctask class to accomplish asynchronous tasks, there are many prob

Android's message processing has three core classes: Looper,handler and message. There's actually a message queue, but MQ is encapsulated in Looper, and we don't deal directly with MQ, so I don't use it as a core class. Here are the following:Thread of the magician LooperLooper literally means "circulator", which is designed to make a normal thread into a looper

each thread.4, LooperLooper is the steward of MessageQueue in each thread, and after calling the Looper loop () method, it goes into an infinite loop, and then whenever a message is found in MessageQueue, it is removed, And passed to Handler's Handlemessage () method. There will only be one Looper object in each thread.After understanding the basic concepts of m

Android's message processing has three core classes: Looper,handler and message. There's actually a message queue, but MQ is encapsulated in Looper, and we don't deal directly with MQ. Usually we use the most often is the message and handler, if the use of handlerthread or their own implementation of similar handlerthread may also be exposed to looper, and Messag

that I did two consecutive add message data, in the results also have a good embodiment, but Looper.prepare (), and handler between the content is only executed once. This is because our custom thread customthread is only one time, and the start has been there and has not been destroyed, so Looper has been there and MessageQueue has been there, thus guaranteeing A thread can have only one Looper object .

Finding out what you're talking about is UI-related, and this is about Android's very important point of knowledge: Handler Looper Message.Talk less and go straight to the chase.(1) Meaning of existence:I've been Handler Looper. Message These classes are a few of the tools that can be used together, in particular because they are provided by the system and are used by the system itself. Since it is a tool c