Android Hello world程序再分析【Android程序的启动流程】

HelloWorld几乎是每一个程序员学习过程中必会遇到的，所谓温故而知新，今天我们来深入了解一下Android中的helloworld程序。

首先，在eclipse中新建一个Android项目：



然后在MainActivity的onCreate方法中打一个断点



然后调试，进入调试界面，在调试界面中可以看到这样的东西，这里就是我们的程序运行时的方法栈


将这里的方法划分为几个部分



如图中所示：

Android程序启动流程大约可以分为6个部分：

zygote孵化
执行ActivityThread的main方法
执行main方法，轮询
轮询到消息，派发消息
实例化并启动Activity
调用Activity的onCreate方法

接下来结合源码深入分析整个启动流程

1，Zygote孵化：Zygote是Android中第一个DalvikVM，在系统启动时（开机）就启动了，这里这个步骤是启动这个HelloWorld程序，Zygote孵化出一个新的进程（也就是DalvikVM）
2，通过反射找到ActivityThread的main方法，并调用（ invoke）
3，执行ActivityThread的main方法，像所有的java程序一样，Android程序也是从main方法中开始的。这里主要干的事情就是通过Android的消息机制（Looper+Handler+Message）将主线程变成一个轮询线程，不断地从消息队列（MessageQueue）中获取消息（Message）并派发消息（dispatchMessage()）。不明白消息机制的童靴可以看看我另外一篇博客：（自己动手写消息机制）
源码位于:frameworks\base\core\java\android\app\ActivityThread.java

public static void main(String[] args) {

...省略部分我看不懂的代码（hah）

Looper.prepareMainLooper();

...

Looper.loop();//开始轮询

//一般来说程序不会运行到这一行，为什么不会运行到这里呢，我们去看看Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}

源码位于：frameworks\base\core\java\android\os\Looper.java

public static void loop() {
final Looper me = myLooper();//获取当前线程的Looper，main方法中Looper.prepareMainLooper();已经初始化了当前线程的Looper
if (me == null) {
//抛出异常说明没有调用Looper.prepare()来初始化Looper
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;//获取消息队列

...

for (;;) {//这里就是一个死循环，这里我不明白为什么不用while，两者有什么区别，知道的童靴请告诉我一声哈
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;//只有消息为null的情况下才会退出循环
}

...删繁就简，抓住问题的核心

msg.target.dispatchMessage(msg);//派发消息的处理事件
...

msg.recycle();
}
}

4，步骤3中的轮询（Looper）获取到了一个消息（Message），这个Message是ActivityThread中的成员H（H是一个Handler）发来的。这个步骤获取到消息，派发消息，这个消息的处理事件就是启动一个Activity，即是调用ActivityThread中的handlerLaunchActivity()方法，辗转调用
performLaunchActivity()方法。
H是ActivityThread中的一个嵌套类，在ActivityThread的main方法中，通过IPC告诉AMS要启动一个Activity，最后调用了ActivityThread中的handlerLaunchActivity()方法

private class H extends Handler {
public static final int LAUNCH_ACTIVITY         = 100;
...
public void handleMessage(Message msg) {
...
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
ActivityClientRecord r = (ActivityClientRecord)msg.obj;

r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null);//调用ActivityThread的handleLaunchActivity()方法
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
...
}
...
}

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
//主要就是这一句
Activity a = performLaunchActivity(r, customIntent);

if (a != null) {
...
} else {
// If there was an error, for any reason, tell the activity
// manager to stop us.
try {
ActivityManagerNative.getDefault()
.finishActivity(r.token, Activity.RESULT_CANCELED, null);
} catch (RemoteException ex) {
// Ignore
}
}
}

private Activity performLaunchActivity(ActivityClientRecord r,
Intent customIntent) {
// System.out.println("##### [" + System.currentTimeMillis() +
// "] ActivityThread.performLaunchActivity(" + r + ")");

ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}

ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(mInitialApplication
.getPackageManager());
r.intent.setComponent(component);
}

if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
// 准备构造Activity
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
// 这里就是通过反射构造Activity
activity = mInstrumentation.newActivity(cl,
component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException("Unable to instantiate activity "
+ component + ": " + e.toString(), e);
}
}
try {
Application app = r.packageInfo.makeApplication(false,
mInstrumentation);
...
if (activity != null) {
Context appContext = createBaseContextForActivity(r, activity);
...
//调用Activity的attach方法
activity.attach(appContext, this, getInstrumentation(),
r.token, r.ident, app, r.intent, r.activityInfo, title,
r.parent, r.embeddedID,
r.lastNonConfigurationInstances, config);

...
//调用Activity的OnCreate方法
activity.mCalled = false;
mInstrumentation.callActivityOnCreate(activity, r.state);
...
}
r.paused = true;

mActivities.put(r.token, r);

} catch (SuperNotCalledException e) {
throw e;

} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException("Unable to start activity "
+ component + ": " + e.toString(), e);
}
}
return activity;
}

5，步骤4中的performLaunchActivity()方法调用了Instrumentation的callActivityOnCreate()方法，实际上，ActivityThread并没有直接管理Activity，而是通过Instrumentation间接管理Activity，这种关系就像是，ActivityThread是一个外交官，负责与ActivityManagerService沟通，当AMS让ActivityThread启动一个Activity或者rusume一个Activity的时候，ActivityThread就告诉Instrumentation，“帮我启动某某某Activity”，然后Instrumentation就启动相应的Activity，Instrumentation负责实例化Activity并管理Activity的声明周期。

6，MainActivity的onCreate()方法。开发者重写的方法。