大家在编写android项目的时候应该用到Handler了吧.

一般做法应该都是先在主线程中创建一个Handler实例

Handler handler = new Handler{

public void handleMessage(Message msg) {
//做相应处理
}

}

然后通过handler.sendMessage(Message msg)发送消息.

最后在handleMessage()回调中做相应的处理.

那么这里有几个疑问:什么是主线程?发送消息到哪里去了?handleMessage()为什么会被回调?

1.主线程也就是UI线程,所有的处理用户消息,以及绘制界面的工作都在该线程中完成的,UI线程是从ActivityThread运行的,

分析点击android桌面app图标启动应用程序的过程这篇文章第三十二步和三十三步中可以看到,第一次启动应用程序时,系统会为应用程序创建一个进程,从ActivityThread的main()方法开始执行,这个main()也就是UI线程的开始.

2.主线程中用handler发送消息消息发送到哪去了?这里我们来看一下main()方法,

在frameworks/base/core/java/android/app/ActivityThread.java中

public static void main(String[] args) {      ......        Looper.prepareMainLooper();......        Looper.loop();        throw new RuntimeException("Main thread loop unexpectedly exited");    }

这里调用了两个方法Looper.prepareMainLooper()和Looper.loop();

首先看第一个:

在frameworks/base/core/java/android/os/Looper.java中

public static void prepareMainLooper() {        prepare(false);        synchronized (Looper.class) {            if (sMainLooper != null) {                throw new IllegalStateException("The main Looper has already been prepared.");            }            sMainLooper = myLooper();        }    }

接着看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));    }

这里有一个sThreadLocal对象,这是什么呢

public class Looper {    private static final String TAG = "Looper";    // sThreadLocal.get() will return null unless you've called prepare().    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();........

它是Looper类的一个静态成员.ThreadLocal类作用是提供"线程局部存储",简单的理解是:ThreadLocal对象内部会根据调用prepare()函数的线程的id保存一个数据对象,这个数据对象就是所谓的"线程局部存储对象",像这里就是主线程调用的,那么就为主线程保存一个数据对象,这个数据对象就是Looper(上面的泛型就是Looper),第一次调用prepare()函数,sThreadLocal肯定还没有存储的,所以通过sThreadLocal.set()函数设置进去,对应get()函数就是取出来.所以从上面prepare()函数可以看出来,prepare()函数在一个线程中只能调用一次,因为第二次调用该函数,get()获取的就不是null,就会报异常.

一般一个应用程序都在一个进程中,所以ActivityThread类的main()函数只会执行一次,所以prepare()函数只会执行一次.

通过上面分析我们知道,每个线程通过prepareMainLooper()函数调用prepare()函数,设置一个Looper对象,那么它们保存的Looper对象是不相同的.

好了,继续看到主线程的Looper对象是如何构造的.sThreadLocal.set(new Looper(quitAllowed));

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

这里MessageQueue是一个消息队列,上面handler发送的消息就是发送到这个队列里了.消息队列采用排队的方式对消息进行处理,即先到的消息会先得到处理,但如果消息本身指定了被处理的时刻,则必须等到该时刻才能处理该消息.对于消息队列我就没有深究了.

这里就是给Looper对象创建了一个消息队列.

然后回到prepareMainLooper()函数,接着看sMainLooper = myLooper();

 public static Looper myLooper() {        return sThreadLocal.get();    }

这一步其实就是把prepare()函数设置的 Looper对象赋值给sMainLooper变量.

ActivityThread类的main()函数里面的prepareMainLooper()函数做了两件事,第一是创建了一个MessageQueue(消息队列),第二是创建了一个Looper对象,一个线程只有一个Looper对象,因此只有一个MessageQueue(消息对象).

ActivityThread类的main()函数里面的另一个函数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 (;;) {...

这个函数的就是从主线程的Looper对象的消息队列中不断的读取和发送消息.一个死循环吧.

读取消息然后回调对应handler的handleMessage(Message msg) 方法.

上面的三个问题我们了解差不多,但是又有新的疑问,new Handler()发送消息就怎么就会发送到主线程的Looper对象里面的消息队列里面去呢??

好了,我们来看一下Handler的构造方法:

 public Handler() {        this(null, false);    }    public Handler(Callback callback, boolean async) {     ...        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;    }

通过构造函数知道,在构造handler对象时(无参数),首先会取得当前线程对应的looper对象.如果该线程没有设置过looper对象,那么就会报异常.一般在我们在程序中new Handler()都是在主线程中,所以这次获取的是主线程的looper对象,而主线程的looper在程序启动的时候就创建好了(activitythread的main()方法里面),所以平时我们这样创建都没有报错.

这样一来我们也知道了,如果在一个线程中使用handler,那么该线程中必须创建了Looper对象.有了Looper对象也就有了消息队列(它在looper的构造方法里面创建).

这样线程称呼为异步消息线程.

总结一下:异步消息处理线程启动后会进入一个无限的循环体之中，每循环一次，从其内部的消息队列中取出一个消息，然后回调相应的消息处理函数，执行完成一个消息后则继续循环。若消息队列为空，线程则会阻塞等待.

android应用程序的主线程就这样一个异步消息线程.

那么除主线程外,我们自定义线程可不可定义成异步消息线程呢?当然可以,android提供了一个HandlerThread这个类

frameworks/base/core/java/android/os/HandlerThread.java

写一个线程MyThread 继承HandlerThread, 看它的run()方法

   public void run() {        mTid = Process.myTid();        Looper.prepare();        synchronized (this) {            mLooper = Looper.myLooper();            notifyAll();        }        Process.setThreadPriority(mPriority);        onLooperPrepared();        Looper.loop();        mTid = -1;    }

是不是有点熟悉,就是先创建MessageQueue消息队列和Looper对象,然后进入死循环了.那么现在就可以使用handler向该线程的消息队列发送消息了,这里得注意了handler怎么与这个线程的消息队列关联起来.handler另外的构造函数:

 public Handler(Looper looper) {        this(looper, null, false);    }

没错,直接传入该线程的looper对象就可以该线程的looper对象怎么获取呢:

 public Looper getLooper() {        ....      return mLooper;    }

也就是MyThread对象调用getLooper()就可以了.

这样想要往这个线程发送消息,构建一个handler传入looper对象.

我们在项目用得最多的应该是往主线程发送更新UI的消息,因为更新UI必须要在主线程中,不然会报异常.

Android中Handler消息处理机制原理

分析点击android桌面app图标启动应用程序的过程这篇文章第三十二步和三十三步中可以看到,第一次启动应用程序时,系统会为应用程序创建一个进程,从ActivityThread的main()方法开始执行,这个main()也就是UI线程的开始.

2.主线程中用handler发送消息消息发送到哪去了?这里我们来看一下main()方法,

在frameworks/base/core/java/android/app/ActivityThread.java中

public static void main(String[] args) { ...... Looper.prepareMainLooper();...... Looper.loop(); throw new RuntimeException("Main thread loop unexpectedly exited"); }

这里调用了两个方法Looper.prepareMainLooper()和Looper.loop();

首先看第一个:

更多相关文章

随机推荐