ActivityManagerService原理分析

一.概述

ActivityManagerService是Framework层的核心服务之一,ActivityManagerService是Binder的子类,它的功能主要以下三点:

• 四大组件的统一调度
• 进程管理
• 内存管理

二.ActivityManagerService中的重要变量

• static final int MAX_ACTIVITYS =20;系统允许的最大后台activity的数目
• static final int MAX_RECENT_TASK=20; 系统最多存储20个任务栈
• static final int MAX_HIDDEN_APP=15;系统允许处于hidden状态的进程数目的最大值,超过这个值后,Ams会杀死掉优先级较低的进程
• ActivityStackSupervisor mStackSupervisor; 通过这个类管理ActivityStacks
• final ActiveServices mServices; 服务的管理类,管理服务的所有的逻辑
• final BroadcastQueue[] mBroadcastQueues = new BroadcastQueue[2]; 前台/后台广播队列
• private final RecentTasks mRecentTasks; 最近的任务的意图列表
• final ProcessMap mProcessNames = new ProcessMap(); 当前正在运行的所有进程列表
• final ArrayList mLruProcesses = new ArrayList();最近使用的进程列表
• final ArrayList mProcessesToGc = new ArrayList();一旦事情闲置，应该gc的进程列表
• final HashMap

三.ActivityManagerService的启动过程

ActivityManagerService的启动是在systemserver进程的startBootstrapServices方法中启动的.下面通过源码来分析这个启动过程.
step1.systemserver.startBootstrapServices

private void startBootstrapServices() {
 // Activity manager runs the show.
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
}

这里调用mSystemServiceManager.startService()来帮助处理,不过这里启动的是ActivityManagerService.Lifecycle类

setp2.SystemService startService

 public SystemService startService(String className) {
        final Class<SystemService> serviceClass;
        try {
//通过类加载将类加载进内存
            serviceClass = (Class<SystemService>)Class.forName(className);
        } catch (ClassNotFoundException ex) {
        }
    //调用startService(serviceClass)进一步处理
        return startService(serviceClass);
    }

 public <T extends SystemService> T startService(Class<T> serviceClass) {
        try {
            final String name = serviceClass.getName();
            final T service;
            try {
            //通过反射创建service
                Constructor<T> constructor = serviceClass.getConstructor(Context.class);
                service = constructor.newInstance(mContext);
            } 

            // Register it.
            mServices.add(service);

            // Start it.
            try {
             启动service
                service.onStart();
            } catch (RuntimeException ex) {

            }
            return service;
        } 
    }

因为这里启动的是ActivityManagerService.Lifecycle类,调用ActivityManagerService.Lifecycle类的start方法来启动,下面就看看这个类.
step3.ActivityManagerService.Lifecycle

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

        public Lifecycle(Context context) {
            super(context);
这个类创建对象的同时就创建出了ActivityManagerService
            mService = new ActivityManagerService(context);
        }

        @Override
        public void onStart() {
     //启动ActivityManagerService
            mService.start();
        }

        public ActivityManagerService getService() {
            return mService;
        }
    }

从上面的代码可以看出,这个类实际上就是帮我们创建出ActivityManagerService的对象,并且调用start方法开启服务.下面在看看ActivityManagerService在创建的时候做了什么.

step4.ActivityManagerService的构造方法

public ActivityManagerService(Context systemContext) {
        mContext = systemContext;
        mFactoryTest = FactoryTest.getMode();
        mSystemThread = ActivityThread.currentActivityThread();

        Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());

        mHandlerThread = new ServiceThread(TAG,
                android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
        mHandlerThread.start();
        //创建处理主要逻辑的hander
        mHandler = new MainHandler(mHandlerThread.getLooper());
        //创建处理UI的handler,比如处理无响应的对话框,弹出debug模式的对话框
        mUiHandler = new UiHandler();

        //创建存放前台和后台广播的广播队列
        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;
        //创建管理service的类
        mServices = new ActiveServices(this);
        //创建管理provider的类
        mProviderMap = new ProviderMap(this);

        在ams服务之外创建电池统计服务
        // TODO: Move creation of battery stats service outside of activity manager service.
        //创建system目录
        File dataDir = Environment.getDataDirectory();
        File systemDir = new File(dataDir, "system");
        systemDir.mkdirs();
        //创建电池服务
        mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
        mBatteryStatsService.getActiveStatistics().readLocked();
        mBatteryStatsService.scheduleWriteToDisk();
        mOnBattery = DEBUG_POWER ? true
                : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
        mBatteryStatsService.getActiveStatistics().setCallback(this);
        //创建跟踪长期执行流程以寻找滥用等糟糕的应用行为的服务
        mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
        //创建关于和控制应用程序操作的信息的服务
        mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);

        mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));

        // User 0 is the first and only user that runs at boot.
        //UserHandle表示一个用户
        mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true));
        mUserLru.add(UserHandle.USER_OWNER);
        updateStartedUserArrayLocked();

        GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
            ConfigurationInfo.GL_ES_VERSION_UNDEFINED);

        mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
        //配置信息
        mConfiguration.setToDefaults();
        mConfiguration.setLocale(Locale.getDefault());

        mConfigurationSeq = mConfiguration.seq = 1;
        mProcessCpuTracker.init();

        //用户要求以屏幕尺寸兼容模式运行的软件包
        mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
        mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);

        //用于启动最近的任务的意图列表
        mRecentTasks = new RecentTasks(this);
        //管理Activity的类,通过这个运行所有的ActivityStack,辅助启动startactivity
        mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);
        //重新启动时保存最近的任务信息
        mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks);
        //运行时cpu用于收集线程
        mProcessCpuThread = new Thread("CpuTracker") {
            @Override
            public void run() {
                while (true) {
                    try {
                        try {
                            synchronized(this) {
                                final long now = SystemClock.uptimeMillis();
                                long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
                                long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
                                //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
                                //        + ", write delay=" + nextWriteDelay);
                                if (nextWriteDelay < nextCpuDelay) {
                                    nextCpuDelay = nextWriteDelay;
                                }
                                if (nextCpuDelay > 0) {
                                    mProcessCpuMutexFree.set(true);
                                    this.wait(nextCpuDelay);
                                }
                            }
                        } catch (InterruptedException e) {
                        }
                        updateCpuStatsNow();
                    } catch (Exception e) {
                        Slog.e(TAG, "Unexpected exception collecting process stats", e);
                    }
                }
            }
        };
        //获取看门狗对象,并且将当前线程也就是这个服务添加进去
        Watchdog.getInstance().addMonitor(this);
        Watchdog.getInstance().addThread(mHandler);
    }

acitivtymanagerservie的构造函数主要初始化了四大组件的管理类,以及处理主要逻辑的mHandler和处理ui相关的mUiHandler ,比如弹出anr等对话框.

Step5.ActivityManagerService.start()

   private void start() {
//删除所有的进程组,确保刚启动的时候是没有进程的
        Process.removeAllProcessGroups();
     将CPU用来收集线程的线程启动
        mProcessCpuThread.start();
启动电池服务
        mBatteryStatsService.publish(mContext);
启动关于和控制应用程序操作的信息的服务
        mAppOpsService.publish(mContext);
        类似servermanger,只不过这个是用于当前进程
     LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    }

到这一步ActivityManagerService服务就真正的开启了,就会开始真正的执行前面说的3个主要功能了.

四.主要功能之一的四大组件的统一调度

ActivityManagerService最主要的功能就是统一的管理者activity,service,broadcast,provider的创建,运行,关闭.我们在应用程序中启动acitivity,关闭acitiviy等操作最终都是要通过ams来统一管理的.这个过程非常的复杂,不是一下子可以讲的清楚的,我这里推荐老罗的博客来讲解四大组件的启动过程:

• Android应用程序内部启动Activity过程（startActivity）的源代码分析
• Android系统在新进程中启动自定义服务过程（startService）的原理分析
• Android应用程序注册广播接收器（registerReceiver）的过程分析
• Android应用程序发送广播（sendBroadcast）的过程分析
• Android应用程序组件Content Provider简要介绍和学习计划

五.主要功能之一的内存管理

我们知道当一个进程中的acitiviy全部都关闭以后,这个空进程并不会立即就被杀死.而是要等到系统内存不够时才会杀死.但是实际上ActivityManagerService并不能够管理内存,android的内存管理是Linux内核中的内存管理模块和OOM进程一起管理的.Android进程在运行的时候,会通过Ams把每一个应用程序的oom_adj值告诉OOM进程,这个值的范围在-16-15,值越低说明越重要,越不会被杀死.当发生内存低的时候,Linux内核内存管理模块会通知OOm进程根据AMs提供的优先级强制退出值较高的进程.因此Ams在内存管理中只是扮演着一个提供进程oom_adj值的功能.真正的内存管理还是要调用OOM进程来完成.下面通过调用Activity的finish()方法来看看内存释放的情况.

当我们手动调用finish()方法或者按back键时都是会关闭activity的,,在调用finish的时候只是会先调用ams的finishActivityLocked方法将当前要关闭的acitiviy的finish状态设置为true,然后就会先去启动新的acitiviy,当新的acitiviy启动完成以后就会通过消息机制通知Ams,Ams在调用activityIdleInternalLocked方法来关闭之前的acitiviy.下面就看看activityIdleInternalLocked的源码

ActivityStackSupevis.activityIdleInternalLocked

 final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,
            Configuration config) {

//所有要暂停的activity
        ArrayList<ActivityRecord> stops = null;
     //所有要finish的activity
        ArrayList<ActivityRecord> finishes = null;
        ArrayList<UserState> startingUsers = null;
        int NS = 0;
        int NF = 0;
        boolean booting = false;
        boolean activityRemoved = false;


        if (allResumedActivitiesIdle()) {
            if (r != null) {
1.通知所有需要内存回收的进程进行内存回收(这些进程都保存在mProgressToGc列表中)
                mService.scheduleAppGcsLocked();
            }

     2.  分别拿到所有要stop和finish的activity存放在stops和finishs容器中,然后将记录清空
        stops = processStoppingActivitiesLocked(true);
        NS = stops != null ? stops.size() : 0;
        if ((NF = mFinishingActivities.size()) > 0) {
            finishes = new ArrayList<>(mFinishingActivities);
            mFinishingActivities.clear();
        }

        if (mStartingUsers.size() > 0) {
            startingUsers = new ArrayList<>(mStartingUsers);
            mStartingUsers.clear();
        }

      3. 停止stops中的所有activity
        for (int i = 0; i < NS; i++) {
            r = stops.get(i);
            final ActivityStack stack = r.task.stack;
            if (stack != null) {
                if (r.finishing) {
                    stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false);
                } else {
                    stack.stopActivityLocked(r);
                }
            }
        }

       4. 销毁finishs中的所有activity
        for (int i = 0; i < NF; i++) {
            r = finishes.get(i);
            final ActivityStack stack = r.task.stack;
            if (stack != null) {
                activityRemoved |= stack.destroyActivityLocked(r, true, "finish-idle");
            }
        }

     5.该步骤内部真正地进行内存回收工作,包括杀死不必要的进程
mService.trimApplications();
        return r;
    }

在这个方法中除了第一步通知客户进程调用GC来主动回收内存以外,剩下的步骤都是没有操作到内存的,所以说stop或者destroy的回调方法调用的时候只是一个状态的变化,而没有真正意义的对内存进行实质性的停止或者销毁.但是会调用trimApplications方法来进一步操作.

ActivityManagerService.trimApplications

final void trimApplications() {
        synchronized (this) {
            int i;
            首先删除mRemoveProcess列表中包含的进程.这里一般包含的是crash后的进程,弹出ANR的进程,调用KillBackGroundProgress()方法杀死的进程.也就是说crash或者弹出Anr对话框我们点确定的时候系统并不会立马就将这些进程杀死,而是要等空闲时调用activityIdleInternalLocked方法时才会真正的来杀死.
                for (i=mRemovedProcesses.size()-1; i>=0; i--) {
                final ProcessRecord app = mRemovedProcesses.get(i);
                if (app.activities.size() == 0
                        && app.curReceiver == null && app.services.size() == 0) {

                    if (app.pid > 0 && app.pid != MY_PID) {
  不杀死当前进程
                        app.kill("empty", false);
                    } else {
                        try {
                            app.thread.scheduleExit();
                        } catch (Exception e) {
                            // Ignore exceptions.
                        }
                    }
                    cleanUpApplicationRecordLocked(app, false, true, -1);
将杀死的进程,移除
                    mRemovedProcesses.remove(i);

                    if (app.persistent) {
                        addAppLocked(app.info, false, null /* ABI override */);
                    }
                }
            }

            // Now update the oom adj for all processes.
告诉OOM Killer所有进程的优先级
            updateOomAdjLocked();
        }
    }

通过上面的源码知道,我们调用finish方法时关闭一个acitiviy的时候并不会真正的在内存中销毁它,而只是会调用onDestroy方法而已.除了会杀死mRemoveProcess列表中的进程,另外也就只会告诉OOM Killer所有进程的优先级.并不会主动的去杀死其他进程.