1.  一个线程里面只有一个Looper。
2. 子线程也可创建handler。
前后需分别加上Looper.prepare();和Looper.loop();
标准写法：
Looper.prepare();
Handler
 mHandler = new
 Handler() {
@Override
publicvoidhandleMessage(Message
 msg) {
if
 (msg.what == 10000)
 {
Log.i(TAG,"在子线程中定义Handler，并接收到消息。。。");
}
}};
Looper.loop();

在prepare
 中创建looper。
3.
 主线程对应的方法在ActivityThread的main方法中。
4. Looper的构造方法中初始化了一个MessageQueue对象
privateLooper(boolean
 quitAllowed) {
mQueue
 = new
 MessageQueue(quitAllowed);
mThread
 = Thread.currentThread();
}
总：Looper.prepare()方法初始话了一个Looper对象并关联在一个MessageQueue对象，并且一个线程中只有一个Looper对象，只有一个MessageQueue对象。而Handler的构造方法则在Handler内部维护了当前线程的Looper对象
5. handler.sendMessage(msg) 会调用queue.enqueueMessage(msg,
 uptimeMillis);，会发现 
MessageQueue并没有使用列表将所有的Message保存起来，而是使用Message.next保存下一个Message，从而按照时间将所有的Message排序；
6.
 Looper.loop()
可以看到Looper.loop()方法里起了一个死循环，不断的判断MessageQueue中的消息是否为空，如果为空则直接return掉，然后执行queue.next()方法



可以看到其大概的实现逻辑就是Message的出栈操作，里面可能对线程，并发控制做了一些限制等。获取到栈顶的Message对象之后开始执行：

msg.target.dispatchMessage(msg);

Handle的dispatchMessage（）

/**
  

*
 Handle system messages here. */

publicvoiddispatchMessage(Message
 msg) {

if
 (msg.callback != null)
 {

handleCallback(msg);

}else
 {

if
 (mCallback != null)
 {

if
 (mCallback.handleMessage(msg)) {

return;

}

 }

handleMessage(msg);

}

}


可以看到，如果我们设置了callback（Runnable对象）的话，则会直接调用handleCallback方法：

privatestaticvoidhandleCallback(Message
 message) {

message.callback.run();

}


msg.callback为空的话，会直接调用我们的mCallback.handleMessage(msg)，即handler的handlerMessage方法。由于Handler对象是在主线程中创建的，所以handler的handlerMessage方法的执行也会在主线程中





原作者的总结：


1）主线程中定义Handler，直接执行：

Handler mHandler =new
 Handler() {

@Override

publicvoidhandleMessage(Message
 msg) {

super.handleMessage(msg);

}};


而如果想要在子线程中定义Handler，则标准的写法为：

// 初始化该线程Looper，MessageQueue，执行且只能执行一次

Looper.prepare();

//
 初始化Handler对象，内部关联Looper对象

Handler mHandler =new
 Handler() {

@Override

publicvoidhandleMessage(Message
 msg) {

super.handleMessage(msg);

}

};

//
 启动消息队列出栈死循环

Looper.loop();


2）一个线程中只存在一个Looper对象，只存在一个MessageQueue对象，可以存在N个Handler对象，Handler对象内部关联了本线程中唯一的Looper对象，Looper对象内部关联着唯一的一个MessageQueue对象。

3）MessageQueue消息队列不是通过列表保存消息（Message）列表的，而是通过Message对象的next属性关联下一个Message从而实现列表的功能，同时所有的消息都是按时间排序的。

4）android中两个子线程相互交互同样可以通过Handler的异步消息机制实现，可以在线程a中定义Handler对象，而在线程b中获取handler的引用并调用sendMessage方法。

5）activity内部默认存在一个handler的成员变量，android中一些其他的异步消息机制的实现方法： 

Handler的post方法：

mHandler.post(new
 Runnable() {

@Override

publicvoidrun()
 {

}

});


查看其内部实现：

publicfinalbooleanpost(Runnable
 r) {

return
 sendMessageDelayed(getPostMessage(r), 0);

}


可以发现其内部调用就是sendMessage系列方法。。。

view的post方法：

publicbooleanpost(Runnable
 action) {
final
 AttachInfo attachInfo = mAttachInfo;
if
 (attachInfo != null)
 {
return
 attachInfo.mHandler.post(action);
}
//
 Assume that post will succeed later
ViewRootImpl.getRunQueue().post(action);
returntrue;
}

可以发现其调用的就是activity中默认保存的handler对象的post方法。

activity的runOnUiThread方法：
publicfinalvoidrunOnUiThread(Runnable
 action) {
if
 (Thread.currentThread() != mUiThread) {
mHandler.post(action);
}else
 {
action.run();
}
}

判断当前线程是否是UI线程，如果不是，则调用handler的post方法，否则直接执行run方法。
http://blog.csdn.net/qq_23547831/article/details/50751687

Android 异步消息机制

参考：http://blog.csdn.net/lmj623565791/article/details/38377229 

1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。 

2、Looper.loop()会让当前线程进入一个无限循环，不断从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。 

3、Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。 

4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。 

5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。 

好了，总结完成，大家可能还会问，那么在Activity中，我们并没有显示的调用Looper.prepare()和Looper.loop()方法，为啥Handler可以成功创建呢，这是因为在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。

1、  Looper 

    Looper.prepare():只能调用一次。会进行判空操作，有则抛出异常，没有则创建并保存到ThreadLocal中。 

    new Looper():创建MessageQueue消息队列，保存在Looper对象中。 

    Looper.loop():无限循环读取消息（messageQueue.next()方法），没有消息则阻塞，获取到则执行msg.target.dispatchMessage(msg);其中msg.target就是Handler对象。

class Thread{
    ThreadLocal threadLocal;        
}
class ThreadLocal{
    Looper looper;
}
class Looper{
    MessageQueue messageQueue;
}


2、 Handler 

    new Handler():保存Thread中的looper、messageQueue到对象中。 

    sendMessage():最终调用sendMessageAtTime()，将msg.target赋值为this，再执行queue.enqueueMessage将消息插入队列。 

    dispatchMessage ：若msg.callback不为空（其实就是postRunnable方式），则执行handCallback，否则执行handMessage方法。

class Handler{
    Looper looper；
    MessageQueue messageQueue；
    new Handler(){
        this.looper = threadLocal.looper;
        this.messageQueue = looper.messageQueue;
    }
}


Handler与哪个looper关联，则最终消息处理在哪执行。（默认与主线程关联，如果传入looper对象，如handlerThread,则会在子线程处理消息）。 

looper循环不卡死：执行message.next，会执行nativePollOnce方法，设计Linux pipe/epoll机制，类似生产者消费者模式。 

HandlerThread：其实就是在run中执行了Looper.prepare()和Looper.loop()，而使用的时候是通过Handler handler = new Handler(handlerThread.getLooper())，之后handler的消息都会在子线程中执行。

谷歌在Android native层实现的一个异步消息机制，在这个机制中几乎不存在同步锁，所有的处理都是异步的，将变量封装到一个消息AMessage结构体中，然后放到队列中去，后台专门有一个线程会从这个队列中取出消息然后执行，执行函数就是onMessageReceived
AMessage类
struct AMessage : public RefBase {
    //构造函数，包括两个参数，第一个参数指明这是个什么消息，用于在onMessageReceived处理分支中进行匹配，第二个参数target用于后台线程在处理这个消息的时候知道发给哪个类处理
    AMessage(uint32_t what = 0, ALooper::handler_id target = 0);
    void setWhat(uint32_t what);
    uint32_t what() const;
    void setTarget(ALooper::handler_id target);
    ALooper::handler_id target() const;

    void clear();
    //这个消息类中定义了一堆set和find方法，用于在在传递消息过程中携带各种信息
    void setObject(const char *name, const sp &obj);
    void setBuffer(const char *name, const sp &buffer);
    void setMessage(const char *name, const sp &obj);
    bool findBuffer(const char *name, sp *buffer) const;
    bool findMessage(const char *name, sp *obj) const;
    void post(int64_t delayUs = 0);
protected:
    virtual ~AMessage();  析构函数
private:
    uint32_t mWhat;
    ALooper::handler_id mTarget;
    两个重要的私有成员变量
};

使用方法

正如开头部分看的那样，构造一个消息的过程如下：
void NuPlayer::start() {
    (new AMessage(kWhatStart, id()))->post();
}
void AMessage::post(int64_t delayUs) {
    gLooperRoster.postMessage(this, delayUs);
}

AHandler类分析----消息处理类的父类
struct AHandler : public RefBase {
    AHandler()
        : mID(0) {  // mID的初始值为0
    }
    ALooper::handler_id id() const {
        return mID;   //id()这个函数用于返回内部变量mID的值，其初始值为0，但是会通过setID函数设置
    }
    sp<ALooper> looper();
protected:
    virtual void onMessageReceived(const sp &msg) = 0;
private:
    friend struct ALooperRoster;
    ALooper::handler_id mID;
    //下面这个函数正式在其友元类ALooperRoster的registerHandler中调用的
    void setID(ALooper::handler_id id) {
        mID = id;
    }
};

ALooper::handler_id ALooperRoster::registerHandler(
        const sp looper, const sp &handler) {
    Mutex::Autolock autoLock(mLock);

    if (handler->id() != 0) {
        CHECK(!"A handler must only be registered once.");
        return INVALID_OPERATION;
    }
    HandlerInfo info;
    info.mLooper = looper;
    info.mHandler = handler;
    ALooper::handler_id handlerID = mNextHandlerID++;
    mHandlers.add(handlerID, info);
    handler->setID(handlerID);
    //针对每个handler调用registerHandler的时候都会设置一个独一无二的handler_id，最后发送消息进行处理的时候就是通过这个独一无二的handler_id这个变量找到处理handler类的。
    return handlerID;
}    

在这个函数中针对这个looper和handler会构造一个HandlerInfo结构体，然后放到pair容器中。一个looper可以有多个handler，但是一一个handler只能跟一个looper。
ALooper类
struct ALooper : public RefBase {
    typedef int32_t event_id;
    typedef int32_t handler_id;
    ALooper();
    // Takes effect in a subsequent call to start().
    void setName(const char *name);
    handler_id registerHandler(const sp &handler);
    void unregisterHandler(handler_id handlerID);
    status_t start(
            bool runOnCallingThread = false,
            bool canCallJava = false,
            int32_t priority = PRIORITY_DEFAULT
            );
private:
    friend struct ALooperRoster; 
    struct Event {
        int64_t mWhenUs;
        sp mMessage;
    };
   //后台存放事件的链表
    List<Event> mEventQueue;
    struct LooperThread;
    //后台处理线程
    sp<LooperThread> mThread;
    void post(const sp &msg, int64_t delayUs);
    bool loop();
};


ALooper 里面用Condition 做消息通知， List存储消息
能作为handler进行注册的类都必须是继承自AHandler这个类，注册的过程也是交给

gLooperRoster处理。
AMessage类：
消息类，用于构造消息，并通过post方法投递出去由ALooperRoster 类中转给ALooper
ALooperRoster类：中转类
将消息中转给ALooper 或者 AHandleReflector
ALooper
负责存储和转发AHandle的消息
LooperThread：
此线程循环调用ALooper的loop方法来转发消息
AHandleReflector类
消息处理类
使用方法

1.开始会创建一个ALooper对象， mLooper->start(…)
2.然后会实现一个AHandler的子类，

mLooper->registerhandler(objectXX)
子类实现一个onMessageReceived(XXXX),做收到消息的处理。
3.最后创建消息进行投递进入Message Queue。

创建AMessage里面，需要指定handleid,才能知道目标是发给谁。
mLooper(new ALooper)
mLooper->setName(name);  

mLooper->start(  
         false, // runOnCallingThread  
         false, // canCallJava  
         ANDROID_PRIORITY_FOREGROUND); 

mPlayer = new NUPlayer;
mLooper->registerHandler(mPlayer);  
//mPlayer是一个AHandler

mReflector =new AhandlerReflector<RTSPSource.(this);
mLooper->registerHandler(mReflector); 

(new AMessage(kWhatStart,id()))->post()

前言

作为Android开发的我们都知道，Android的主线程即UI线程是不安全的，如果我们在子线程里去更新UI则有可能造成程序崩溃。解决办法我们都非常的熟悉了，就是创建message，然后使用handler去发送这个message,之后在handlerMessage里去刷新UI。我们称之为异步消息处理线程，但是其中的原理是怎样的，你真的知道吗？

源码分析

基本使用方法这里就不再说明了，我们或许知道’在子线程里直接创建handler会报错’,至于为什么会报错，我们来看看Handler的构造函数：



public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

代码12行，这里做了判断，如果mLooper为null那么就抛出一个异常，这里就能解释我们在线程里直接创建handler会报错了，所以我们在子线程中创建handler之前应该先创建Looper：



Looper.prepare();

我们来看下是如何创建Looper的，进入prepare方法



private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

首先会判断当前线程是否已经有Looper，如果有，则抛出异常’一个线程只能有一个Looper’，反之则创建Looper对象，我们进入Looper的构造函数：



 private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

我们发现，在Looper的构造函数里创建了MessagerQueue，由此，我们可以得出结论MessageQueue是一一对应的，且一个线程里只能有1个Looper和1个MessageQueue。

那为什么主线程可以直接创建Handler呢？现在我们应该都知道答案了，因为主线程默认创建了Looper.进入ActivityThread的main方法：



public static void main(String[] args) {
    SamplingProfilerIntegration.start();
    CloseGuard.setEnabled(false);
    Environment.initForCurrentUser();
    EventLogger.setReporter(new EventLoggingReporter());
    Process.setArgV0("<pre-initialized>");
    Looper.prepareMainLooper();
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    AsyncTask.init();
    if (false) {
        Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
    }
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

可以看到，在第7行调用了Looper.prepareMainLooper()方法，而这个方法又会再去调用Looper.prepare()方法，代码如下：



public static final void prepareMainLooper() {
    prepare();
    setMainLooper(myLooper());
    if (Process.supportsProcesses()) {
        myLooper().mQueue.mQuitAllowed = false;
    }
}

现在，从我们最熟悉的代码继续：



mHandler.sendMessage(msg);

进入sendMessage方法：



public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }




public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }



public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }

这里的mQueue，我们上面已经看到，创建Looper的时候创建，这里是加了个判断，进入enqueueMessage方法：



private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

我们看到，最终这个消息是交给了MessageQueue去处理，进入MessageQueue的enqueueMessage方法：



 boolean enqueueMessage(Message msg, long when) {
        if (msg.isInUse()) {
            throw new AndroidRuntimeException(msg + " This message is already in use.");
        }
        if (msg.target == null) {
            throw new AndroidRuntimeException("Message must have a target.");
        }

        synchronized (this) {
            if (mQuitting) {
                RuntimeException e = new RuntimeException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w("MessageQueue", e.getMessage(), e);
                return false;
            }

            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

MessageQueue是一个消息处理队列，毫无疑问enqueueMessage方法就是入队，这里我们要明白的是，MessageQueue并不像集合以一样把所有消息存在一起，而是使用mMessages代表待处理的消息，然后观察上面的代码的16~43行我们就可以看出，这里的入队，实质就是将所有消息根据时间来排序，根据就是我们传入的uptimeMillis参数，根据时间的顺序调用msg.next，从而为每一个消息指定它的下一个消息是什么。

那Looper对MessageQueue做了怎样的操作呢？进入Looper.loop()方法：



public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycle();
        }
    }

我们可以看到，从代码的13行开始进入死循环，不断的调用MessageQueue的next方法，对的，next就是出队方法。逻辑就是：如果当前MessageQueue中存在mMessages，就将这个消息出队，然后让下一条消息成为mMessages，否则就进入一个阻塞状态，一直等到有新的消息入队。我们继续看代码的27行，msg.target.dispatchMessage(msg);target是什么？进入Message源码我们会发现，实质就是我们的Handler。进入dispatchMessage方法：



public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

这里会判断mCallback是否为空，如果不为空，handleCallback(进入Callback源码发现调用mCallback的handleMessage()方法)将消息传出去，如果为空，就使用handler的handleMessage方法将消息传出去。这个handlerMessage我们是不是很熟悉，这下我们就明白为什么在handlerMessage方法里能收到消息了。

在google官方copy了一段标准的创建异步消息的代码，相信大家会很清楚的理解：



class LooperThread extends Thread {
      public Handler mHandler;

      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

在文章的开头我们提到在多线程中直接更新UI会报错，我们也知道用什么方法去解决。以下三个方法，可以直接在其他线程中更新UI：



1. Handler的post()方法
2. View的post()方法
3. Activity的runOnUiThread()方法

他们的实质就是异步消息机制。这里就不一一说明了。