Android的消息循环与Handler机制理解 4年前

一、概念

1、事件驱动型

什么是事件驱动？就是有事了才去处理，没事就躺着不动。假如把用户点击按钮，滑动页面等这些都看作事件，事件产生后程序就执行相应的处理方法，就是属于事件驱动型。

2、消息循环

把需要处理的事件表示成一个消息，并且把这个消息放入一个队列。消息循环就是一循环，for或者while都一样。从消息队列里面取出未处理的消息，然后调用该消息的处理方法。

3、Handler

最开始碰到handler是需要在子线程里面更新UI的时候。android的UI更新只能在主线程中进行，但是在子线程中执行的逻辑又需要更新UI，例如文件下载，在子线程中访问网络下载之后，就是更新下载进度。这个时候就需要使用Hanlder，准确的说是要发送一个进度更新的消息。什么是Handler？我的理解是消息的处理者。create消息对应一个create的Handler，destroy消息对应一个destroy的Handler。

二、实现

只是说说概念太假了，下面就来实现一个简单的消息处理机制。

1、Msg

把产生的事件用消息来表示，数据用各个参数传递。

copy
public class Msg implements Serializable{
    //序列化标识
    private static final long serialVersionUID = -2414053244664115328L;
    
    //该消息的处理者。
    private int handlerId;
    
    //参数。
    public Object arg1;
    public Object arg2;

    //大量参数
    public Object array[];
    
    public Msg(int handlerId) {
        this.handlerId=handlerId;
    }
    
    public void setHandlerId(int handlerId) {
        this.handlerId=handlerId;
    }
    public int getHandleId() {
        return handlerId;
    }
}

2、Handler

事件的处理者

copy
public abstract class Handler {
    //唯一标识，由Looper分配
    private int id;
    
    //使用该Handler的Looper
    private Looper looper;
    
    public Handler(Looper looper) {
        this.looper=looper;
        id=looper.addMsgHandler(this);
    }
    
    //消息处理函数
    abstract public  boolean handleMsg(Msg msg);
    
    //添加一个未处理消息。
    public void sendMsg(Msg msg) {
        looper.addMsg(msg);
    }
    
    //返回该handler的信使。
    public Msg obtainMsg() {
        return new Msg(id);
    }
}

3、Looper

消息循环

copy
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

public class Looper {
    private int handlerCount=0;
    //消息队列。
    private Queue<Msg> msgQueue=new LinkedList<Msg>();
    //消息的处理。
    private Map<Integer, Handler> msgHandler=new HashMap<>();
    
    //loop
    public void loop() {
        for(;true;)
            if(!msgQueue.isEmpty())
                if(!distributeMsg(msgQueue.poll()))
                //当消息处理返回false时。程序结束。
                    break;    
    }
    
    //添加处理消息的handler
    public int addMsgHandler(Handler handler) {
        handlerCount++;
        msgHandler.put(handlerCount,handler);
        return handlerCount;
    }
    
    //添加待处理的消息
    public void addMsg(Msg msg) {
        msgQueue.add(msg);
    }
    
    //消息分发
    private boolean distributeMsg(Msg msg) {
        Handler handler=msgHandler.get(msg.getHandleId());
        if(handler!=null) {
            handler.handleMsg(msg);
        }else {
            //出现未知消息，程序结束。
            System.out.println("exit");
            return false;
        }
        return true;    
    }
}

4、模拟生命周期

copy
abstract class Basic{
    private Looper mainLooper=new Looper();
    private Handler sysHandler=new Handler(mainLooper) {
                @Override
                public boolean handleMsg(Msg msg) {
                    if(msg.arg1.equals("create")) {
                        onCreate();
                    }
                    if(msg.arg1.equals("destroy")) {
                        onDestroy();
                    }
                    return true;
                }
            };
    
    public Basic() {
        Msg m=sysHandler.obtainMsg();
        m.arg1="create";
        sysHandler.sendMsg(m);
        //新获取一个Msg,不能沿用上一个。
        m=sysHandler.obtainMsg();
        m.arg1="destroy";
        sysHandler.sendMsg(m);
    }
    
    public Looper getMainLooper() {
        return mainLooper;
    }
    
    /**
     * 生命周期
     */
    abstract public void onCreate();
    abstract public void onDestroy();
}

上面的代码创建了一个抽象类Basic，在里面注册了一个处理create和destroy两个消息的Handler。

5、子线程调用主线程的方法。

copy
public class Main extends Basic{
    private final Handler handler
        =new Handler(getMainLooper()) {
        @Override
        public boolean handleMsg(Msg msg) {
            // TODO Auto-generated method stub
            System.out.println("msg.arg1="+msg.arg1+",Tid="+
            Thread.currentThread().getId());
            getMainLooper().addMsg(new Msg(-1));
            return true;
        }
    };
    public void onCreate() {
        System.out.println("..............onCreate");
        System.out.println("mainThread Tid="+Thread.currentThread().getId());
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("childThread Tid="+Thread.currentThread().getId());
                Msg msg=handler.obtainMsg();
                msg.arg1="childCall";
                handler.sendMsg(msg);
            }
        }).start();
    }
    @Override
    public void onDestroy() {
        // TODO Auto-generated method stub
        System.out.println(".............onDestroy");
        //getMainLooper().addMsg(new Msg(-1));
    }
    public static void main(String[] args) {
        new Main().getMainLooper().loop();
    }
}

6、结果

结果分析，首先是两个生命周期的方法被调用，其次是实现了子线程调用主线程的方法。这里子线程转到主线程的原因是因为Looper运行在主线程，消息由Looper分发处理。