ActivityManagerService原理-CSDN博客

本文详细探讨了ActivityManagerService（AMS）的初始化过程，从AMS的创建到SystemServer的startBootstrapServices方法，再到Lifecycle类作为适配器的角色。AMS的构造过程中涉及线程创建、系统目录初始化以及服务注册和启动。systemReady方法的执行分为三个阶段，包括系统服务启动、进程管理和广播发布。通过对这些步骤的分析，全面揭示了AMS的核心启动逻辑。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1:前言

前文《Android源码阅读分析：从Activity开始（一）——启动流程》中我简单地讲解了Activity是如何被启动的。其中涉及到了ActivityManagerService。在Android系统中，ActivityManagerService（下文中我们都简称为AMS）是管理Android四大组件的核心，其重要性不言而喻。那么，从本篇文章就开始分析AMS的源码，理解其内部的逻辑。

2：AMS对象初始化

我们要分析一个问题，首先就要从这个问题的源头来分析起。所以，我们先看一下ams是如何被创建起来的。
　　经过查找，发现ams最初的创建位置在SystemServer的startBootstrapServices方法内。

(frameworks/base/servces/java/com/android/server/SystemServer.java)

private void startBootstrapServices() {
	...
	// 启动Activity Manager
	mActivityManagerService = mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
	...
	// 为系统进程创建并启动Application实例
	mActivityManagerService.setSystemProcess();
	...
}

该方法表示通过SystemServiceManager的startService方法，启动Lifecycle后获取服务。然后为系统进程创建并启动Application实例。
　　Lifecycle是AMS的内部静态类

(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)

public static final class Lifecycle extends SystemService {
	private final ActivityManagerService mService;

    public Lifecycle(Context context) {
		super(context);
        mService = new ActivityManagerService(context);
    }

    @Override
    public void onStart() {
		mService.start();
    }

    @Override
    public void onCleanupUser(int userId) {
		mService.mBatteryStatsService.onCleanupUser(userId);
    }

    public ActivityManagerService getService() {
		return mService;
    }
}

到这么可以看出Lifecycle类的作用，就是在ActivityManagerSerivce与SystemService之间充当适配器的作用

再返回来看一下SystemServiceManager的startService方法做了什么

(frameworks/base/services/core/java/com/android/server/SystemServiceManager.java)

public <T extends SystemService> T startService(Class<T> serviceClass) {
	try {
		final String name = serviceClass.getName();
		...
		final T service;
        try {
			Constructor<T> constructor = serviceClass.getConstructor(Context.class);
            service = constructor.newInstance(mContext);
        }
        ...
        startService(service);
        return service;
	}
	...
}

这里通过构造器创建一个SystemService的子类实例，这里即Lifecycle类的实例，再调用startService(SystemService)方法

在Lifecycle的构造方法中，会根据传入的Context参数创建一个ActivityManagerService对象。那我们看一下ActivityManagerService的构造方法

(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)

public ActivityManagerService(Context systemContext) {
	...
    mInjector = new Injector();
    mContext = systemContext;

    mFactoryTest = FactoryTest.getMode();
    mSystemThread = ActivityThread.currentActivityThread();
    mUiContext = mSystemThread.getSystemUiContext();
    ...
    // 创建名为ActivityManagerService的前台线程
    mHandlerThread = new ServiceThread(TAG, THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();
    mHandler = new MainHandler(mHandlerThread.getLooper());
    // 创建UI线程
    mUiHandler = mInjector.getUiHandler(this);
    ...
    // 创建前台广播队列和后台广播队列
    mFgBroadcastQueue = new BroadcastQueue(this, mHandler, "foreground", BROADCAST_FG_TIMEOUT, false);
    mBgBroadcastQueue = new BroadcastQueue(this, mHandler, "background", BROADCAST_BG_TIMEOUT, true);
    mBroadcastQueues[0] = mFgBroadcastQueue;
    mBroadcastQueues[1] = mBgBroadcastQueue;
    ...
    // 创建"/data/system"目录
    File dataDir = Environment.getDataDirectory();
    File systemDir = new File(dataDir, "system");
    systemDir.mkdirs();
    ...
    // 所有Activity的启动都要通过mStackSupervisor执行
    mStackSupervisor = createStackSupervisor();
    ...
    mActivityStarter = new ActivityStarter(this, mStackSupervisor);
    ...
    mProcessCpuThread = new Thread("CpuTracker") {
	    @Override
        public void run() {
			synchronized (mProcessCpuTracker) {
				mProcessCpuInitLatch.countDown();
                mProcessCpuTracker.init();
            }
            ...
	    }
    }
}

asm的构造方法创建了asm线程、UI线程和CpuTracker线程，同时创建了系统目录以及用于创建Activity的StackSupervisor和ActivityStarter

asm对象创建完成(＾－＾)V

`对象创建完就得把他用起来呀！不然对象就摆在门口了哈哈哈`

下面我们在看一下SystemServiceManager.startService(SystemService)方法


(frameworks/base/services/core/java/com/android/server/SystemServiceManager.java)

public void startService(@NonNull final SystemService service) {
	mServices.add(service);
	...
	try {
		service.onStart();
	}
	...
}

这个方法主要做了两件事情，一个是注册服务，另一个就是启动服务。而Lifecycle的onStart方法中又会调用ActivityManagerService的start方法，下面跟踪一下该方法

(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)

private void start() {
	// 删除所有进程组
	removeAllProcessGroups();
	// 启动CpuTracker线程
    mProcessCpuThread.start();
    mBatteryStatsService.publish();
    mAppOpsService.publish(mContext);
    LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    try {
		mProcessCpuInitLatch.await();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new IllegalStateException("Interrupted wait during start");
    }
}

到这AMS已经创建完成

我们再回到SystemServer的startBootstrapServices方法中，在创建了ams后，又调用了其setSystemProcess方法

(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)

public void setSystemProcess() {
	try {
		ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
        ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
        ServiceManager.addService("meminfo", new MemBinder(this));
        ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
        ServiceManager.addService("dbinfo", new DbBinder(this));
        if (MONITOR_CPU_USAGE) {
			ServiceManager.addService("cpuinfo", new CpuBinder(this));
        }
        ServiceManager.addService("permission", new PermissionController(this));
        ServiceManager.addService("processinfo", new ProcessInfoService(this));

        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo("android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

        synchronized (this) {
			ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
            app.persistent = true;
            app.pid = MY_PID;
            app.maxAdj = ProcessList.SYSTEM_ADJ;
            app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
            synchronized (mPidsSelfLocked) {
				mPidsSelfLocked.put(app.pid, app);
            }
            updateLruProcessLocked(app, false, null);
            updateOomAdjLocked();
        }
	}
	...
}

该方法的主要作用是为系统进程创建并启动Application实例并启动，同时也注册一些服务。
　　现在我们再回头看一下SystemServer调用startBootstrapServices方法的地方

(frameworks/base/servces/java/com/android/server/SystemServer.java)

// zygote的主进入点
public static void main(String[] args) {
	new SystemServer().run();
}

private void run() {
	...
	try {
		traceBeginAndSlog("StartServices");
        startBootstrapServices();
        startCoreServices();
        startOtherServices();
        SystemServerInitThreadPool.shutdown();
    }
	...
}

在执行了startBootstrapServices方法后，又接着调用了startCoreServices方法和startOtherServices方法。这两个方法用于启动一些在startBootstrapServices方法内没有启动的必要服务和其他各种服务

(frameworks/base/servces/java/com/android/server/SystemServer.java)

private void startCoreServices() {
	...
	// 检测应用统计
	mActivityManagerService.setUsageStatsManager(LocalServices.getService(UsageStatsManagerInternal.class));
	...
}

private void startOtherServices() {
	...
	mActivityManagerService.installSystemProviders();
	...
	final Watchdog watchdog = Watchdog.getInstance();
    watchdog.init(context, mActivityManagerService);
    ...
    // 通知ActivityManagerService
    mActivityManagerService.systemReady(() -> {
	    ...
	    mSystemServiceManager.startBootPhase(SystemService.PHASE_ACTIVITY_MANAGER_READY);
	    ...
	    try {
			mActivityManagerService.startObservingNativeCrashes();
        }
	    ...
	    try {
			startSystemUi(context, windowManagerF);
        }
        ...
		// 通知若干系统服务systemReady
		...
		// 启动Watchdog
		Watchdog.getInstance().start();
		...
		// 通知若干系统服务systemRunning
		...
    }, BOOT_TIMINGS_TRACE_LOG);
}

上面代码调用了ActivityManagerService的systemReady方法，其中的Lambda表达式应为Runnable类型。

(frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java)

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
	synchronized(this) {
		if (mSystemReady) {
			if (goingCallback != null) {
				// 执行回调
				goingCallback.run();
            }
            return;
		}
        mLocalDeviceIdleController = LocalServices.getService(DeviceIdleController.LocalService.class);
        mAssistUtils = new AssistUtils(mContext);
        mVrController.onSystemReady();
        mUserController.onSystemReady();
        mRecentTasks.onSystemReadyLocked();
        mAppOpsService.systemReady();
        mSystemReady = true;
	}
	...
	// 检查需要kill的进程，并执行kill，且不允许重启
	ArrayList<ProcessRecord> procsToKill = null;
    synchronized(mPidsSelfLocked) {
		for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
			ProcessRecord proc = mPidsSelfLocked.valueAt(i);
            if (!isAllowedWhileBooting(proc.info)){
				if (procsToKill == null) {
					procsToKill = new ArrayList<ProcessRecord>();
                }
                procsToKill.add(proc);
			}
        }
	}
	synchronized(this) {
		if (procsToKill != null) {
			for (int i=procsToKill.size()-1; i>=0; i--) {
				ProcessRecord proc = procsToKill.get(i);
                removeProcessLocked(proc, true, false, "system update done");
            }
		}
        mProcessesReady = true;
    }
    ...
    retrieveSettings();
    ...
    // 执行回调
    if (goingCallback != null) goingCallback.run();
    ...
    synchronized (this) {
	    // 启动持久化进程
	    startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
	    ...
	    // 启动桌面Activity
	    startHomeActivityLocked(currentUserId, "systemReady");
	    ...
	    try {
		    // 发送ACTION_USER_STARTED广播
			Intent intent = new Intent(Intent.ACTION_USER_STARTED);
            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND);
            intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
            broadcastIntentLocked(null, null, intent, null, null, 0, null, null, null, AppOpsManager.OP_NONE, null, false, false, MY_PID, SYSTEM_UID, currentUserId);
            // 发送ACTION_USER_STARTING广播
            intent = new Intent(Intent.ACTION_USER_STARTING);
            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
            intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
            broadcastIntentLocked(null, null, intent, null, 
	            new IIntentReceiver.Stub() {
					@Override
                    public void performReceive(Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
                    }
                }, 
                0, null, null, new String[] {INTERACT_ACROSS_USERS}, AppOpsManager.OP_NONE, null, true, false, MY_PID, SYSTEM_UID, UserHandle.USER_ALL);
		}
		...
		mStackSupervisor.resumeFocusedStackTopActivityLocked();
		...
    }
}

该方法可以根据goingCallback.run()的执行时间，分为三个部分。
　　1. 在goingCallback.run()执行之前的主要操作是通知systemReady和杀掉启动时不被允许的进程。
　　2. goingCallback.run()方法主要用于启动各种系统服务进程
　　3. 在goingCallback.run()执行之后的主要操作是启动持久化进程、启动桌面Activity、发布ACTION_USER_STARTED和ACTION_USER_STARTING广播。

以上就是asm的启动流程。

总结下以上主要是讲解ActivityManagerService的创建和启动逻辑