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

Love The Way You Lie 2023-10-14 15:11 6阅读 0赞

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

#### 目录 ####

*  一、导读
 *   *  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启动显示
 *  三、 推荐阅读

![在这里插入图片描述][f5ba2a630958460ab6a581523327cf4d.png]

## 一、导读 ##

我们继续总结学习**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的主要职责包括：

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

我们画个简单的图  
![图片][223eed4707e44b34a557aaed02cf492d.png]  
![在这里插入图片描述][9f89340d00df4e1fa70922b8783a9a49.png]

下面贴一下代码：

### 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();

![在这里插入图片描述][c472cc637f604ab7bb16199a9502dc24.png]

### 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;

继续一系列调用  
![在这里插入图片描述][c6e5264408e448afaab861926822fe4f.png]

最后调用到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 生命周期函数

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

## 三、 推荐阅读 ##

[Java 专栏][Java]

[SQL 专栏][SQL]

[数据结构与算法][Link 1]

[Android学习专栏][Android]

[f5ba2a630958460ab6a581523327cf4d.png]: https://img-blog.csdnimg.cn/f5ba2a630958460ab6a581523327cf4d.png
[223eed4707e44b34a557aaed02cf492d.png]: https://img-blog.csdnimg.cn/223eed4707e44b34a557aaed02cf492d.png
[9f89340d00df4e1fa70922b8783a9a49.png]: https://img-blog.csdnimg.cn/9f89340d00df4e1fa70922b8783a9a49.png
[c472cc637f604ab7bb16199a9502dc24.png]: https://img-blog.csdnimg.cn/c472cc637f604ab7bb16199a9502dc24.png
[c6e5264408e448afaab861926822fe4f.png]: https://img-blog.csdnimg.cn/c6e5264408e448afaab861926822fe4f.png
[Java]: https://blog.csdn.net/fumeidonga/category_12311533.html
[SQL]: http://t.csdn.cn/4i3TW
[Link 1]: http://t.csdn.cn/9gGNy
[Android]: http://t.csdn.cn/A0aTR