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 的内部类，我们可以看到，这里的逻辑结构也是特别简单。
定义了58种状态，这些状态包含四大组件（主要），Application，Windows等的不同状态。
将状态值转换成 flag 对应的字符串，主要用于使用 Log 的时候输出。
最核心的就是通过这个状态值进行相应的处理：重写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++实现的。
