关于作者：CSDN内容合伙人、技术专家，从零开始做日活千万级APP。
专注于分享各领域原创系列文章，擅长java后端、移动开发、人工智能等，希望大家多多支持。

在这里插入图片描述

一、导读

我们继续总结学习Android 基础知识，温故知新。

还是在多年前做系统应用开发的时候，通过编译源码学习了一遍APP的启动过程，
最近在整理应用启动优化相关的文档，打算重新梳理一遍，并整理成一个通俗易懂的文档，以备后面查看。
在学习过程中，大家最好是把源码下载下来。

1.1 启动知识储备

启动过程比较复杂，涉及到的知识点非常多，建议通过其他文章进行学习。

1.2 Zygote进程

Zygote进程是Android设备启动时由init进程创建和启动，之后不断接收来自应用程序的请求。
Zygote进程预先创建一个虚拟机和一些共享资源，以提高应用程序的启动速度和系统资源的利用效率。
同时，Zygote进程也负责处理应用程序进程的环境初始化和加载核心类库等操作。
每当有新的应用程序启动请求到达时，Zygote进程会fork出一个子进程（应用程序进程）来运行该应用程序。

1.3 SystemServer进程

SystemServer进程是Android操作系统的一个关键进程，它在设备启动时由init进程创建的。

SystemServer进程是一个守护进程，在系统运行期间一直存在，负责启动和管理各个核心系统服务，如AMS、Window Manager、Package Manager等。

1.4 AMS（Activity Manager Service）

AMS（Activity Manager Service）是SystemServer进程中的一个关键组件，负责管理所有应用程序的生命周期和交互。它监控应用程序的启动、暂停、恢复和销毁，
并协调应用程序之间的切换和交互。除此之外，AMS还处理任务栈管理、权限管理、用户通知等相关任务。

1.5 APP进程（ActivityThread）

APP进程是指在Android系统中运行的应用程序进程。每个运行的应用程序都会分配一个或多个独立的APP进程来承载应用的执行环境。
每个APP进程都是Zygote进程通过fork系统调用创建的子进程。

ActivityThread 是Android应用程序的主线程，负责管理和调度应用程序中的所有Activity的生命周期以及处理一些系统事件。

ActivityThread的主要职责包括：

创建和启动应用程序的主Activity。
处理应用程序的消息循环，接收和分发来自系统和应用程序的消息。
管理应用程序的所有Activity的生命周期，包括创建、启动、暂停、恢复、停止和销毁等。
处理应用程序的资源加载和更新，包括布局文件、图片、字符串等资源的加载。
处理应用程序的窗口管理，包括窗口的创建、显示、隐藏和更新等操作。
与AMS (Activity Manager Service)通信，处理Activity的启动、停止、切换等请求，并接收来自AMS的指令和请求。
处理应用程序的异常错误，包括崩溃、ANR (Application Not Responding)等情况的处理。

二、启动流程概览

涉及到多个进程之间的通信：
1、用户点击图标后，Laucher（手机桌面）会通过binder的方式通知SystemServer进程。
2、SystemServer收到信息，内部的AMS（Activity Manager Service）通知Zygote去创建APP进程，通过反射调用ActivityThread.main方法，即创建主线程。
3、APP进程创建后（Zygote进行fork），通过回调通知AMS。
4、AMS收到信息后经过一些列调用，通知APP进程（ActivityThread）创建Application
5、Application 之后，继续执行调用到ClientLifecycleManager，进行Activity创建等过程

我们画个简单的图

在这里插入图片描述

下面贴一下代码：

2.1 用户点击桌面图标

Launcher获取到AMS的binder，之后进入到SystemServer进程。

然后调用的zygote进程，fork出一个新的app进程。

2.2 创建app进程

ActivityThread


应用进程启动的入口函数main()方法中，会调用Looper相关的初始化和循环方法，从而让主线程的Looper进入循环状态，保证app进程的一直运行状态

    public static void main(String[] args) {
   
   
        . ..
        //looper绑定主线程
        Looper.prepareMainLooper();

        创建ActivityThread
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);


        //looper开启无限循环读取消息
        Looper.loop();

            . ..
    }


    private void attach(boolean system, long startSeq) {
   
   

        if (!system) {
   
   
            . ..
            final IActivityManager mgr = ActivityManager.getService();
            try {
   
   
                // 通知 AMS， 并将当前进程的binder句柄传给AMS绑定管理起来
                mgr.attachApplication(mAppThread, startSeq);
            } catch (RemoteException ex) {
   
   
            }
            . ..
        }

        . ..
    }

attachApplication 这个流程会分两步:
1、创建应用的application对象
2、activity启动显示

2.3 创建 application

IActivityManager.aidl


    void attachApplication(in IApplicationThread app, long startSeq);

ActivityManagerService


// 这里接受APP传递过来的消息
    @Override
    public final void attachApplication(IApplicationThread thread, long startSeq) {
   
   
        synchronized (this) {
   
   
            // 通过 Binder 获取 PID ，PID和UID都是进程创建应用的时候系统指定的
            int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final long origId = Binder.clearCallingIdentity();

            attachApplicationLocked(thread, callingPid, callingUid, startSeq);
        }
    }


    @GuardedBy("this")
    private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
   
   


        // *** 1、通知APP进程进行初始化操作，初始化application，创建应用进程的application对象
        if (app.isolatedEntryPoint != null) {
   
   

        } else if (app.instr != null) {
   
   
            thread.bindApplication(processName, appInfo, providers, ...);
        } else {
   
   
            thread.bindApplication(processName, appInfo, providers, ...);
        }


        // *** 2、 通知APP拉起指定的MainActivity，调用ATMS的启动页面的方法，后面继续介绍
        // See if the top visible activity is waiting to run in this process...
        if (normalMode) {
   
   
            try {
   
   
                if (mStackSupervisor.attachApplicationLocked(app)) {
   
   
                    didSomething = true;
                }
            } catch (Exception e) {
   
   
            }
        }
    }

IApplicationThread.aidl


void bindApplication(in String packageName, in ApplicationInfo info, ...);

我们来看看 Application 是如何创建的
ActivityThread


由AMS调用过来，具体看上面的代码
public final void bindApplication(String processName, ApplicationInfo appInfo, ...) {
   
   

        sendMessage(H.BIND_APPLICATION, data);
}

public void handleMessage(Message msg) {
   
   

    switch (msg.what) {
   
   
        case BIND_APPLICATION:

        AppBindData data = (AppBindData)msg.obj;
        handleBindApplication(data);
        break;

        . ..
    }
}


private void handleBindApplication(AppBindData data) {
   
   

    Application app;
    try{
   
   
        classLoader加载APK中的dex，并且加载APK的资源
        final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
                appContext.getClassLoader(), false, true, false);
        final ContextImpl instrContext = ContextImpl.createAppContext(this, pi);

        通过 calssLoader 来创建 application 对象
        app=data.info.makeApplication(data.restrictedBackupMode,null);


        try{
   
   
            调用Application的onCreate

            mInstrumentation.onCreate(data.instrumentationArgs);
        }catch(Exception e){
   
   
        }
        try{
   
   
            mInstrumentation.callApplicationOnCreate(app);
        }catch(Exception e){
   
   

        }
    } ... 
}


public Application newApplication(ClassLoader cl, String className, Context context) 。。{
   
   
    Application app = getFactory(context.getPackageName()).instantiateApplication(cl, className);
    app.attach(context);
    return app;
}


(Application) cl.loadClass(className).newInstance();

在这里插入图片描述

2.4 activity启动显示

接着上面的代码 mStackSupervisor.attachApplicationLocked(app)；

ActivityStackSupervisor
方法realStartActivityLocked();


    boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
   
   
        final String processName = app.processName;
        boolean didSomething = false;


        Activity启动的入口
        try {
   
   
            if (realStartActivityLocked(activity, app, top == activity, true)) {
   
   

            }
        } catch (RemoteException e) {
   
   
        }
        return didSomething;
    }

    真的开始启动 activity
    final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
   
   

            // Create activity launch transaction.
            final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                    r.appToken);
                    clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                    System.identityHashCode(r), r.info,
                    // TODO: Have this take the merged configuration instead of separate global
                    // and override configs.
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), r.compat,
                    r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                    r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                    profilerInfo));

            // Schedule transaction.
            mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    }

ActivityManagerService


    ClientLifecycleManager getLifecycleManager() {
   
   
        return mLifecycleManager;
    }

ClientLifecycleManager

    通过代码，我们可以看到，获取的client就是 ActivityThread，IApplicationThread是一个AIDL文件
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
   
   
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();

    }

ClientTransaction


    /** Target client. */
    private IApplicationThread mClient;

    public void schedule() throws RemoteException {
   
   
        mClient.scheduleTransaction(this);
    }

ClientTransactionHandler


    //ActivityThread中没有复写scheduleTransaction，会执行到父类的方法
    //public final class ActivityThread extends ClientTransactionHandler
    //ClientTransactionHandler.java
    public abstract class ClientTransactionHandler {
   
   

        void scheduleTransaction(ClientTransaction transaction) {
   
   
            transaction.preExecute(this);
            //发送消息
            sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
        }
    }

ActivityThread.java


    case EXECUTE_TRANSACTION:
        final ClientTransaction transaction = (ClientTransaction) msg.obj;
        mTransactionExecutor.execute(transaction);
        break;

继续一系列调用
在这里插入图片描述

最后调用到ActivityThread，创建并启动Activity，由于篇幅原因，Activity资源加载相关的内容我们在另一篇文章介绍。


    /**
     * Extended implementation of activity launch. Used when server requests a launch or relaunch.
     */
    @Override
    public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
   
   

        final Activity a = performLaunchActivity(r, customIntent);


        return a;
    }

    Activity实例化过程

    /**  Core implementation of activity launch. */
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
   
   

        Activity activity = null;
        try {
   
   
            // 通过反射实例化Activity对象
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
        } catch (Exception e) {
   
   
        }

        window

        theme

        //当实例化Activity对象后，继续执行callActivityOnCreate
        if (r.isPersistable()) {
   
   
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
   
   
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }
    }

接下来就是执行 Activity 生命周期函数

所用的源码不同，代码可能会有些许差别。

三、推荐阅读

Android应用启动流程：从启动到可交互的过程解析

一、导读

1.1 启动知识储备

1.2 Zygote进程

1.3 SystemServer进程

1.4 AMS（Activity Manager Service）

1.5 APP进程（ActivityThread）

二、启动流程概览

2.1 用户点击桌面图标

2.2 创建app进程

2.3 创建 application

2.4 activity启动显示

三、推荐阅读

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

Android应用启动流程：从启动到可交互的过程解析

一、导读

1.1 启动知识储备

1.2 Zygote进程

1.3 SystemServer进程

1.4 AMS（Activity Manager Service）

1.5 APP进程（ActivityThread）

二、启动流程概览

2.1 用户点击桌面图标

2.2 创建app进程

2.3 创建 application

2.4 activity启动显示

三、 推荐阅读

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

三、推荐阅读