Android下的多线程下Handler的使用

在Android下面也有多线程的概念，在C/C++中，子线程可以是一个函数，一般都是一个带有循环的函数，来处理某些数据，优先线程只是一个复杂的运算过程，所以可能不需要while循环，运算完成，函数结束，线程就销毁。对于那些需要控制的线程，一般我们都是和互斥锁相互关联，从而来控制线程的进度，一般我们创建子线程，一种线程是很常见的，那就是带有消息循环的线程。
消息循环是一个很有用的线程方式，曾经自己用C在Linux下面实现一个消息循环的机制，往消息队列里添加数据，然后异步的等待消息的返回。当消息队列为空的时候就会挂起线程，等待新的消息的加入。这是一个很通用的机制。
在Android，这里的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper，这个事android的新概念。我们的主线程（UI线程）就是一个消息循环的线程。针对这种消息循环的机制，我们引入一个新的机制Handle，我们有消息循环，就要往消息循环里面发送相应的消息，自定义消息一般都会有自己对应的处理，消息的发送和清除，消息的的处理，把这些都封装在Handle里面，注意Handle只是针对那些有Looper的线程，不管是UI线程还是子线程，只要你有Looper，我就可以往你的消息队列里面添加东西，并做相应的处理。
但是这里还有一点，就是只要是关于UI相关的东西，就不能放在子线程中，因为子线程是不能操作UI的，只能进行数据、系统等其他非UI的操作。
那么什么情况下面我们的子线程才能看做是一个有Looper的线程呢？我们如何得到它Looper的句柄呢？
Looper.myLooper();获得当前的Looper
Looper.getMainLooper () 获得UI线程的Lopper
我们看看Handle的初始化函数，如果没有参数，那么他就默认使用的是当前的Looper，如果有Looper参数，就是用对应的线程的Looper。
如果一个线程中调用Looper.prepare()，那么系统就会自动的为该线程建立一个消息队列，然后调用 Looper.loop();之后就进入了消息循环，这个之后就可以发消息、取消息、和处理消息。这个如何发送消息和如何处理消息可以再其他的线程中通过Handle来做，但前提是我们的Hanle知道这个子线程的Looper，但是你如果不是在子线程运行 Looper.myLooper()，一般是得不到子线程的looper的。

public void run() {
            synchronized (mLock) {
                Looper.prepare();
               //do something
            }
            Looper.loop();
        } 

所以很多人都是这样做的：我直接在子线程中新建handle，然后在子线程中发送消息，这样的话就失去了我们多线程的意义了。

class myThread extends Thread{ 
             private EHandler mHandler ; 
             public void run() { 
                 Looper myLooper, mainLooper; 
                 myLooper = Looper.myLooper (); 
                mainLooper = Looper.getMainLooper (); 
                String obj; 
                if (myLooper == null ){ 
                         mHandler = new EHandler(mainLooper); 
                         obj = "current thread has no looper!" ; 
                } 
                else { 
                     mHandler = new EHandler(myLooper); 
                     obj = "This is from current thread." ; 
                } 
                mHandler .removeMessages(0); 
                Message m = mHandler .obtainMessage(1, 1, 1, obj); 
                mHandler .sendMessage(m); 
             } 
  } 

可以让其他的线程来控制我们的handle，可以把 private EHandler mHandler ;放在外面，这样我们的发消息和处理消息都可以在外面来定义，这样增加程序代码的美观，结构更加清晰。

对如任何的Handle，里面必须要重载一个函数

public void handleMessage(Message msg) 

这个函数就是我们的消息处理，如何处理，这里完全取决于你，然后通过 obtainMessage和 sendMessage等来生成和发送消息， removeMessages(0)来清除消息队列。Google真是太智慧了，这种框架的产生，我们写代码更加轻松了。

有的时候，我们的子线程想去改变UI了，这个时候千万不要再子线程中去修改，获得UI线程的Looper，然后发送消息即可。

我们来看看代码：

// class ac01 extends Activity { 
          // ……… 
              public void onClick(View v) { 
                     switch (v.getId()){ 
                     case 101: 
                                  t = new myThread(); 
                            t .start(); 
                          break ; 
                     case 102: 
                  finish(); 
                                break ; 
                     } 
           } 

//------------------------------------------------------              
class EHandler extends Handler { 
                   public EHandler(Looper looper) { 
                       super (looper); 
                   } 
                   @Override 
                   public void handleMessage(Message msg) { 
                      tv .setText((String)msg. obj ); 
               } 
           } 
//------------------------------------------------------              

  
class myThread extends Thread{ 
             private EHandler mHandler ; 
             public void run() { 
                Looper myLooper, mainLooper; 
                myLooper = Looper.myLooper (); 
                mainLooper = Looper.getMainLooper (); 
                String obj; 
                if (myLooper == null ){ 
                        mHandler = new EHandler(mainLooper); 
                        obj = "current thread has no looper!" ; 
                } 
                else { 
                     mHandler = new EHandler(myLooper); 
                     obj = "This is from current thread." ; 
                } 
                mHandler .removeMessages(0); 
                Message m = mHandler .obtainMessage(1, 1, 1, obj); 
                mHandler .sendMessage(m); 
             } 
  } 
} 
 

完全是不知所云，一坨狗屎。我们来看，在上面的run里面

Looper myLooper, mainLooper; 
myLooper = Looper.myLooper (); //很明显这个会返回空，因为你还没有 prepare，不会返回Looper。 
mainLooper = Looper.getMainLooper (); 
 

建议大家在看Looper的时候不要看高焕堂的书，感觉他也不是很懂，倒还把我搞糊涂了。讲了那么多，完全是他自己的理解，他自己的理解很是复杂，关键的是把简单的问题复杂化，并且复杂之后的东西还是错的。我们看看Goole Music App的源代码。

在MediaPlaybackActivity.java中，我们可以看一下再OnCreate中的有这样的两句：

 mAlbumArtWorker = new Worker("album art worker");
 mAlbumArtHandler = new AlbumArtHandler(mAlbumArtWorker.getLooper()); 

很明显这两句，是构建了一个子线程。并且这个子线程还是Looper的子线程，这里很牛逼的使用了 mAlbumArtWorker.getLooper()这个函数，因为我们知道，我们能够得到子线程的Looper的途径只有一个：就是在子线程中调用 Looper.myLooper ()，并且这个函数还要在我们perpare之后调用才能得到正确的Looper，但是他这里用了一个这样的什么东东 getLooper，不知道它是如何实现的？

这里有一个大概的思路，我们在子线程的的prepare之后调用 myLooper ()这个方法，然后保存在一个成员变量中，这个getLooper就返回这个东西，但是这里会碰到多线程的一个很突出的问题，同步。我们在父线程中调用 mAlbumArtWorker.getLooper()，但是想要这个返回正确的looper就必须要求我们的子线程运行了prepare，但是这个东西实在子线程运行的，我们如何保证呢？

我们看Google是如何实现的？

 private class Worker implements Runnable {
        private final Object mLock = new Object();
        private Looper mLooper;
        
        /**
         * Creates a worker thread with the given name. The thread
         * then runs a {@link android.os.Looper}.
         * @param name A name for the new thread 
         */
        Worker(String name) {
            Thread t = new Thread(null, this, name);
            t.setPriority(Thread.MIN_PRIORITY);
            t.start();
            synchronized (mLock) {
                while (mLooper == null) {
                    try {
                        mLock.wait();
                    } catch (InterruptedException ex) {
                    }
                }
            }
        }
        
        public Looper getLooper() {
            return mLooper;
        }
        
        public void run() {
            synchronized (mLock) {
                Looper.prepare();
                mLooper = Looper.myLooper();
                mLock.notifyAll();
            }
            Looper.loop();
        }
        
        public void quit() {
            mLooper.quit();
        }
    }

 

我们知道，一个线程类的构造函数是在主线程中完成的，所以在我们的 Worker的构造函数中我们创佳一个线程，然后让这个线程运行，这一这个线程的创建是指定一个 Runnabl，这里就是我们的Worker本身，在主线程调用 t.start();，这后，我们子线程已经创建，并且开始执行work的run方法。然后下面的代码很艺术：

synchronized (mLock) {
                while (mLooper == null) {
                    try {
                        mLock.wait();
                    } catch (InterruptedException ex) {
                    }
                }
            } 

我们开始等待我们的子线程给mLooper赋值，如果不赋值我们就继续等，然后我们的子线程在运行run方法之后，在给 mLooper赋值之后，通知worker够着函数中的wait，然后我们的构造函数才能完成，所以我们说：

mAlbumArtWorker = new Worker("album art worker"); 

这句本身就是阻塞的，它创建了一个子线程，开启了子线程，并且等待子线程给mLooper赋值，赋值完成之后，这个函数才返回，这样才能保证我们的子线程的Looper的获取绝对是正确的，这个构思很有创意。值得借鉴。

android消息机制，异步和多线程

自从framework广泛应用后，我们不用面对赤裸裸的手机操作系统API，做一些重复而繁杂没有意义的事情。但天下没有免费的午餐，我们还是需要学会高效正确的使用不同的framework，很多处理某一特定问题的手法在不同的framework中，用起来都会有所不同的。今天我们主要学习andorid framework的使用。
　　在Android中，下层是Linux的核，但上层的java做的framework把这一切封装的密不透风。以消息处理为例，在MFC中，我们可以用PreTranslateMessage等东东自由处理消息，在C#中，Anders Hejlsberg老大说了，他为我们通向底层开了一扇“救生窗”，但很遗憾，在Android中，这扇窗户也被关闭了（至少我现在没发现…）。
　　在Android中，你想处理一些消息（比如：Keydown之类的…），你必须寻找Activity为你提供的一些重载函数（比如 onKeyDown之类的…）或者是各式各样的listener（比如OnKeyDownListner之类的…）。这样做的好处是显而易见的，越多的自由就会有越多的危险和越多的晦涩，条条框框画好了，用起来省心看起来省脑，这是一个设计良好的framework应该提供的享受。对于我目前的工程而言，我没有什么BT的需求在当前API下做不到的，google的设计ms还是很nice的。
　　但世界是残酷的，有的时候我们还是必须有机制提供消息的分发和处理的，因为有的工作是不能通过直接调用来同步处理的，同时也不能通过Activity中内嵌的消息分发和接口设定来做到，比如说事件的定时触法，异步的循环事件的处理，高耗时的工作等等。在Android中，它提供了一些蛮有意思的方式来做这件事情（不好意思，我见不多识不广，我没见过类似玩法，有见过的提个醒 && 嘴下超生^_），它有一个android.os.Handler的类，这个类接受一个Looper参数，顾名思义，这是一个封装过的，表征消息循环的类。默认情况下，Handler接受的是当前线程下的消息循环实例，也就是说一个消息循环可以被当前线程中的多个对象来分发，来处理（在UI线程中，系统已经有一个Activity来处理了，你可以再起若干个Handler来处理…）。在实例化一个 handlerInstance之后，你可以通过sendMessage等消息发送机制来发送消息，通过重载handleMessage等函数来分发消息。但是！该handlerInstance能够接受到的消息，只有通过handlerInstance.obtainMessage构造出来的消息（这种说法是不确切的，你也可以手动new一个Message，然后配置成该handlerInstance可以处理的，我没有跟进去分析其识别机制，有兴趣的自己玩吧^_）。也就是说A, B, C, D都可以来处理同一线程内的消息分发，但各自都只能处理属于自己的那一份消息，这抹杀了B想偷偷进入A领地，越俎代庖做一些非份之事的可能（从理论上看，B还是有可能把消息伪装的和A他们家的一样，我没有尝试挑战一下google的智商，有BT需求的自行研究^_）。这样做，不但兼顾了灵活性，也确保了安全性，用起来也会简单，我的地盘我做主，不用当心伤及无辜，左拥右抱是一件很开心的事情。。。
　　很显然，消息发送者不局限于自己线程，否者只能做一些定时，延时之类的事情，岂不十分无趣。在实例化Handler的时候，Looper可以是任意线程的，只要有Handler的指针，任何线程也都可以sendMessage（这种构造方式也很有意思，你可以在A线程里面传B线程的Looper来构造 Handler，也可以在B线程里构造，这给内存管理的方法带来很大的变数…）。但有条规则肯定是不能破坏的，就是非UI线程，是不能触碰UI类的。在不同平台上有很多解决方式（如果你有多的不能再多的兴趣，可以看一下很久很久以前我写的一个，不SB不要钱）。我特意好好跟了一下android中的AsyncQueryHandler类，来了解google官方的解决方案。
　　AsyncQueryHandler是Handler的子类，文档上说，如果处理ContentProvider相关的内容，不用需要自行定义一套东西，而可以简单的使用async方式。我想指代的就应该是AsyncQueryHandler类。该类是一个典型的模板类，为ContentProvider 的增删改查提供了很好的接口，提供了一个解决架构，final了一些方法，置空了一些方法。通过派生，实例化一些方法（不是每个对 ContentProvider的处理多需要全部做增删改查，我想这也是该类默认置空一些方法而不是抽象一些方法的原因），来达到这个目的。在内部，该类隐藏了多线程处理的细节，当你使用时，你会感觉异常便利。以query为例，你可以这么来用：

// 定义一个handler，采用的是匿名类的方式，只处理query，因此只重写了onQueryComplete函数：
queryHandler = new AsyncQueryHandler(this.getContentResolver()){ // 传入的是一个ContentResolver实例，所以必须在OnCreate后实例化该Handler类
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
        // 在这里你可以获得一个cursor和你传入的附加的token和cookie。
        // 该方法在当前线程下（如果传入的是默认的Looper话），可以自由设定UI信息
    }
　　调用时只需要调用startQuery(int token, Object cookie, ContentURI uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)函数即可：
queryHandler.startQuery(token, cookie, uri, projection, selection, selectionArgs, sortBy);

可见，该类的使用是多么简单（其实现可不会很容易，因为我尝试做了一次造车轮的工作**），比直接用Handler简单无数倍。但让我倍感孤独的是，不知道是没人做异步的ContentProvider访问，还是这个类使用太过于弱智（这个使用方法可是我摸索了半天的啊，难道我真的如此的弱@@），抑或是大家都各有高招，从SDK到网上，没有任何关于该类的有点用的说明。而我又恰巧悲伤的发现，这个类其实有很多的问题，比如他吃掉异常，有错误时只是简单的返回null指针（这个其实不能怪他，你可以看看这里…）；当你传一个null的ContentResolver进去的时候，没有任何异常，只是莫名其妙的丢弃所有消息，使你陷入苦苦的等待而不知其因；更愤慨的是，他的token传递竟然有Bug（难道还是我使用不对&&），从startXX传入的token，到了onXXComplete里面一律变成1，而文档上明明写着两个是一个东西（我的解决方法是用cookie做token，这个不会丢**）。不过我暂时还没有遗弃它的打算，虽然没人理睬，虽然有一堆问题，虽然我按图索骥造了个新轮子，但为了节省剩下的一些无聊的工作，我决定苟且偷生了。。。
　　还是习惯性跑题了，其实，我是想通过我对这个类的无数次Debugger跟进，说说它的多线程异步处理的解决策略的。他的基本策略如下：
　　1. 当你实例化一个AsyncQueryHandler类时（包括其子类…），它会单件构造一个线程（后面会详述…），这个线程里面会构建一个消息循环。
　　2. 获得该消息循环的指针，用它做参数实例化另一个Handler类，该类为内部类。至此，就有了两个线程，各自有一个Handler来处理消息。
　　3. 当调用onXXX的时候，在XXX函数内部会将请求封装成一个内部的参数类，将其作为消息的参数，将此消息发送至另一个线程。
　　4. 在该线程的Handler中，接受该消息，并分析传入的参数，用初始化时传入的ContentResolver进行XXX操作，并返回Cursor或其他返回值。
　　5. 构造一个消息，将上述返回值以及其他相关内容绑定在该消息上，发送回主线程。
　　6. 主线程默认的AsyncQueryHandler类的handleMessage方法（可自定义，但由于都是内部类，基本没有意义…）会分析该消息，并转发给对应的onXXXComplete方法。
　　7. 用户重写的onXXXComplete方法开始工作。
　　这就是它偷偷摸摸做过的事情，基本还是很好理解的。我唯一好奇的是它的线程管理方式，我猜测他是用的单件模式。第一个AsyncQueryHandler的实例化会导致创建一个线程，从此该线程成为不死老处男，所有的ContentResolver相关的工作，都由该线程统一完成。个人觉得这种解决方式很赞。本来这个线程的生命周期就很难估量，并且，当你有一个ContentProvider的请求的时候，判断你会做更多的类似操作并不过分。就算错了，花费的也只是一个不死的线程（与进程同生死共存亡…），换来的却是简单的生命周期管理和无数次线程生死开销的节约。同时另外一个很重要的问题，他并会涉及到单件中数据同步的问题，每个类都有各自的Handler类，彼此互不干扰，分发可以分别进行。当多个数据请求的时候，在同一个ContentResolver上进行的可能微乎其微，这就避免了堵塞。总而言之，这套解决办法和Android的整体设计算是天作之合了。
　　建议，如果你有什么非ContentProvider操作，却需要异步多线程执行的话，模拟一套，是个不错的策略，当然，具体情况具体分析，生搬硬套是学不好马列主义的。。。android的消息机制，异步和多线程其实并不复杂，只要有心，就能够学会。