ActivityThread 中的 H 用来干嘛的

ActivityThread 这个类呢，是整个Android的入口，main方法就位于这个类中，今天就理一理这个 H，作为学习Handler的一个练习。

如果对 Handler 不是很了解的呢，可以参看这篇文章。

在这里简单回顾一下 Handler 的使用：

public class MainActivity extends AppCompatActivity {

    private TextView textView;
    private String TAG = "MainActivity";

    Handler mHandler = new Handler(){
        /**
         * handleMessage接收消息后进行相应的处理
         * @param msg
         */
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if(msg.what==1){
                textView.setText(msg.arg1+"");
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.textView);
        textView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                    //创建新的线程
                    new Thread(){
                        @Override
                        public void run() {
                            super.run();
                            doSendMsg();
                        }
                  }.start();
            }
        });
    }

    /**
     * 在子线程中做耗时操作，完成之后，通知Handler更新UI
     */
    private void doSendMsg(){
        try {
            Thread.sleep(1000);//模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Message message = Message.obtain();
        message.arg1 = 222;
        message.what = 1;
        mHandler.sendMessage(message);
    }

}

可以看见，在两个线程中，都可以拿到这个 Handler 的引用，持有这个引用就代表着能够访问另一个线程的内存空间，即我可以访问另一线程的消息队列，进行增加操作，而这个的基础就是，进程是分配资源的单位，而进程内的线程共享这些资源（包括内存）。

现在就拿这个模式去 ActivityThread 中套一下，理解下。

先看看 H 是什么东东

    private class H extends Handler {
        public static final int LAUNCH_ACTIVITY         = 100;
        public static final int PAUSE_ACTIVITY          = 101;
        ...
        // 100 - 157 顺序排列的标志位：包括四大组件的状态等
        public static final int ATTACH_AGENT = 155;
        public static final int APPLICATION_INFO_CHANGED = 156;
        public static final int ACTIVITY_MOVED_TO_DISPLAY = 157;

        String codeToString(int code) {
            if (DEBUG_MESSAGES) {
                switch (code) {
                    case LAUNCH_ACTIVITY: return "LAUNCH_ACTIVITY";
                    case PAUSE_ACTIVITY: return "PAUSE_ACTIVITY";
                    ...
                    // 将上面定义的标志位转换成对应的字符串
                    case LOCAL_VOICE_INTERACTION_STARTED: return "LOCAL_VOICE_INTERACTION_STARTED";
                    case ATTACH_AGENT: return "ATTACH_AGENT";
                    case APPLICATION_INFO_CHANGED: return "APPLICATION_INFO_CHANGED";
                }
            }
            return Integer.toString(code);
        }
        public void handleMessage(Message msg) {
            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
            switch (msg.what) {
                case LAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;
                case RELAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
                    ActivityClientRecord r = (ActivityClientRecord)msg.obj;
                    handleRelaunchActivity(r);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;
                ...
                // 按着处理58种信息
                case ATTACH_AGENT:
                    handleAttachAgent((String) msg.obj);
                    break;
                case APPLICATION_INFO_CHANGED:
                    mUpdatingSystemConfig = true;
                    try {
                        handleApplicationInfoChanged((ApplicationInfo) msg.obj);
                    } finally {
                        mUpdatingSystemConfig = false;
                    }
                    break;
            }
            Object obj = msg.obj;
            if (obj instanceof SomeArgs) {
                ((SomeArgs) obj).recycle();
            }
            if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
        }
    }

这是 ActivityThread 的内部类，我们可以看到，这里的逻辑结构也是特别简单。

1. 定义了58种状态，这些状态包含四大组件（主要），Application，Windows等的不同状态。

2. 将状态值转换成 flag 对应的字符串，主要用于使用 Log 的时候输出。

3. 最核心的就是通过这个状态值进行相应的处理：重写handleMessage(Message msg) 方法。例如，在app中创建一个 Activity 最终就通过binder调用远程服务，最后调到第一个case中的handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");通过类加载器创建一个 Activity

认识到 H 大概干了什么，那 H 在哪里实列的呢？

main方法了解一下：

    public static void main(String[] args) {
        ....

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        ...
        Looper.loop();
        ...
    }

其实很简单，这里就在主线程准备 Looper ，并且实例了 ActivityThread ，下一步就是生成Application等等，然后启动了 Looper。

这里就有几个问题了，Handler是用来切换线程的，那切换的是哪些线程嘞，答案就是在 binder 线程与主线程的切换。binder线程在哪里生成的呢？是在一个进程fork出来，然后就会直接生成binder线程，实现是用C++实现的。