系统启动过程

启动Zygote进程：
启动过程开始于Zygote进程，当启动一个应用时，Zygote进程会被复用以创建新的应用进程。

这里是ZygoteInit.main的主要作用，它是Zygote进程的入口：

public class ZygoteInit {
    public static void main(String argv[]) {
        // ... 省略的一些前期初始化代码

        // 启动系统服务进程
        if (startSystemServer) {
            startSystemServer(forkedProcesses);
        }

        // 进入Zygote的主循环
        Runnable caller;
        try {
            caller = zygoteServer.runSelectLoop();
        } catch (Throwable ex) {
          // ... 处理异常
        }

        // 运行子进程初始化代码
        if (caller != null) {
            caller.run();
        }
    }
}
1、Zygote连接处理：
Zygote进程在初始化后会进入一个循环，等待来自ActivityManagerService（AMS）的进程启动请求。这是在runSelectLoop中处理的。

ZygoteServer.runSelectLoop 在后台等待连接请求：

public class ZygoteServer {
    Runnable runSelectLoop() {
        while (true) {
            // 等待AMS连接
            ZygoteConnection connection = acceptCommandPeer();
            return connection.processOneCommand(); // 这里实际上是处理一个命令
        }
    }
}
2、处理启动命令：
在接收到启动请求后，ZygoteConnection.processOneCommand 方法负责处理实际启动参数。

public class ZygoteConnection {
    Runnable processOneCommand() {
        // 解析启动参数
        Arguments args = readArgumentList();

        // 调用Zygote来fork新进程
        Zygote.forkAndSpecialize(...);

        if (pid == 0) {
            // 子进程执行到这里
            return handleChildProc(args, descriptors, childPipeFd, newStderr);
        } else {
            // 父进程（Zygote进程）执行到这里
            ...
        }
    }
}
这 就是说，handleChildProc 方法在子进程中被调用，这里新启动的进程会完成初始化：

3. handleChildProc
handleChildProc 负责处理子进程的初始化。

public class ZygoteConnection {
    private Runnable handleChildProc(Arguments parsedArgs) {
        // 初始化子进程
        return RuntimeInit.wrapperInit(parsedArgs);
    }
}
4. RuntimeInit.wrapperInit
RuntimeInit.wrapperInit 是实际启动应用进程的方法。

public class RuntimeInit {
    public static Runnable wrapperInit(Arguments args) {
        return applicationInit(args);
    }
    private static Runnable applicationInit(Arguments args) {
        return invokeStaticMain(args.startClass, args.startArgs, null);
    }
    protected static Runnable invokeStaticMain(String className, String[] argv, ClassLoader classLoader) {
        // 反射调用main方法
        Class<?> cl;
        try {
            cl = Class.forName(className);
            Method m = cl.getMethod("main", new Class[] { String[].class });
            m.invoke(null, new Object[]{argv});
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
        return null;
    }
}
5. ActivityThread.main
以上步骤最终会调用到ActivityThread.main方法，这是实际应用进程的入口。

public class ActivityThread {
    public static void main(String[] args) {
        // 主线程初始化
        Looper.prepareMainLooper();
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        Looper.loop();
    }
}

总结

整个调用链从Zygote接收启动参数到涉及到的主要过程如下：
ZygoteInit.main: 启动进程，并进入等待循环。
ZygoteServer.runSelectLoop: 等待并处理启动请求。
ZygoteConnection.processOneCommand: 解析并fork新的进程。
RuntimeInit.wrapperInit: 完成子进程进一步初始化。
RuntimeInit.applicationInit: 通过反射调用指定类的main方法。
ActivityThread.main: 启动应用主线程。

接下来看看AMS是怎么传输Socket数据给Zygote的

在ActivityManagerService（AMS）中，有关启动应用进程并通过Socket请求发送给Zygote的部分，主要是通过startProcessLocked方法来实现。这个方法会调用Process.start方法，并通过Zygote发送启动请求。在启动参数中传递了android.app.ActivityThread。

具体的流程如下：

1. ActivityManagerService.startProcessLocked
ActivityManagerService的startProcessLocked方法负责启动新进程：

public class ActivityManagerService {
    private boolean startProcessLocked(ProcessRecord app, ...) {
        ...
        // 调用Process.start来启动进程
        Process.ProcessStartResult startResult = Process.start(
                "android.app.ActivityThread", // 这里指定类名
                app.processName, ...);
        ...
    }
}
2. Process.start
Process.start方法负责创建并启动一个新的应用进程：

public class Process {
    public static ProcessStartResult start(
            String processClass, // 这里是传入的 "android.app.ActivityThread"
            String niceName,
            ...
            ) {
        ...
        try {
            return startViaZygote(processClass, niceName, ...);
        } catch (RuntimeException e) {
            ...
        }
    }

    private static ProcessStartResult startViaZygote(
            String processClass,
            String niceName,
            ...
            ) {
        ...
        // 创建启动参数列表
        ArrayList<String> argsForZygote = new ArrayList<String>();

        // 传递启动组件类名
        argsForZygote.add("--runtime-args");
        argsForZygote.add("--setuid=" + uid);
        argsForZygote.add("--setgid=" + gid);
        argsForZygote.add("-classpath");
        argsForZygote.add("--nice-name=" + niceName);
        argsForZygote.add(processClass); // 传入的类名

        // 调用Zygote来启动进程
        ProcessStartResult result = ZygoteProcess.zygoteSendArgsAndGetResult(
                openZygoteSocketIfNeeded(abi), argsForZygote);
        ...
        return result;
    }
}
3. ZygoteProcess.zygoteSendArgsAndGetResult
这个方法通过Socket将启动参数发送给Zygote进程：

public class ZygoteProcess {
    public Process.ProcessStartResult zygoteSendArgsAndGetResult(
            ZygoteState zygoteState, ArrayList<String> args)
            throws ZygoteStartFailedEx {
        try {
            // 获取Zygote进程的Socket连接
            DataOutputStream zygoteWriter = zygoteState.mZygoteOutputWriter;

            // 发送启动参数
            for (String arg : args) {
                zygoteWriter.writeBytes(arg + "\n");
            }

            // 获取启动结果
            ProcessStartResult result = new ProcessStartResult();
            result.pid = zygoteState.mZygoteInputStream.readInt();
            ...
            return result;
        } catch (IOException ex) {
            throw new ZygoteStartFailedEx(ex);
        }
    }
}
传递给Zygote的参数
从上述代码可以看到，Process.start方法最终构建了一个参数列表argsForZygote，其中包括要启动的类名android.app.ActivityThread，并通过ZygoteProcess.zygoteSendArgsAndGetResult发送到Zygote进程。

4. 接受请求并启动进程的Zygote代码
回到之前的细节：

ZygoteServer.runSelectLoop
Zygote进程在启动后，会进入一个循环等待AMS的请求：

public class ZygoteServer {
    Runnable runSelectLoop() {
        while (true) {
            ZygoteConnection connection = acceptCommandPeer();
            return connection.processOneCommand();
        }
    }
}
ZygoteConnection.processOneCommand
在接受到启动请求后，Zygote进程通过processOneCommand方法处理请求：

public class ZygoteConnection {
    Runnable processOneCommand() {
        // 读取并解析参数
        Arguments args = readArgumentList();
        // Fork新的进程
        int pid = Zygote.forkAndSpecialize(args);
        if (pid == 0) {
            // 子进程处理
            return handleChildProc(args);
        } else {
            // 父进程处理
            ...
        }
    }
}

总结
总结来说，关于传递类名android.app.ActivityThread的调用链如下：

ActivityManagerService.startProcessLocked: 调用Process.start方法，传入类名android.app.ActivityThread。
Process.start: 调用startViaZygote，构建参数列表并调用ZygoteProcess.zygoteSendArgsAndGetResult。
ZygoteProcess.zygoteSendArgsAndGetResult: 通过Socket将启动参数发给Zygote进程。
ZygoteServer.runSelectLoop: 接受并处理启动请求。
ZygoteConnection.processOneCommand: 解析启动参数并fork新进程。
handleChildProc: 初始化新进程，最终调用RuntimeInit.zygoteInit，并反射调用ActivityThread.main。