throw ex;
}
String abiListString = getAbiList(zygoteWriter, zygoteInputStream);
Log.i(“Zygote”, "Process: zygote socket opened, supported ABIS: " + abiListString);
return new ZygoteState(zygoteSocket, zygoteInputStream, zygoteWriter,
Arrays.asList(abiListString.split(“,”)));
}
}
建立Socket连接的流程很明朗了,如下所示:
- 创建LocalSocket对象。
- 将LocalSocket与LocalServerSocket建立连接,建立连接的过程就是LocalSocket对象在/dev/socket目录下查找一个名称为"zygote"的文件,然后将自己与其绑定起来,这样就建立了连接。
- 创建LocalSocket的输入流,以便可以接收Zygote进程发送过来的数据。
- 创建LocalSocket的输出流,以便可以向Zygote进程发送数据。
1.2 ZygoteInit.main(String argv[])
ZygoteInit是Zygote进程的启动类,该类会预加载一些类,然后便开启一个循环,等待通过Socket发过来的创建新进程的命令,fork出新的 子进程。
ZygoteInit的入口函数就是main()方法,如下所示:
public class ZygoteInit {
public static void main(String argv[]) {
// Mark zygote start. This ensures that thread creation will throw
// an error.
ZygoteHooks.startZygoteNoThreadCreation();
try {
//…
registerZygoteSocket(socketName);
//…
//开启循环
runSelectLoop(abiList);
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run();
} catch (Throwable ex) {
Log.e(TAG, “Zygote died with exception”, ex);
closeServerSocket();
throw ex;
}
}
// 开启一个选择循环,接收通过Socket发过来的命令,创建新线程
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
ArrayList fds = new ArrayList();
ArrayList peers = new ArrayList();
//sServerSocket指的是Socket通信的服务端,在fds中的索引为0
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
//开启循环
while (true) {
StructPollfd[] pollFds = new StructPollfd[fds.size()];
for (int i = 0; i < pollFds.length; ++i) {
pollFds[i] = new StructPollfd();
pollFds[i].fd = fds.get(i);
pollFds[i].events = (short) POLLIN;
}
try {
//处理轮询状态,当pollFds有时间到来时则往下执行,否则阻塞在这里。
Os.poll(pollFds, -1);
} catch (ErrnoException ex) {
throw new RuntimeException(“poll failed”, ex);
}
for (int i = pollFds.length - 1; i >= 0; --i) {
//采用IO多路复用机制,当接收到客户端发出的连接请求时或者数据处理请求到来时则
//往下执行,否则进入continue跳出本次循环。
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
//索引为0,即为sServerSocket,表示接收到客户端发来的连接请求。
if (i == 0) {
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
}
//索引不为0,表示通过Socket接收来自对端的数据,并执行相应的操作。
else {
boolean done = peers.get(i).runOnce();
//处理完成后移除相应的文件描述符。
if (done) {
peers.remove(i);
fds.remove(i);
}
}
}
}
}
}
可以发现ZygoteInit在其入口函数main()方法里调用runSelectLoop()开启了循环,接收Socket发来的请求。请求分为两种:
- 连接请求
- 数据请求
没有连接请求时Zygote进程会进入休眠状态,当有连接请求到来时,Zygote进程会被唤醒,调用acceptCommadPeer()方法创建Socket通道ZygoteConnection
private static ZygoteConnection acceptCommandPeer(String abiList) {
try {
return new ZygoteConnection(sServerSocket.accept(), abiList);
} catch (IOException ex) {
throw new RuntimeException(
“IOException during accept()”, ex);
}
}
然后调用runOnce()方法读取连接请求里的数据,然后创建新进程。
此外,连接的过程中服务端接受的到客户端的connect()操作会执行accpet()操作,建立连接手,客户端通过write()写数据,服务端通过read()读数据。
1.3 ZygoteConnection.runOnce()
class ZygoteConnection {
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
try {
//读取客户端发过来的参数列表
args = readArgumentList();
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
Log.w(TAG, "IOException on command socket " + ex.getMessage());
closeSocket();
return true;
}
//… 参数处理
try {
//… 参数处理
//调用Zygote.forkAndSpecialize(来fork出新进程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
parsedArgs.appDataDir);
} catch (ErrnoException ex) {
logAndPrintError(newStderr, “Exception creating pipe”, ex);
} catch (IllegalArgumentException ex) {
logAndPrintError(newStderr, “Invalid zygote arguments”, ex);
} catch (ZygoteSecurityException ex) {
logAndPrintError(newStderr,
"Zygote security policy prevents request: ", ex);
}
try {
//pid == 0时表示当前是在新创建的子进程重磅执行
if (pid == 0) {
// in child
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
// should never get here, the child is expected to either
// throw ZygoteInit.MethodAndArgsCaller or exec().
return true;
}
// pid < 0表示创建新进程失败,pid > 0 表示当前是在父进程中执行
else {
// in parent…pid of < 0 means failure
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}
}
该方法主要用来读取进程启动参数,然后调用Zygote.forkAndSpecialize()方法fork出新进程,该方法是创建新进程的核心方法,它主要会陆续调用三个 方法来完成工作:
- preFork():先停止Zygote进程的四个Daemon子线程的运行以及初始化GC堆。这四个Daemon子线程分别为:Java堆内存管理现场、堆线下引用队列线程、析构线程与监控线程。
- nativeForkAndSpecialize():调用Linux系统函数fork()创建新进程,创建Java堆处理的线程池,重置GC性能数据,设置进程的信号处理函数,启动JDWP线程。
- postForkCommon():启动之前停止的Zygote进程的四个Daemon子线程。
上面的方法都完成会后,新进程会创建完成,并返回pid,接着就调用handleChildProc()来启动新进程。handleChildProc()方法会接着调用RuntimeInit.zygoteInit()来 完成新进程的启动。
1.4 RuntimeInit.zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
这个就是个关键的方法了,它主要用来创建一些运行时环境,我们来看一看。
public class RuntimeInit {
public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
if (DEBUG) Slog.d(TAG, “RuntimeInit: Starting application from zygote”);
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, “RuntimeInit”);
redirectLogStreams();
//创建应用进程的时区和键盘等通用信息
commonInit();
//在应用进程中创建一个Binder线程池
nativeZygoteInit();
//创建应用信息
applicationInit(targetSdkVersion, argv, classLoader);
}
}
该方法主要完成三件事:
- 调用commonInit()方法创建应用进程的时区和键盘等通用信息。
- 调用nativeZygoteInit()方法在应用进程中创建一个Binder线程池。
- 调用applicationInit(targetSdkVersion, argv, classLoader)方法创建应用信息。
Binder线程池我们后续的文章会分析,我们重点来看看applicationInit(targetSdkVersion, argv, classLoader)方法的实现,它主要用来完成应用的创建。
该方法里的argv参数指的就是ActivityThread,该方法会调用invokeStaticMain()通过反射的方式调用ActivityThread类的main()方法。如下所示:
public class RuntimeInit {
private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
//…
// Remaining arguments are passed to the start class’s static main
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
Class<?> cl;
//通过反射调用ActivityThread类的main()方法
try {
cl = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException ex) {
throw new RuntimeException(
"Missing class when invoking static main " + className,
ex);
}
Method m;
try {
m = cl.getMethod(“main”, new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
throw new RuntimeException(
"Missing static main on " + className, ex);
} catch (SecurityException ex) {
throw new RuntimeException(
"Problem getting static main on " + className, ex);
}
//…
}
}
走到ActivityThread类的main()方法,我们就很熟悉了,我们知道在main()方法里,会创建主线程Looper,并开启消息循环,如下所示:
public final class ActivityThread {
public static void main(String[] args) {
//…
Environment.initForCurrentUser();
//…
Process.setArgV0(“”);
//创建主线程looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
//attach到系统进程
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//主线程进入循环状态
Looper.loop();
throw new RuntimeException(“Main thread loop unexpectedly exited”);
}
}
前面我们从Process.start()开始讲起,分析了应用进程的创建及启动流程,既然有启动就会有结束,接下来我们从 Process.killProcess()开始讲起,继续分析进程的结束流程。
二 进程的优先级
进程按照优先级大小不同又可以分为实时进程与普通进程。
prio值越小表示进程优先级越高,
- 静态优先级:优先级不会随时间改变,内核也不会修改,只能通过系统调用改变nice值,优先级映射公式为:static_prio = MAX_RT_PRIO + nice + 20,其中MAX_RT_PRIO = 100,那么取值区间为[100, 139];对应普通进程;
- 实时优先级:取值区间为[0, MAX_RT_PRIO -1],其中MAX_RT_PRIO = 100,那么取值区间为[0, 99];对应实时进程;
- 懂爱优先级:调度程序通过增加或者减少进程优先级,来达到奖励IO消耗型或按照惩罚CPU消耗型的进程的效果。区间范围[0, MX_PRIO-1],其中MX_PRIO = 140,那么取值区间为[0,139];
三 进程调度流程
进程的调度在Process类里完成。
3.1 优先级调度
优先级调度方法
setThreadPriority(int tid, int priority)
进程的优先级以及对应的nice值如下所示:
- THREAD_PRIORITY_LOWEST 19 最低优先级
- THREAD_PRIORITY_BACKGROUND 10 后台
- THREAD_PRIORITY_LESS_FAVORABLE 1 比默认略低
- THREAD_PRIORITY_DEFAULT 0 默认
- THREAD_PRIORITY_MORE_FAVORABLE -1 比默认略高
- THREAD_PRIORITY_FOREGROUND -2 前台
- THREAD_PRIORITY_DISPLAY -4 显示相关
- THREAD_PRIORITY_URGENT_DISPLAY -8 显示(更为重要),input事件
- THREAD_PRIORITY_AUDIO -16 音频相关
- THREAD_PRIORITY_URGENT_AUDIO -19 音频(更为重要)
3.2 组优先级调度
进程组优先级调度方法
setProcessGroup(int pid, int group)
setThreadGroup(int tid, int group)
组优先级及对应取值
- THREAD_GROUP_DEFAULT -1 仅用于setProcessGroup,将优先级<=10的进程提升到-2
- THREAD_GROUP_BG_NONINTERACTIVE 0 CPU分时的时长缩短
- THREAD_GROUP_FOREGROUND 1 CPU分时的时长正常
- THREAD_GROUP_SYSTEM 2 系统线程组
- THREAD_GROUP_AUDIO_APP 3 应用程序音频
- THREAD_GROUP_AUDIO_SYS 4 系统程序音频
3.3 调度策略
调度策略设置方法
setThreadScheduler(int tid, int policy, int priority)
- SCHED_OTHER 默认 标准round-robin分时共享策略
- SCHED_BATCH 批处理调度 针对具有batch风格(批处理)进程的调度策略
- SCHED_IDLE 空闲调度 针对优先级非常低的适合在后台运行的进程
- SCHED_FIFO 先进先出 实时调度策略,android暂未实现
- SCHED_RR 循环调度 实时调度策略,android暂未实现
3.4 进程adj调度
另外除了这些基本的调度策略,Android系统还定义了两个和进程相关的状态值,一个就是定义在ProcessList.java里的adj值,另一个 是定义在ActivityManager.java里的procState值。
定义在ProcessList.java文件,oom_adj划分为16级,从-17到16之间取值。
- UNKNOWN_ADJ 16 一般指将要会缓存进程,无法获取确定值
- CACHED_APP_MAX_ADJ 15 不可见进程的adj最大值 1
- CACHED_APP_MIN_ADJ 9 不可见进程的adj最小值 2
- SERVICE_B_AD 8 B List中的Service(较老的、使用可能性更小)
- PREVIOUS_APP_ADJ 7 上一个App的进程(往往通过按返回键)
- HOME_APP_ADJ 6 Home进程
- SERVICE_ADJ 5 服务进程(Service process)
- HEAVY_WEIGHT_APP_ADJ 4 后台的重量级进程,system/rootdir/init.rc文件中设置
- BACKUP_APP_ADJ 3 备份进程 3
- PERCEPTIBLE_APP_ADJ 2 可感知进程,比如后台音乐播放 4
- VISIBLE_APP_ADJ 1 可见进程(Visible process) 5
- FOREGROUND_APP_ADJ 0 前台进程(Foreground process) 6
- PERSISTENT_SERVICE_ADJ -11 关联着系统或persistent进程
- PERSISTENT_PROC_ADJ -12 系统persistent进程,比如telephony
- SYSTEM_ADJ -16 系统进程
- NATIVE_ADJ -17 native进程(不被系统管理)
更新进程adj值的方法定义在ActivityManagerService中,分别为:
- updateOomAdjLocked:更新adj,当目标进程为空,或者被杀则返回false;否则返回true;
- computeOomAdjLocked:计算adj,返回计算后RawAdj值;
- applyOomAdjLocked:应用adj,当需要杀掉目标进程则返回false;否则返回true。
那么进程的adj值什么时候会被更新呢?🤔
Activity
- ActivityManagerService.realStartActivityLocked: 启动Activity
- ActivityStack.resumeTopActivityInnerLocked: 恢复栈顶Activity
- ActivityStack.finishCurrentActivityLocked: 结束当前Activity
- ActivityStack.destroyActivityLocked: 摧毁当前Activity
Service
- ActiveServices.realStartServiceLocked: 启动服务
- ActiveServices.bindServiceLocked: 绑定服务(只更新当前app)
- ActiveServices.unbindServiceLocked: 解绑服务 (只更新当前app)
- ActiveServices.bringDownServiceLocked: 结束服务 (只更新当前app)
- ActiveServices.sendServiceArgsLocked: 在bringup或则cleanup服务过程调用 (只更新当前app)
BroadcastReceiver
- BroadcastQueue.processNextBroadcast: 处理下一个广播
- BroadcastQueue.processCurBroadcastLocked: 处理当前广播
- BroadcastQueue.deliverToRegisteredReceiverLocked: 分发已注册的广播 (只更新当前app)
ContentProvider
- ActivityManagerService.removeContentProvider: 移除provider
- ActivityManagerService.publishContentProviders: 发布provider (只更新当前app)
- ActivityManagerService.getContentProviderImpl: 获取provider (只更新当前app)
最后
今天关于面试的分享就到这里,还是那句话,有些东西你不仅要懂,而且要能够很好地表达出来,能够让面试官认可你的理解,例如Handler机制,这个是面试必问之题。有些晦涩的点,或许它只活在面试当中,实际工作当中你压根不会用到它,但是你要知道它是什么东西。
最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司19年的面试题,把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节,由于篇幅有限,这里以图片的形式给大家展示一部分。
还有 高级架构技术进阶脑图、Android开发面试专题资料,高级进阶架构资料 帮助大家学习提升进阶,也节省大家在网上搜索资料的时间来学习,也可以分享给身边好友一起学习。
【Android核心高级技术PDF文档,BAT大厂面试真题解析】
【算法合集】
【延伸Android必备知识点】
【Android部分高级架构视频学习资源】
Android精讲视频领取学习后更加是如虎添翼!进军BATJ大厂等(备战)!现在都说互联网寒冬,其实无非就是你上错了车,且穿的少(技能),要是你上对车,自身技术能力够强,公司换掉的代价大,怎么可能会被裁掉,都是淘汰末端的业务Curd而已!现如今市场上初级程序员泛滥,这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期,想要年后突破自己涨薪的,进阶Android中高级、架构师对你更是如鱼得水,赶快领取吧!
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!
集】**
[外链图片转存中…(img-9zGASDxI-1714873837780)]
【延伸Android必备知识点】
[外链图片转存中…(img-iRGa1yTO-1714873837780)]
【Android部分高级架构视频学习资源】
Android精讲视频领取学习后更加是如虎添翼!进军BATJ大厂等(备战)!现在都说互联网寒冬,其实无非就是你上错了车,且穿的少(技能),要是你上对车,自身技术能力够强,公司换掉的代价大,怎么可能会被裁掉,都是淘汰末端的业务Curd而已!现如今市场上初级程序员泛滥,这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期,想要年后突破自己涨薪的,进阶Android中高级、架构师对你更是如鱼得水,赶快领取吧!
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!