handler looper

a summary of handler.Message: Messages, including the message ID, the message processing object and the processing of data, etc., by the MessageQueue Unified Queue, the final processing by Handler . Handler: Handler, responsible for sending and processing the message. When using Handler , you need to implement the hand

):Sendmessagedelayed (Message,long):SendMessage This action queues the Message object, which contains some information, and handler's Hanlermessage (message) handles the message.Handlermessage (Message) must be overridden by the Handler subclass.Post This action puts the Runnable object into the Messagequeue,messagequeue when you receive these messages, execute them in a certain sort of order.When posting or sending to a hanler, you can have three beh

thread.Looper.prepare(); // 为当前线程创建一个Looper对象Looper.getMainLooper(); // 返回当前应用主线程的Looper对象Looper.myLooper(); // 返回当前线程的Looper对象Looper.loop(); // 从消息队列中获取Message，并执行msg.target.dispatchMessage(msg)，msg.target其实是绑定到消息队列的HandlerAndroid.os.HandlerThe handler object is bound to the message queue of a thread, providing a way

Looper PreparationWhen handler is instantiated, it gets looper from the current thread, obtaining MessageQueue for sending messages. Then, the thread is not born with a Looper object, it needs to call the static method Looper.prepare () in the threads execution, and eventually calls to the following static method:Priva

In the main UI thread, the system has initialized a Looper object, so the program creates handler directly, then posts handler to send messages and process messages.The program ape itself initiates the child thread, the program ape must create itself a Looper object, and start it, create the

In the simple music player, with the handler, and not too much to study, here to learn the next Android under the asynchronous message processing mechanism. The handler used here is mainly that the UI cannot be updated in the thread, and it needs to be handler. There are several concepts about asynchronous message processing.1. Message: Messages, data units for i

Analysis of asynchronous message processing mechanismAsynchronous message processing in Android consists of four parts, message, Handler, MessageQueue, and Looper.1. MessageA message is an information that is passed between threads, and it can carry a small number of messages inside to exchange data between different threading. In the previous example, the What field of message was used, in addition to usin

Relationship between message, Handler, message Queue, Looper in a single-threaded model1. MessageA message is an information that can be understood as a communication between threads. Processing a data background thread requires updating the UI, and you can send a message containing some data to the UI thread.2, HandlerHandler is the processor, is the main processor of the message, responsible for sending t

if (looper.mylooper () = Looper.getmainlooper ()) {If we finish marking off of the main thread, we need toActually do it in the main thread to ensure correct ordering.Handler mainthread = new Handler (Looper.getmainlooper ());Mainthread.post (New Runnable () {@Overridepublic void Run () {Meventlog.add (tag, threadId);Meventlog.finish (This.tostring ());}});Return}Handler inside holds a

To do a simple little demo about Handler,looper,message, a button on the main interface of the code, click Send Message (accumulate) to the thread's Looper loop, and then print it out in Logcat:Package Zhangphil.looper;import Android.os.bundle;import Android.os.handler;import android.os.looper;import Android.os.message;import Android.util.log;import Android.view.

Calls in the thread containing the creation of the handler method, will be an error, prompt:"Need call Looper.prepare ()"--before creating, invoke the Looper.prepare () method to create a LooperHowever, the method that contains the create handler may be called in the main thread or in a child thread.When called in the main thread, you add the Looper.prepare () method to it, it may error, prompt:"Only one

1. A handler has only one queue;2. When invoking the Handler.post (Runnable Runnable) method, the Runnable is encapsulated as a message;3. When the queue executes, it determines whether the current message encapsulates the runnable, and if it is closed, executes the runnable directly, and if not, passes the current message to Handlemessage (message msg) for processing;4. Handler can be set at the time of in

Android messaging SystemOverall frameworkIn the Android messaging system, each thread has a looper,looper in which a Messagequeue,handler delivers a message to the queue Message,looper loops out of the message to be processed by handler. The whole

This article is mainly to handler and message loop implementation principle of source analysis, if not familiar with handler can see the blog "android handler use", which is why Android introduced handler mechanism and how to use handler to

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 becau

Message Queuing for the thread. 2. Then call Looper.mylooper () to get a reference to this Looper object. This is not necessary, but if you need to save the Looper object, be sure to prepare (), otherwise the method called on this object does not necessarily have an effect, such as looper.quit () will not exit. 3. Add handler to process messages in the run () me

ThreadLocalBefore looking down, you need to know about Java's threadlocal class, you can refer to the blog: Decryption ThreadlocalLooper, Handler and MessageQueueLet's analyze the previous code and see what the relationship between Handle, Looper, and MessageQueue is in the handler mechanism.classWorkerthreadextendsThread {@Override Public voidrun () {Super. Run

.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 threa

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

void run () {System.out.println ("Runab LEID::::::::::: "+thread.currentthread (). GetId ()); System.out.println (" Runablename: "+thread.currentthread (). g Etname ()), try {Thread.Sleep (10000), and catch (Interruptedexception e) {22 TODO auto-generated catch block23 e.printstacktrace ();24}25}26};27} FourWe pass the data through a message and finally print out the data we passed in the Handlemessage () method.What bundles are:Bundle is a special map, which is a tool for passi