looper book

Overview : Android uses messaging mechanisms to communicate between threads, threads create their own message loops through Looper, MessageQueue is a FIFO message queue, Looper is responsible for extracting messages from MessageQueue. and distributes to the message specifies the target handler object. The handler object binds to the thread's local variable looper

1. The relationship between Handler Looper MessageQueue2. Source Code AnalysisRepresents the relationship between the four classes of handler, Looper, MessageQueue, and message. The handler must be associated with a looper, and the relevant looper determines which MessageQueue the handler will send a message t

Preface:The previous article is about bitmap and memory optimization technology, this article to everyone talk about handler.Handler is an important knowledge of the Android system, which is often asked in Android multithreaded interviews and is often used in real-world projects. Of course, more complex, more knowledge, involved in the class has thread, Looper, Message, MessageQueue.Android is multi-threaded, usually the user-related UI events in the

The role of handler is to send a message and handle the message sent by Message,handler is actually sent to its own object for processing, so who is sent who is handling, but this absolutely makes sense, So that we can move the processing of the message from one thread to another through handler, after a message has changed hands, the object that handles it is the same, but the thread that handles it changes and becomes the thread that creates the handler object. Instead of the thread that gener

First, IntroductionIn Android development, you use Message Queuing to complete inter-thread communication. The thread that uses Message Queuing is the message loop (msg looper). The message loop constantly checks the message queue for new messages. A message loop consists of a thread and a looper; the Looper object manages the thread's message queue.The main thre

Overview:To facilitate communication between threads, the Handler mechanism simplifies the development of multithreading through collaboration between Handler and Looper, MessageQueue, and Message classes. The thread's interaction is encapsulated into a message, and the thread that implements the Handler mechanism calls the Looper loop () method by Handler the message into the MessageQueue message queue,

Overview* Message: Messages. Messages can contain simple data, object and bundle, and can contain a runnable (which can actually be considered a callback). * MessageQueue: Message Queuing for looper threads to consume messages. * Looper: Used to loop through the message, a thread in conjunction with a Looper to implement messages loop processing. The main thread

After reading so many articles, I finally read it.References: "1" Android Developer Handler "2"handler role in Android"3" Android Thread Looper Handler relationship "4" Android message processing mechanism (figure + source analysis)--looper,handler,message1, from the definition of understanding handlerFirst of all, a reference to "1" in an English sentence to illustrate the following: a Handler allows you

We know that in the Android thread, the message loop is taken out of the information to deal with, the main thread and child threads, child threads and child threads between the communication is also looper to achieve, and then I will briefly introduce the use of the Looper method. The main thread (that is, the UI thread) itself has a message loop that does not need to be created, and other threads need to

One: Handler,looper,message,messagequeue,threadHandler: Message processing, responsible for sending message messages (Handler.sendmessage (...) ) and processing messages, for handler processing messages, you need to implement the Handlermessage (Message msg) method, which handles specific messages, such as Finer UILooper: Message pump, used to extract messages from MessageQueue, so a looper corresponds to a

Looper is typically a thread running in a circular queue of messages, and threads do not provide a looping message to associate them by default, that is, there is no message queue in the normal thread to correlate the message. Then if the thread wants to manage these messages, it must call Looper.prepare () in this thread to make the message queue run, and call Looper.loop () This method to keep its message queue running until it stops. And handler is

Handler: Handling MessagesMessage: MessagesMessageQueue: Message QueuingLooper:messagequeue's managerMessageQueue:Message Queuing. Storing multiple Message.messagequeue with FIFO is managed through handler, through Looper.prepare () The MessageQueue object is created automatically while the Looper is created. The UI main thread creates the Looper by default, and other threads need to be created manually. Th

Handler created, must have a looper, the main thread has created itself. Other threads need to be created by themselves, not by default. Create a method1. This method is to create a system-defined handlerthread, which is run in a non-UI thread, has created a good looper, directly use it. Create handler have multiple constructors, see the source codeHandlerthread Threadhandler = new Handlerthread ("1111");Th

Asynctask is the simplest way to perform a background thread, but it does not apply to repetitive and long-running tasks.1. LooperIn Android, a thread has a message queue, and a thread that uses Message Queuing is called a message loop. The message loop loops through the queue to check for new messages.The message loop consists of threads and Looper, and the Looper object manages the thread's message queue.

.4. What is LooperLooper is the meaning of the loop, which is responsible for taking the message out of the message queue and handing it over to the target processing5. What is the difference between a thread and a looper? If a thread does not have a looper, there is no message queue and the message cannot be processed, and handler cannot be used inside the thread. This is why creating a handler inside a ch

I. Looper1. How do I use Looper?(1) define a looperthread.Class Looperthread extends Thread {Public Handler Mhandler;public void Run () {Looper.prepare (); Call prepare ();Looper.loop (); Enter the message loop.}}(2) Use Looperthread in the application:{New Looperthread (). Start (); Start a new thread, and the thread function is run.}2. Looper.prepare () function:public static final void prepare () {if (sthreadlocal.get () = NULL) {throw new RuntimeE

For this part of the content, will be divided into 4 sections to describe:1. Responsibilities and relationships2. Message loops3. Threads and Updates4. A few summary--------------------------------------------------------------------------------------------------1) Next, we begin this part of the content, first of all to understand the respective responsibilities and the relationship between each other. DutyMessage: Messages that contain the message ID, the message Processing object, and the pro

Simply put, handler gets the Looper object in the current thread, Looper is used to hold the message taken out of the MessageQueue, and the message is distributed and processed by handler, in FIFO execution.MessageQueue (Message Queuing): Used to hold a message sent through handler, usually attached to a thread that created it, can get the message queue of the current thread through Looper.myqueue ().Handle

Handler, Looper, and message all have concepts related to the Android asynchronous message processing thread. So what is the asynchronous message processing thread? When the asynchronous message processing thread starts, it enters an infinite loop body, takes a message out of its internal message queue once per loop, and then callbacks the corresponding message handler, and then resumes the loop after the completion of a message. If the message queue

method. At the right time, given theRunnableand theMessagewill be inHandlerof theMessageQueuein isscheduled. Message Introduction:Message A class is defined as a message that contains a descriptor and any data object that is used to pass to the handler.message Object providing an additional two int Domain and a Object domain, which allows you to not use the assigned action in most cases. Although the message 's constructor is public, the best way to get the message instance is to call the M