handler机制简析

首先要知道,android 中有两个重要的机制,一个是Binder机制,另一个是handler机制.

为什么要引入handler机制呢,因为在android中,主线程不能进行耗时的操作,否则会发生ANR异常.子线程做耗时的操作,如联网操作,i/o操作,做完耗时操作后可能需要更新UI,但是android不允许在子线程中更新UI,否则就会触发程序异常,这个时候就可以通过Handler+子线程将更新UI的操作切换到主线程中进行.

• 为什么不可以在子线程中更新UI

  1. 因为android的UI线程不是线程安全的(就是指如果多个线程调用这个类的方法，会出现不可预知的不正常的情况,那么线程安全的意思就是多个线程同时操作不会有问题),如果多个子线程并发发访问(同时访问)会导致UI空间处于不可预期的状态
  2. UI空间不可以枷锁,因为一会导致UI访问的逻辑变得复杂,其次会降低UI访问的效率,会阻塞某些线程的执行’

  由于上边的两个缺点,就可以采用单线程的模式来更新UI,对于开发人员来说只需要通过handler(也可以通过SyncTask类来实现)来切换一下UI访问的线程即可.

2.消息机制原理分析

1. 核心类

* message: 可分为硬件产生的消息和软件产生的消息,一个handler可以发送多个消息
* messageQueue:消息队列,主要用来存放handler发送过来的消息,由系统维护,只有一个实例
* handler:消息辅助类,主要通过sendMessage()发送消息,通过handlerMessage()接受消息,每个activity都可以new一个handler,所以可以有多个handler
* looper:轮询器 ,不断从消息队列中轮询,取出消息,当没有消息的时候回休眠,同时还负责分发消息

首先需要在主线程中建立一个Handler对象，并重写Handler.Message()，并调用sendMessage(),将之存到MessageQueue中，而Looper则会一直尝试从MessageQueue中取出待处理消息，最后分发回handleMessage()中，这是一个无限循环。Looper若没有新消息需要处理则会进入等待状态，直到有消息需要处理为止。

2.Message,handler,MessageQueue,Looper对象的创建

2.1 message的创建

    有三种方式:
        1.new Message()
        2.message.obtain()
        3.handler.obtainMessage() 内部调用了message.obtain()

源码:
//message.obtain()
    public static Message obtain() {
        synchronized (mPoolSync) {
            if (mPool != null) {
                Message m = mPool;
                mPool = m.next;
                m.next = null;
                return m;
            }
        }
        return new Message();
    }
//Handler中的obtainMessage(),本质上还是调用了Message.obtain(this)
    public final Message obtainMessage()
    {
        return Message.obtain(this);//this其实就是handler实例
    }

2.2 handler looper messagequeue的创建

new handler();

一个应用中可以同时有多个handler对象,一个handler对象也可以发送多个message

handler相关源码:
 public Handler() {
        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 = null;
    }

//looper中的相关源码
    public static final void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());//looper就是在这里被实例化的,一定要注意
    }
    public static final void prepareMainLooper() {
        prepare();//调用了prepare(),
        setMainLooper(myLooper());
        if (Process.supportsProcesses()) {
            myLooper().mQueue.mQuitAllowed = false;
        }
    }
//ActivityThread中的源码

  public static final void main(String[] args) {
        SamplingProfilerIntegration.start();

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();//在这里调用了prepareMainLooper()
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler();
        }

//在looper的构造方法中创建了Messagequeue,looper的构造又是在prepare()被调用
  private Looper() {
        mQueue = new MessageQueue();//创建Messagequeue
        mRun = true;
        mThread = Thread.currentThread();
    }

2.3 handler是如何发送消息的

handler依次调用以下3个方法:
sendMessage(Message msg)
sendMessageDelayed(Message msg, long delayMillis)
endMessageAtTime(Message msg, long uptimeMillis)

具体源码如下:

//调用了 sendMessageDelayed(Message msg, long delayMillis)
    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

//endMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)
  public final boolean  sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)；//手机开机时间，加上延迟发送的时间

//通过调用enqueueMessage(msg, uptimeMillis)将消息插入消息队列
    public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
            msg.target = this;
            sent = queue.enqueueMessage(msg, uptimeMillis);//将消息插入队列
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

2.4 messagequeue插入消息的原理

主要由 enqueueMessage(Message msg, long when)方法实现

情形一:当队列中没有消息,或者要插入的消息比队列中的第一消息还要早执行

 final boolean enqueueMessage(Message msg, long when) {
            msg.when = when;
            //Log.d("MessageQueue", "Enqueing: " + msg);
            Message p = mMessages; //mMessages表示队列中的第一个消息
            if (p == null || when == 0 || when < p.when) {
            //message的next属性指向的是下一个消息
                msg.next = p;//原来队列第一个消息变为第二个消息
                mMessages = msg;//将要插入的消息变为第一个消息
                needWake = mBlocked; // new head, might need to wake up
            } else {

情形二:需要将消息插入到中间的情况

 else {
                Message prev = null;//prev中间变量
                while (p != null && p.when <= when) {
                /**通过while循环不断判断,如果要插入的消息比原来第一个晚执行
                /*
                    prev = p;
                    p = p.next;
                }
                msg.next = prev.next;
                prev.next = msg;
                needWake = false; // still waiting on head, no need to wake up
            }

情形二的逻辑比较复杂,下假设需要插入到第二个,一定要画图进行理解:

插入消息完整的源码如下:

    final boolean enqueueMessage(Message msg, long when) {
        if (msg.when != 0) {
            throw new AndroidRuntimeException(msg
                    + " This message is already in use.");
        }
        if (msg.target == null && !mQuitAllowed) {
            throw new RuntimeException("Main thread not allowed to quit");
        }
        final boolean needWake;
        synchronized (this) {
            if (mQuiting) {
                RuntimeException e = new RuntimeException(
                    msg.target + " sending message to a Handler on a dead thread");
                Log.w("MessageQueue", e.getMessage(), e);
                return false;
            } else if (msg.target == null) {
                mQuiting = true;
            }

            msg.when = when;
            //Log.d("MessageQueue", "Enqueing: " + msg);
            Message p = mMessages;
            if (p == null || when == 0 || when < p.when) {
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked; // new head, might need to wake up
            } else {
                Message prev = null;
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
                msg.next = prev.next;
                prev.next = msg;
                needWake = false; // still waiting on head, no need to wake up
            }
        }
        if (needWake) {
            nativeWake(mPtr);
        }
        return true;
    }

2.5 looper唤醒

looper会一直轮询messagequeue,当队列中没有消息的时候,looper会休眠,当handler发送消息后,它又会被唤醒

hanlder在发送消息的时候,写入一个标志:W

2.6 looper如何将msg发送给制定的handler对象

msg.sendToTarget(); //发送给handler

msg.sendToTarget(); //发送给handler
    public void sendToTarget() {
        target.sendMessage(this);//this就是handler,根据不同的handler对象将消息发送给不同的hanglder
    }

2.7 looper如何分发消息

首先调用loop(),在loop()中一次调用下边几个方法:
Looper me = myLooper();//获取looper对象
MessageQueue queue = me.mQueue;//找到消息队列
Message msg = queue.next();//取消息
msg.target.dispatchMessage(msg);//调用handler的 dispatchMessage(msg)方法

handler中的 dispatchmessage()

    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);//当msg中传有回调时执行此方法
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {//mCallback 表示handler中自己的回调
                    return;
                }
            }
            handleMessage(msg);//调用handleMessage() 具体是有我们自己实现
        }
    }

注:handler移除消息 有待研究

总结:
其实Asychtask内部也是使用了handler,从Android 1.5开始系统将AsyncTask引入到android.os包中，过去在很早1.1和1.0 SDK时其实官方将其命名为UserTask，其内部是JDK 1.5开始新增的concurrent库，做过J2EE的网友可能明白并发库效率和强大性，比Java原始的Thread更灵活和强大，但对于轻量级的使 用更为占用系统资源。Thread是Java早期为实现多线程而设计的，比较简单不支持concurrent中很多特性在同步和线程池类中需要自己去实现 很多的东西，对于分布式应用来说更需要自己写调度代码，而为了Android UI的刷新Google引入了Handler和Looper机制，它们均基于消息实现，有时可能消息队列阻塞或其他原因无法准确的使用。

推荐大家使用AsyncTask代替Thread+Handler的方式，不仅调用上更为简单，经过实测更可靠一些，Google在Browser中大量 使用了异步任务作为处理耗时的I/O操作，比如下载文件、读写数据库等等，它们在本质上都离不开消息，但是AsyncTask相比Thread加 Handler更为可靠，更易于维护，但AsyncTask缺点也是有的比如一旦线程开启即dobackground方法执行后无法给线程发送消息，仅能 通过预先设置好的标记来控制逻辑，当然可以通过线程的挂起等待标志位的改变来通讯，对于某些应用Thread和Handler以及Looper可能更灵 活。

（1）发送消息

Handler支持2种消息类型，即Runnable和Message。因此发送消息提供了post(Runnable r)和sendMessage(Message msg)两个方法。从下面源码可以看出Runnable赋值给了Message的callback，最终也是封装成Message对象对象。学姐个人认为外部调用不统一使用Message，应该是兼容Java的线程任务，学姐认为这种思想也可以借鉴到平常开发过程中。发送的消息都会入队到MessageQueue队列中。

（2）处理消息

Looper循环过程的时候，是通过dispatchMessage(Message msg)对消息进行处理。处理过程：先看是否是Runnable对象，如果是则调用handleCallback(msg)进行处理，最终调到Runnable.run()方法执行线程；如果不是Runnable对象，再看外部是否传入了Callback处理机制，若有则使用外部Callback进行处理；若既不是Runnable对象也没有外部Callback，则调用handleMessage(msg)，这个也是我们开发过程中最常覆写的方法了。

（3）移除消息

removeCallbacksAndMessages()，移除消息其实也是从>>MessageQueue中将Message对象移除掉。