Handler机制

深入理解Handler机制

最新推荐文章于 2025-10-15 00:15:00 发布

原创最新推荐文章于 2025-10-15 00:15:00 发布 · 1k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#handler

Handler机制中涉及到几个比较重要的类：Handler、Looper、Message、和MessageQueue。UI主线程初始化第一个Handler时会通过ThreadLocal创建一个Looper。使用ThreadLocal的目的是保证每一个线程只创建唯一一个Looper。之后其他Handler初始化的时候直接获取第一个Handler创建的Looper。Looper初始化的时候会创建一个消息队列MessageQueue。Hander持有对消息队列MessageQueue和消息循环器Looper的引用，子线程可以通过Handler将消息Message发送到消息队列MessageQueue中。UI主线程通过Looper循环查询消息队列，当发现有消息存在时会将消息Message从消息队列中取出，将消息Message分发给相应的Handler进行处理。
对于Handler机制的源码分析分析文章很多，在此对源码就不多说了。下面通过自定义Hander 、Looper、 MessageQueue和 Message，加深大家对Handler机制的理解。
1.Handler类：类里有两个重要的成员变量MessageQueue mQueue和Looper mLooper，也就是，Handler被实例化的时候，持有MessageQueue和Looper 的引用，Handler中两个很重要的函数：sendMessage(Message msg)和handleMessage(Message msg)，子线程发送消息时，调用前者，Looper从消息队列MessageQueue取出Message时，会调用handleMessage(Message msg)处理消息，所以我们在实例化Handler的时候，重写handleMessage(Message msg)函数，该函数就会被回调。

package mhandler;

public class Handler {
    public MessageQueue mQueue;//消息队列
    private Looper mLooper;



    public Handler() {
        mLooper = Looper.myLooper();//获取当前线程的looper对象
        this.mQueue = mLooper.mQueue;
    }



    /**
     * 发送消息，把message对象加入消息队列
     * @param msg
     */
    public void sendMessage(Message msg){
        msg.handler = this;
        //Message消息压入消息队列
        mQueue.enqueueMessage(msg);

    }

    public void dispatchMessage(Message msg){
        handleMessage(msg);

    }

    public void handleMessage(Message msg){


    }



}

2.Looper：消息轮询器。通过ThreadLocal存取Looper，每个线程只允许创建一个Looper，在UI主线程中，已经调用了prepare（）函数实例化了一个Looper，所以不需要程序员去实例化looper，在最后也调用了loop（）函数，开启轮询。若在子线程中实例化Handler对象，则需要先调用prepare（）最后调用loop（）函数。Looper的作用是不断地循环查询消息队列，当发现有消息存在时，会将消息Message从消息队列中取出，将消息Message分发给相应的Handler进行处理。

package mhandler;

public final class Looper {
    //looper对象保存在ThreadLocal，保证了线程数据的隔离
    static final ThreadLocal<Looper> mThreadLocal = new ThreadLocal<Looper>();
    MessageQueue mQueue;

    private Looper(){

        mQueue = new MessageQueue();
    }

    /**
     * 初始化looper，将其加入mThreadLocal
     */
    public static void prepare(){
        if (mThreadLocal.get() != null) {
            throw new RuntimeException("一个线程只能拥有一个looper");

        }
        mThreadLocal.set(new Looper());

    }

    /**
     * 获取looper对象
     * @return
     */
    public static Looper myLooper(){
        return mThreadLocal.get();

    }

    /**
     * 轮询消息队列
     */
    public static void loop(){
        Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("looper空，请先调用prepare()实例化looper对象");

        }
        MessageQueue queue = me.mQueue;
        for (;;) {
            Message msg = queue.next();
            if (msg == null) {
                continue;

            }
            msg.handler.dispatchMessage(msg);

        }

    }

}

3.Message：消息类，持有一个Handler 的引用

package mhandler;

public class Message {
    public int what;
    public Object obj;
    Handler handler;

}

4.MessageQueue：消息队列，以链表的数据结构存取Message，源码中Message对象还有时间when属性，默认情况下，Message的when为存储时的时间，若调用了sendMessageDelayed(Message msg, long delayMillis)函数，则when = 当前时间+delay的时间，MessageQueue会按照时间顺序把Message加入队列。

package mhandler;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MessageQueue {
    Message[] items;//存放消息的数组
    private int putIndex;
    private int takeIndex;
    private int count;

    //互斥锁
    private Lock lock;
    private Condition notEmpty;
    private Condition notfull;

    public MessageQueue() {

        this.items = new Message[50];
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition(); 
        this.notfull = lock.newCondition(); 

    }

    /**
     * 子线程加入消息队列
     * @param msg
     */
    public void enqueueMessage(Message msg){
        try {
            lock.lock();//枷锁
            //消息队列已满，子线程阻塞，停止消息加入队列
            while(count == items.length){
                try {
                    notfull.await();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

            items[putIndex] = msg;
            //如果putIndex等于数组长度，则归零
            putIndex = (++putIndex == items.length) ? 0 : putIndex;
            count ++;
            //通知主线程停止阻塞
            notEmpty.signalAll();


        } finally {
            lock.unlock();

        }



    }

    /**
     * 主线程消息出队
     * @return
     */
    public Message next(){
        try {
            lock.lock();//枷锁
            //消息队列为空，主线程阻塞
            while(count == 0){
                try {
                    notEmpty.await();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

            Message msg = items[takeIndex];
            items[takeIndex] = null;
            takeIndex = (++takeIndex == items.length) ? 0 : takeIndex;
            count --;
            //通知子线程停止阻塞
            notfull.signalAll();
            return msg;

        } finally {
            lock.unlock();

        }


    }

}