Android消息处理机制

引用一段进程的总结作为开头：

进程是程序在计算机上的一次执行活动。当你运行一个程序，你就启动了一个进程。显然，程序是死的(静态的)，进程是活的(动态的)。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程，它们就是处于运行状态下的操作系统本身；所有由你启动的进程都是用户进程。进程是操作系统进行资源分配的单位。在Windows下，进程又被细化为线程，也就是一个进程下有多个能独立运行的更小的单位。

在同一个时间里，同一个计算机系统中如果允许两个或两个以上的进程处于运行状态，这便是多任务。现代的操作系统几乎都是多任务操作系统，能够同时管理多个进程的运行。多任务带来的好处是明显的，比如你可以边听mp3边上网，与此同时甚至可以将下载的文档打印出来，而这些任务之间丝毫不会相互干扰。那么这里就涉及到并行的问题，俗话说，一心不能二用，这对计算机也一样，原则上一个CPU只能分配给一个进程，以便运行这个进程。我们通常使用的计算机中只有一个CPU，也就是说只有一颗心，要让它一心多用，同时运行多个进程，就必须使用并发技术。实现并发技术相当复杂，最容易理解的是“时间片轮转进程调度算法”，它的思想简单介绍如下：在操作系统的管理下，所有正在运行的进程轮流使用CPU，每个进程允许占用CPU的时间非常短(比如10毫秒)，这样用户根本感觉不出来CPU是在轮流为多个进程服务，就好象所有的进程都在不间断地运行一样。但实际上在任何一个时间内有且仅有一个进程占有CPU。如果一台计算机有多个CPU，情况就不同了，如果进程数小于CPU数，则不同的进程可以分配给不同的CPU来运行，这样，多个进程就是真正同时运行的，这便是并行。但如果进程数大于CPU数，则仍然需要使用并发技术。在Windows中，进行CPU分配是以线程为单位的，一个进程可能由多个线程组成，这时情况更加复杂，但简单地说，有如下关系：

总线程数<= CPU数量：并行运行
总线程数 > CPU数量：并发运行

并行运行的效率显然高于并发运行，所以在多CPU的计算机中，多任务的效率比较高。但是，如果在多CPU计算机中只运行一个进程(线程)，就不能发挥多CPU的优势。这里涉及到多任务操作系统的问题，多任务操作系统(如Windows)基本原理是:操作系统将CPU的时间片分配给多个线程,每个线程在操作系统指定的时间片内完成(注意,这里的多个线程是分属于不同进程的).操作系统不断的从一个线程的执行切换到另一个线程的执行,如此往复,宏观上看来,就好像是多个线程在一起执行.由于这多个线程分属于不同的进程,因此在我们看来,就好像是多个进程在同时执行,这样就实现了多任务。

原文地址：http://www.cnblogs.com/kaituorensheng/p/3603057.html

---

线程这个概念在项目中必然是经常使用到的，以简单的MCU来说，都是以一个main来开头，我们称为主线程，在RTOS中，我们还可以分配出多个循环，我们称之为线程。

线程有如下功能：

1. 判断是否发生了某些事件
   使用查询

2. 休眠-唤醒(其他线程或者内核来唤醒)
   线程间通信使用epoll机制，创建一个PIPE管道，子线程来读管道，无数据时休眠，如果主线程发现用户触发控件(按下按键)就去写管道，写操作会导致内核把线程唤醒。比如有A和B两个线程，A-B两个线程间的通信使用”消息”来通信(源码对应Message)，A的消息如果多则需要一个消息队列(源码对应MessageQueue这个类)，B线程负责处理，处理步奏：

   a. 从队列取出消息 
   b. 处理消息   
   

   这两个步奏在内核里面封装为一个Looper
   整个线程间通信的处理过程涉及下面三个过程：
   1.首先创建消息队列(MessageQueue)：由Looper.prepare这个类创建
   2.发消息(内核里面由Handler(创建一个handler实例化对象即new handler)来执行以下步奏 )：

   2.1 new Handler，里面需要getLooper(即信息发送给谁)
   2.2 发消息：Handler.sendMessage，或 sendEmptyMessageAtTime, 或sendMessageDelayed
   

   3.处理消息：
   使用looper循环处理消息(从MessagQueue中取出Message),然后执行队列的处理函数: msg.target.dispatchMessage处理消息

3.处理事件：Handler.Callback(可以自己定义一个方法处理)、post(直接在post对应的run方法里面处理)

---

对应源码解析过程：

******************************************* looper.jave ********************************************


public static void prepare() {
    prepare(true);
}

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));/* 创建一个looper的实例化对象*/
}

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);/* 创建了一个消息队列 */
    mThread = Thread.currentThread();
}

/* looper循环处理消息 */
public static void loop() {
    …
    …
     for (;;) { 
            Message msg = queue.next(); // might block /* 从队列中循环获取消息 */
            if (msg == null) {/* 判断是否取得消息,没有则休眠 */
                // No message indicates that the message queue is quitting.
                return;
            }

    /* 后面则是处理消息 */
    …
    …
        msg.target.dispatchMessage(msg);/* target是一个handler,调用这个handler里面的方法 */
    …
    …
    …
    }
}

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {/* 如果message本身有一个callback的话则调用它里面的run函数处理 */
        handleCallback(msg);
    } else {
        if (mCallback != null) {/*如果在创建handler的时候传入一个callback,则可以使用自己传入的*/
            if (mCallback.handleMessage(msg)) { 
                return;
            }
        }
        handleMessage(msg);
    }
}

private static void handleCallback(Message message) {
    message.callback.run();/* 调用Message的run函数处理 */
}

******************************************* handler.java *******************************************


public final boolean sendMessage(Message msg)
{
    return sendMessageDelayed(msg, 0); /* 第二个参数是时间值,表示可以在若干时间后再来处理消息 */
}

public final boolean sendMessageDelayed(Message msg, long delayMillis) /* 当前时间加上一段时间再发送 */
{
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis)/* 指定一个绝对的时间，到达后发送 */
{
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, uptimeMillis);
}

---

APP编写过程：

功能描述：
添加一个按键，在主线程里面检测按键，一旦按键按下，给两个线程发送消息，这两个线程收到消息后调用各自的触发处理方法，首先添加一个线程不停的处理运行递增显示数据(线程1)，再添加两个线程，一个线程调用使用handler.callback的方式进行处理(线程2)，一个线程使用自带post自带run函数处理(线程3)

代码如下：

package com.lzf.myapplication;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.os.HandlerThread;/* 直接使用HanderThread */

import static java.lang.Thread.sleep;

public class MainActivity extends AppCompatActivity {

    private Button mButton;
    private final String TAG = "MessageTest";
    private int ButtonCount = 0;
    private int mMessageCount = 0;

    /* 线程1 */
    /* 缺点：无法扩展更多的函数 */
    /* 创建子线程，子线程如下，每隔3s发送一次Log */
    private Thread myThread;

    /* 实现一个runnable接口 */
    class MyRunnable implements Runnable{
        public void run(){
            int count = 0;
            for (;;){
                Log.d(TAG, "MyThread "+ count);
                count++;
                try {
                    Thread.sleep(3000);/* 延时 */
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /* 线程2 */
    /* 自定义类继承于Thread，复写run函数 */
    private MyThread myThread2;
    private Handler mHandler2;

    class MyThread extends Thread{
        /* Tip: Ctrl+o可以选择类里面的方法 */

        private Looper mLooper;
        @Override
        public void run() {
            super.run();
            /* 添加 prepare 和 loop 就有了处理消息的功能 */
            Looper.prepare();/* 创建消息队列 */

            synchronized (this) {
                mLooper = Looper.myLooper();/* 一旦创建了Looper，mLooper这个变量就不是null，保证只唤醒一次*/
                notifyAll();/* 唤醒wait */
            }

            Looper.loop();/* for循环，从队列里面取出消息 */
        }

        /* 假设getLooper先于run方法(即looper还未创建就先来获取looper)， */
        public Looper getLooper() {
            if (!isAlive()) { /* 假设如果成立：第一次进来线程是active状态，所以这个if不成立 */
                return null;
            }

            // If the thread has been started, wait until the looper has been created.
            synchronized (this) {
                while (isAlive() && mLooper == null) { /* mLooper还处于NULL的话，就会等待(wait) */
                    try {
                        wait(); /*一旦Looper.prepare执行后要通知线程从wait里面唤醒过来*/
                    } catch (InterruptedException e) {
                    }
                }
            }
            return mLooper;
            //return Looper.myLooper();/* 返回Looper */
        }
    }

    /* 线程3定义 */
    private HandlerThread myThread3;
    private Handler mHandler3;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /* Tip: Shift+F1跳转至说明文档 */
        mButton = (Button)findViewById(R.id.button);
        mButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                // Code here executes on main thread after user presses button
                Log.d(TAG, "Send Message " + ButtonCount);
                ButtonCount++;

                /* 构造消息 */
                Message msg = new Message();
                /* 按键按下时发送message给线程2 */
                mHandler2.sendMessage(msg);

                mHandler3.post(new Runnable() {/* post实现构造消息并且把消息放到队列里面去 */
                    /* 消息处理函数 */
                    @Override
                    public void run() {
                        /* 线程的处理函数 */
                        Log.d(TAG, "get Message for Thread3 "+ mMessageCount);
                        mMessageCount++;
                    }
                });

            }
        });

        /* 实例化对象(线程1) */
        myThread = new Thread(new MyRunnable(),"MessageThread");/* 线程及线程名字 */
        myThread.start();

        /* 实例化对象(线程2) */
        myThread2 = new MyThread();
        myThread2.start();//note :这里start后不一定能马上创建looper，而后面的程序去getlooper可能会出错

        /* 线程2构造handler,这个handler有多种构造方法,callback、looper.... */
        /* 第一个参数这里需要指定looper,给哪个线程发送消息，第二个参数添加处理方法 */
        mHandler2 = new Handler(myThread2.getLooper(), new Handler.Callback() {
            @Override
            public boolean handleMessage(Message msg) { /* 当对应线程的looper收到消息后会调用这个handleMessage来处理 */
                Log.d(TAG, "get Message for Thread2 "+ mMessageCount);
                mMessageCount++;
                return false;
            }
        });

        /* 实例化对象(线程3) */
        myThread3 = new HandlerThread("MessageTestThread3");//带入一个线程名
        myThread3.start();

        mHandler3 = new Handler(myThread3.getLooper());/* 因为post方法已经有了run函数，所以就没必要在添加callback了 */
    }
}

效果如下：