ActivityManagerService（AMS）主要负责系统中四大组件的启动、切换、调度以及应用程序的管理和调度工作，其职责与操作系统中的进程管理和调度模块类似。

ActivityManagerService 进行初始化的时机很明确，就是在 system_server 进程开启的时候，就会初始化 ActivityManagerService。（启动 APP 的时候，是需要 AMS 通知 Zygote 进程，所有的 Activity 的生命周期都需要 AMS 来控制）
ActivityThread 在 Android 中代表主线程，在 APP 进程创建完成之后，就会加载 ActivityThread.main 函数，然后执行 Looper.loop() 循环，使当前线程进入消息循环。

ApplicationThread 是 ActivityThread 的内部类，继承了 IApplicationThread.Stub。如果需要在目标进程中启动 Activity，就要通过 ApplicationThread 与 AMS 所在的进程（system_server 进程）进行通信。



ActivityManager

ActivityManager 是一个和 AMS 相关联的类，主要是对运行中的 Activity 进行管理，但是，这些管理工作并不是直接由 ActivityManager 管理的，而是交由 AMS 来处理。
ActivityManager 中的方法会通过 ActivityManagerNative(AMN).getDefault() 方法来得到 ActivityManagerProxy（AMP），通过 AMP 就可以和 AMN 进行通信。AMN 是一个抽象类，它将功能交给它的子类 AMS 来处理，因此，AMP 就是 AMS 的代理类。

public interface IInterface{
    public IBinder asBinder();
}

public interface IBinder { 
    public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException;
}

public class Binder implements IBinder { }

public interface IActivityManager extends IInterface { }

public abstract class ActivityManagerNative extends Binder 
        implements IActivityManager { 
            class ActivityManagerProxy implements IActivityManager { }
}

public final class ActivityManagerService extends ActivityManagerNative
    implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback { 



}

AMS 作为系统服务，很多 API 是不会暴露给 ActivityManager 的，因此 ActivityManager 并不算是 AMS 家族中的一份子。在 Activity 的启动过程中会调用 Instrumentation.execStartActivity 方法：

```java
// /frameworks/base/core/java/android/app/Instrumentation.java
public ActivityResult execStartActivity(
    ...
    try {
        intent.migrateExtraStreamToClipData();
        intent.prepareToLeaveProcess(who);
        int result = ActivityManagerNative.getDefault()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                           intent.resolveTypeIfNeeded(who.getContentResolver()),
                           token, target, requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

AMS 和 ActivityThread 之间，比如 Activity 的创建、暂停等交互工作实际上是由 Instumentation 具体操作的。每个 Activity 都持有一个 Instrumentation 对象的引用，整个进程中也只有一个 Instrumentation。mInstrumentation 的初始化在 ActivityThread.handleBindApplication 函数中，可以用来独立地控制某个组件的生命周期。Activity.startActivity 方法调用 mInstrumentation.execStartActivity 方法，最终，通过 AMS 告知 Zygote 进程 fork 子进程。

// /frameworks/base/core/java/android/app/ActivityThread.java
private void handleBindApplication(AppBindData data) {
    ...
    if (ii != null) {
        ...
        try {
            final ClassLoader cl = instrContext.getClassLoader();
            mInstrumentation = (Instrumentation)
                cl.loadClass(data.instrumentationName.getClassName()).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(
                "Unable to instantiate instrumentation "
                + data.instrumentationName + ": " + e.toString(), e);
        }
        ...
    } else {
        mInstrumentation = new Instrumentation();
    }

}

在 Instrumentation.execStartActivity 方法中会调用 ActivityManagerNative(AMN).getDefault() 方法来获取 AMS 的代理类 AMP，接着调用了 ActivityManagerProxy(AMP).startActivity 方法。 首先来看 ActivityMangerNative.getDefault() 方法：

// /frameworks/base/core/java/android/app/ActivityManagerNative.java
static public IActivityManager getDefault() {
    return gDefault.get();
}

private static final Singleton gDefault = new Singleton() {
    protected IActivityManager create() {
        IBinder b = ServiceManager.getService("activity"); // 1
        if (false) {
            Log.v("ActivityManager", "default service binder = " + b);
        }
        IActivityManager am = asInterface(b); // 2
        if (false) {
            Log.v("ActivityManager", "default service = " + am);
        }
        return am;
    }
};

// frameworks/base/core/java/android/util/Singleton.java
public abstract class Singleton {
    private T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

在 ActivityManagerNative.getDefault() 方法中调用了 gDefault.get() 方法，gDefault 是一个 Singleton 类。在注释1 处得到名为 “activity” 的 Service 引用，也就是 IBinder 类型的 AMS 的引用。接着在注释 2 处将它封装成 AMP 类型对象，并将它保存到 gDefault 中，此后调用 ActivityManagerNative.getDefault() 方法就会直接获取 AMS 的代理对象 AMP。 注释 2 处的 asInterface 方法如下所示：

// /frameworks/base/core/java/android/app/ActivityManagerNative.java
static public IActivityManager asInterface(IBinder obj) {
    if (obj == null) {
        return null;
    }
    IActivityManager in =
        (IActivityManager)obj.queryLocalInterface(descriptor); // 1
    if (in != null) {
        return in;
    }

    return new ActivityManagerProxy(obj); // 2
}

注释 1 处的 descriptor 值为 android.app.IActivityManager，注释 1 处的代码主要用来查询本地进程是否有 IActivityManager 接口的实现，如果有则返回，如果没有，就在注释 2 处将 IBinder 类型的 AMS 引用封装成 AMP，AMP 的构造方法如下所示：

// /frameworks/base/core/java/android/app/ActivityManagerNative.java
 class ActivityManagerProxy implements IActivityManager {
    public ActivityManagerProxy(IBinder remote) {
        mRemote = remote;
    }
    ...
}

在 AMP 的构造方法中将 AMS 的引用赋值给变量 mRemote，这样在 AMP 中就可以使用 AMS 了。其中，IActivityManager 是一个接口，AMN 和 AMP 都实现了这个接口，用于实现代理模式和 Binder 通信。
再回到 Instrumentation.execStartActivity 方法中，查看 ActivityManagerProxy(AMP).startActivity 方法，AMP 是 AMN 的内部类，代码如下所示：

// ActivityManagerService.java
public int startActivity(IApplicationThread caller, String callingPackage, Intent intent, 
         String resolvedType, IBinder resultTo, String resultWho, int requestCode, 
         int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
    ...
    data.writeInt(requestCode);
    data.writeInt(startFlags);
    ...
    mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0); // 1
    reply.readException();
    int result = reply.readInt();
    reply.recycle();
    data.recycle();
    return result;
}

首先将传入的参数写入到 Parcel 类型的 data 中。在注释 1 处，通过 IBinder 类型对象 mRemote（AMS 的引用）向服务端的 AMS 发送一个 START_ACTIVITY_TRANSACTION 类型的进程间通信请求，之后，服务端 AMS 就会从 Binder 线程池中读取客户端发来的数据，最终会调用 ActivityManagerNative.onTransact 方法，如下所示：

@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
    throws RemoteException {
    switch (code) {
        case START_ACTIVITY_TRANSACTION:
            {
                ...
                int result = startActivity(app, callingPackage, intent, resolvedType,
                       resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
                reply.writeNoException();
                reply.writeInt(result);
                return true;
            }
          ...
    }