Android面试：一个进程有多少个 Context 对象？看似

前言

• “一个进程有多少 Context 对象？” 这是一个比较初级的问题。但是，从这个问题却可以看出面试者对Android源码是否具备最基本的认识；
• 如果你试图直接从网上寻找答案，而不是自己阅读源码，很可能你会给出这样的答案：Context对象个数 = Service对象个数 + Activity对象个数 + 1， 因为网上 99% 的文章 / 面经就是这么讲的。但是，你觉得他们说得对吗？

目录

作者：彭旭锐
链接：https://www.jianshu.com/p/51d63a1ffb95

1. Context 继承关系

Context是一个抽象类，具体的实现类有Application、Activity、Service与ContextImpl。为方便区分，通常也称为ApplicationConext、ActivityContext与ServiceContext，具体 UML 类图如下：

可以看到，除了我们熟悉的Application、Activity、Service，继承关系上还有ContextWrapper与ContextThemeWrapper，它们的作用 & 职责如下：

• ContextWrapper

  • 定义：Context包装类

  • 作用：持有基础对象的引用(mBase)，并且实现了Context接口，将所有方法调用请求转发给基础对象

// ContextWrapper.java

Context mBase;

public ContextWrapper(Context base) {
    mBase = base;
}

// 【分析点1：绑定基础对象（见todo）】
protected void attachBaseContext(Context base) {
    if (mBase != null) {
        throw new IllegalStateException("Base context already set");
    }
    mBase = base;
}

@Override
public void startActivity(Intent intent) {
    // 转发给 mBase
    mBase.startActivity(intent);
}

• ContextThemeWrapper
  • 定义：Context包装类
    【todo】

---

2. Application 对象

我们都知道，在启动四大组件（Activity、Service、ContentProvider, BroadcastReceiver）时，如果对应的进程未启动，就需要先创建进程，相应地也会创建一个Application对象。简单来说：

• 在system_server进程，通过AMS#getProcessRecordLocked(...)获取进程信息(ProcessRecord)；
• 若不存在，则调用AMS#startProcessLocked(...)创建进程
• 在Zygote孵化目标进程之后，在目标进程反射执行ActivityThread#main()，并最终在ActivityThread#handleBindApplication(...)中创建Application对象

// ActivityThread.java

Application mInitialApplication;
final ArrayList<Application> mAllApplications = new ArrayList<Application>();

private void handleBindApplication(AppBindData data) {
    // ...
    Application app;
    // data.info 为 LoadedApk.java
    app = data.info.makeApplication(data.restrictedBackupMode, null);
    // ...
    mInitialApplication = app;
    // ...
}

// LoadedApk.java

private Application mApplication;

public Application makeApplication(...) {
    // 创建基础对象 ContextImpl
    ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
    // 反射调用创建 Application 对象
    app = mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext);
    // ContextImpl 也持有包装类 Application
    appContext.setOuterContext(app);
    // 保存创建的 Application 对象
    mActivityThread.mAllApplications.add(app);
    mApplication = app;
}

// Instrumentation.java

public Application newApplication(ClassLoader cl, String className, Context context) {
    // 反射调用创建 Application 对象
    Application app = getFactory(context.getPackageName()).instantiateApplication(cl, className);
    app.attach(context);
    return app;
}

// Application.java
final void attach(Context context) {
    // 设置包装类 Application 的基础对象
    attachBaseContext(context);
    mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
}

总结要点如下：

• 一个Application对象相当于存在两个Context对象（代理对象与基础对象）
• Application对象与ContextImpl对象相互引用

---

3. Activity 对象

这一节我们来看Activity对象的创建过程，简单来说：

• 创建Application对象之后，最后在ActivityThread#handleLaunchActivity(...)中创建Activity对象

// ActivityThread.java

public Activity handleLaunchActivity(...) {
    // ...
    final Activity a = performLaunchActivity(r, customIntent);
    // ...
}

private Activity performLaunchActivity(...) {
    // ...
    // 创建基础对象 ContextImpl
    ContextImpl appContext = ContextImpl.createActivityContext(...);
    // 反射调用创建 Activity 对象
    Activity activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
    // 相互引用
    appContext.setOuterContext(activity);
    activity.attach(appContext,...)
    // ...
}

总结要点如下：

• 一个Activity对象相当于存在两个Context对象（代理对象与基础对象）
• Activity对象与ContextImpl对象相互引用

---

4. Service 对象

这一节我们来看Service对象的创建过程，简单来说：

• 创建Application对象之后，startService(...)最后在ActivityThread#handleCreateService(...)中创建Service对象

• 创建Application对象之后，bindService(...)最后在ActivityThread#handleCreateService(...)中创建Service对象，在ActivityThread#handleBindService(...)中绑定Service（注意：两个方法都在远程进程执行）

// ActivityThread.java

private void handleCreateService(...) {
    // ...
    // 反射调用创建 Serivce 对象
    Serivce service = packageInfo.getAppFactory().instantiateService(cl, data.info.name, data.intent);
    // 创建基础对象 ContextImpl
    ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
    // 相互引用
    context.setOuterContext(service);
    service.attach(...);
}

总结要点如下：

• 一个Serivce对象相当于存在两个Context对象（代理对象与基础对象）
• Serivce对象与ContextImpl对象相互引用

---

5. 问题回归

到这里，我们回归开头提出的问题，结论是：Context个数 = Service个数 + Activity个数 + Application个数 + ContextImpl个数。

考虑到Application等与ContextImpl间的代理关系，也可以写为：Context 个数 = 2 x（Service 个数 + Activity 个数 + Application 个数） + 其他 ContextImpl 个数

觉得文章有点意思的，不妨留个赞，点个关注再走呀~文章会持续更新Android面试系列文章哦，为你的面试之路保驾护航，喵喵喵