Android进程

一个学渣的自我救赎

已于 2024-05-04 00:16:29 修改

阅读量781

点赞数 16

分类专栏： Android Framework 文章标签： android

于 2024-05-02 19:36:58 首次发布

本文链接：https://blog.csdn.net/liuning1985622/article/details/138398209

版权

Android Framework 专栏收录该内容

372 篇文章 23 订阅

订阅专栏

一、Android进程介绍

进程的基本概念

进程是计算机中正在运行的程序的实例。每个进程都有自己的内存空间和系统资源，并且可以独立地执行任务。进程是操作系统进行资源分配和调度的基本单位。

进程的基本概念包括以下几个方面：

进程状态：进程在其生命周期中会经历不同的状态，包括就绪、运行、阻塞和终止等状态。就绪状态表示进程已经准备好执行，但还没有获得CPU的执行权；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，例如等待输入/输出操作完成；终止状态表示进程已经完成了它的任务并退出。
进程控制块（PCB）：每个进程都有一个与之对应的进程控制块，用于存储进程的相关信息，包括进程的标识符、状态、优先级、程序计数器、内存分配情况等。操作系统通过操作进程控制块来管理和控制进程的执行。
进程间通信：在多进程系统中，进程之间需要进行通信和数据交换。常见的进程间通信方式包括管道、消息队列、共享内存和信号量等。
进程调度：操作系统通过进程调度算法来决定哪个进程获得CPU的执行权。常见的调度算法包括先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（RR）和优先级调度等。
进程同步：多个进程之间可能需要协调和同步它们的执行。常见的进程同步机制包括互斥锁、条件变量和信号量等。
进程创建和终止：操作系统提供了创建和终止进程的接口，可以通过系统调用来创建新的进程，并在进程完成任务后终止它们。

进程和线程的区别

进程和线程是操作系统中的两个重要概念，它们都是用来实现并发执行的方式，但在实现方式和资源管理上有一些区别。

进程是操作系统中的一个执行单位，它拥有独立的内存空间和系统资源，包括文件描述符、信号处理等。每个进程都是独立运行的，它们之间的通信需要通过进程间通信（IPC）机制来实现。进程之间的切换开销较大，因为需要保存和恢复进程的上下文信息。
线程是进程中的一个执行流，它与同一进程中的其他线程共享相同的内存空间和系统资源。线程之间可以直接访问共享的数据，因此线程之间的通信更加方便和高效。线程的切换开销较小，因为不需要切换内存空间。
进程和线程的关系是一对多的关系，一个进程可以包含多个线程。多线程可以提高程序的并发性和响应性，但也增加了线程同步和资源竞争的问题。
并行和并发是两个概念。并行是指多个任务同时执行，需要具备多个处理器或者多核处理器的支持。而并发是指多个任务交替执行，通过时间片轮转等方式实现。

综上所述，进程和线程的区别主要体现在资源管理、通信方式和执行方式上。进程拥有独立的资源和内存空间，通信需要通过IPC机制，执行方式是并发的；而线程共享资源和内存空间，通信更加方便高效，执行方式可以是并发或并行的。

Android进程介绍

Android系统的底层为Linux，因此进程也是采用Linux机制。对应Android系统，APP在启动的时候就开启了一个进程。开发中在 MainiFest 中对 application 或者四大组件进行 android:process 属性设置，可以为其分配进程。默认情况下，同一应用程序的所有组件都运行在一个进程里面，当然也可以在Manifest里面配置一个Service在特定的进程里面去后台做一些操作。线程不是越多越好，最好是CPU个数+1。

Android会尽量保留一个正在运行进程，只在内存资源出现不足时，Android会尝试停止一些进程从而释放足够的资源给其他新的进程使用，也能保证用户正在访问的当前进程有足够的资源去及时地响应用户的事件。Android会根据进程中运行的组件类别以及组件的状态来判断该进程的重要性，Android会首先停止那些不重要的进程。按照重要性从高到低一共有五个级别：

■前台进程

前台进程是用户当前正在使用的进程。只有一些前台进程可以在任何时候都存在。他们是最后一个被结束的，当内存低到根本连他们都不能运行的时候。一般来说，在这种情况下，设备会进行内存调度，中止一些前台进程来保持对用户交互的响应。

■可见进程

可见进程不包含前台的组件但是会在屏幕上显示一个可见的进程是的重要程度很高，除非前台进程需要获取它的资源，不然不会被中止。

■服务进程

运行着一个通过startService() 方法启动的service，这个service不属于上面提到的2种更高重要性的。service所在的进程虽然对用户不是直接可见的，但是他们执行了用户非常关注的任务(比如播放mp3，从网络下载数据)。只要前台进程和可见进程有足够的内存，系统不会回收他们。

■后台进程

运行着一个对用户不可见的activity(调用过 onStop() 方法).这些进程对用户体验没有直接的影响，可以在服务进程、可见进程、前台进程需要内存的时候回收。通常，系统中会有很多不可见进程在运行，他们被保存在LRU (least recently used) 列表中，以便内存不足的时候被第一时间回收。如果一个activity正确的执行了它的生命周期，关闭这个进程对于用户体验没有太大的影响。

■空进程

未运行任何程序组件。运行这些进程的唯一原因是作为一个缓存，缩短下次程序需要重新使用的启动时间。系统经常中止这些进程，这样可以调节程序缓存和系统缓存的平衡。

Android 对进程的重要性评级的时候，选取它最高的级别。另外，当被另外的一个进程依赖的时候，某个进程的级别可能会增高。一个为其他进程服务的进程永远不会比被服务的进程重要级低。因为服务进程比后台activity进程重要级高，因此一个要进行耗时工作的activity最好启动一个service来做这个工作，而不是开启一个子进程――特别是这个操作需要的时间比activity存在的时间还要长的时候。例如，在后台播放音乐，向网上上传摄像头拍到的图片，使用service可以使进程最少获取到“服务进程”级别的重要级，而不用考虑activity目前是什么状态。broadcast receivers做费时的工作的时候，也应该启用一个服务而不是开一个线程。

Android系统中存在的进程

1. Zygote进程

Zygote，受精卵的意思。在Android系统中，所有的系统服务进程SystemServer以及应用程序进程都是由Zygote进程Fork（孕育）出来的。

2. App主进程

每一个App都是运行在一个独立的进程中；这个进程也是由Zygote进程Fork出来的；App的进程的名称就是包名，并由AMS（ActivityManagerService）管理，BroadcastReceiver的发送也是由AMS来完成的。

3. App辅助进程

一个App可以拥有多个进程；具体为在AndroidManifest.xml文件中为Activity或者Service进行配置android:process=""；辅助进程也是由Zygote Fork出来并由AMS管理

4. Native进程

Android程序运行在Dalvik虚拟机中；NDK允许用户使用类似C / C++之类的原生代码语言执行部分程序；由NDK所Fork出的进程称之为Native进程；Native进程自由度较高可以不受AMS管理；NDK也可用来做进程保活；

Android系统中进程的优先级

Android系统中进程的优先级定义在com.android.server.am.ProcessList 类中，这个类在SDK中可以找到；

在 LMS 回收内存时会根据进程的级别优先杀死 OOM_ADJ 比较大的进程，对于优先级相同的进程则进一步受到进程所占内存和进程存活时间的影响；

主要优先级定义（oom_adj值）

（1）oom_adj >= 4,比较容易被kill的进程

（2）4> oom_adj >= 0,不容易被kill的Android进程

（3）oom_adj < 0 ,Linux进程，非安卓进程

名称	说明
UNKNOWN_ADJ = 16	预留最低级别，一般指将要会缓存进程，无法获取确定值
CACHED_APP_MAX_ADJ = 15	持有不可见的Activity的进程，也就是后台进程，系统内存不足会被Kill
CACHED_APP_MIN_ADJ = 9	缓存进程，也就是空进程
SERVICE_B_ADJ = 8	SERVICE_B_ADJ = 8
PREVIOUS_APP_ADJ = 7	切换进程，切换应用程序时保存的之前的进程,上一个App的进程
HOME_APP_ADJ = 6	与Home交互的进程
SERVICE_ADJ = 5	包含Service的进程，一般来说Kill掉对用户影响不太大
HEAVY_WEIGHT_APP_ADJ = 4	高权重进程，在后台运行但是系统尽量不Kill掉
BACKUP_APP_ADJ = 3	托管备份的进程，Kill掉是一个bad idea值
PERCEPTIBLE_APP_ADJ = 2	可被用户感知的进程，比如音乐播放器
VISIBLE_APP_ADJ = 1	可见进程(Visible process)，但不一定都是前台进程，有可能是被覆盖的Activity
FOREGROUND_APP_ADJ = 0	前台进程，运行在前台的App的进程
PERSISTENT_SERVICE_ADJ = -11	重要进程，系统或重要进程绑定的进程
PERSISTENT_PROC_ADJ = -12	核心进程，系统持续进程，如电话
SYSTEM_ADJ = -16	系统进程
NATIVE_ADJ = -17	不由系统管理的Native相关进程

二、Android进程间通信

无论是Android系统，还是各种Linux衍生系统，各个组件、模块往往运行在各种不同的进程和线程内，这里就必然涉及进程/线程之间的通信。对于IPC(Inter-Process Communication, 进程间通信)，Linux现有管道、消息队列、共享内存、套接字、信号量、信号这些IPC机制，Android额外还有Binder IPC机制，Android OS中的Zygote进程的IPC采用的是Socket机制，在上层system server、media server以及上层App之间更多的是采用Binder IPC方式来完成跨进程间的通信。对于Android上层架构中，很多时候是在同一个进程的线程之间需要相互通信，例如同一个进程的主线程与工作线程之间的通信，往往采用的Handler消息机制。

想深入理解Android内核层架构，必须先深入理解Linux现有的IPC机制；对于Android上层架构，则最常用的通信方式是Binder、Socket、Handler，其中Binder主要用于进程间通信，AIDL就是基于Binder通信实现的。Socket主要用于网络通信。而Handler主要用户线程间通信，下面重点介绍一下Binder通信。

Binder作为Android系统提供的一种IPC机制，无论从系统开发还是应用开发，都是Android系统中最重要的组成，也是最难理解的一块知识点。深入了解Binder机制，最好的方法便是阅读源码，借用Linux鼻祖Linus Torvalds曾说过的一句话：Read The Fucking Source Code。下面简要说说Binder IPC原理。

Binder IPC原理

Binder通信采用c/s架构，从组件视角来说，包含Client、Server、ServiceManager以及binder驱动，其中ServiceManager用于管理系统中的各种服务。

Binder IPC通信过程

1.首先，一个进程使用 BINDER_SET_CONTEXT_MGR 命令通过 Binder 驱动将自己注册成为 ServiceManager

2.Server 通过驱动向 ServiceManager 中注册 Binder（Server 中的 Binder 实体），表明可以对外提供服务。驱动为这个 Binder 创建位于内核中的实体节点以及 ServiceManager 对实体的引用，将名字以及新建的引用打包传给 ServiceManager，ServiceManger 将其填入查找表。

3.Client 通过名字，在 Binder 驱动的帮助下从 ServiceManager 中获取到对 Binder 实体的引用，通过这个引用就能实现和 Server 进程的通信。

Binder IPC 数据传输过程

1.首先 Binder 驱动在内核空间创建一个数据接收缓存区；

2.接着在内核空间开辟一块内核缓存区，建立内核缓存区和内核中数据接收缓存区之间的映射关系，以及内核中数据接收缓存区和接收进程用户空间地址的映射关系；

3.发送方进程通过系统调用 copy_from_user() 将数据 copy 到内核中的内核缓存区，由于内核缓存区和接收进程的用户空间存在内存映射，因此也就相当于把数据发送到了接收进程的用户空间，这样便完成了一次进程间的通信。

Binder 是基于 C/S 架构的。由一系列的组件组成，包括 Client、Server、ServiceManager、Binder 驱动。

其中 Client、Server、Service Manager 运行在用户空间，Binder 驱动运行在内核空间。

其中 Service Manager 和 Binder 驱动由系统提供，而 Client、Server 由应用程序来实现。

Client、Server 和 ServiceManager 均是通过系统调用 open、mmap 和 ioctl 来访问设备文件 /dev/binder，从而实现与 Binder 驱动的交互来间接的实现跨进程通信。

Binder通信的代理模式

当 A 进程想要获取 B 进程中的 object 时，驱动并不会真的把 object 返回给 A，而是返回了一个跟 object 看起来一模一样的代理对象 objectProxy，这个 objectProxy 具有和 object 一摸一样的方法，但是这些方法并没有 B 进程中 object 对象那些方法的能力，这些方法只需要把把请求参数交给驱动即可。对于 A 进程来说和直接调用 object 中的方法是一样的。

当 Binder 驱动接收到 A 进程的消息后，发现这是个 objectProxy 就去查询自己维护的表单，一查发现这是 B 进程 object 的代理对象。于是就会去通知 B 进程调用 object 的方法，并要求 B 进程把返回结果发给自己。当驱动拿到 B 进程的返回结果后就会转发给 A 进程，一次通信就完成了。

Binder通信的特点

面向对象思想的引入将进程间通信转化为通过对某个Binder对象的引用调用该对象的方法，而其独特之处在于Binder对象是一个可以跨进程引用的对象，它的实体（本地对象）位于一个进程中，而它的引用（代理对象）却遍布于系统的各个进程之中。最诱人的是，这个引用和java里引用一样既可以是强类型，也可以是弱类型，而且可以从一个进程传给其它进程，让大家都能访问同一Server，就象将一个对象或引用赋值给另一个引用一样。Binder模糊了进程边界，淡化了进程间通信过程，整个系统仿佛运行于同一个面向对象的程序之中。形形色色的Binder对象以及星罗棋布的引用仿佛粘接各个应用程序的胶水，这也是Binder在英文里的原意。

Binder跨进程传输并不是真的把一个对象传输到了另外一个进程；传输过程好像是Binder跨进程穿越的时候，它在一个进程留下了一个真身，在另外一个进程幻化出一个影子（这个影子可以很多个）；Client进程的操作其实是对于影子的操作，影子利用Binder驱动最终让真身完成操作。

由于驱动返回的objectProxy与Server进程里面原始的object是如此相似，给人感觉好像是直接把Server进程里面的对象object传递到了Client进程；因此，我们可以说Binder对象是可以进行跨进程传递的对象

Android系统实现这种机制使用的是代理模式, 对于Binder的访问，如果是在同一个进程（不需要跨进程），那么直接返回原始的Binder实体；如果在不同进程，那么就给他一个代理对象（影子）；我们在系统源码以及AIDL的生成代码里面可以看到很多这种实现。Client进程只不过是持有了Server端的代理；代理对象协助驱动完成了跨进程通信。

通常意义下，Binder指的是一种通信机制；我们说AIDL使用Binder进行通信，指的就是Binder这种IPC机制。

对于Server进程来说，Binder指的是Binder本地对象，对于Client来说，Binder指的是Binder代理对象，它只是Binder本地对象的一个远程代理；对这个Binder代理对象的操作，会通过驱动最终转发到Binder本地对象上去完成；对于一个拥有Binder对象的使用者而言，它无须关心这是一个Binder代理对象还是Binder本地对象；对于代理对象的操作和对本地对象的操作对它来说没有区别。对于传输过程而言，Binder是可以进行跨进程传递的对象；Binder驱动会对具有跨进程传递能力的对象做特殊处理：自动完成代理对象和本地对象的转换。

Binder机制跨进程原理

首先，Server进程要向SM注册；告诉自己是谁，自己有什么能力；在这个场景就是Server告诉SM，它叫zhangsan，它有一个object对象，可以执行add 操作；于是SM建立了一张表：zhangsan这个名字对应进程Server;

然后Client向SM查询：我需要联系一个名字叫做zhangsan的进程里面的object对象；这时候关键来了：进程之间通信的数据都会经过运行在内核空间里面的驱动，驱动在数据流过的时候做了一点手脚，它并不会给Client进程返回一个真正的object对象，而是返回一个看起来跟object一模一样的代理对象objectProxy，这个objectProxy也有一个add方法，但是这个add方法没有Server进程里面object对象的add方法那个能力；objectProxy的add只是一个傀儡，它唯一做的事情就是把参数包装然后交给驱动。

但是Client进程并不知道驱动返回给它的对象动过手脚，毕竟伪装的太像了，如假包换。Client开开心心地拿着objectProxy对象然后调用add方法；我们说过，这个add什么也不做，直接把参数做一些包装然后直接转发给Binder驱动。

驱动收到这个消息，发现是这个objectProxy；一查表就明白了：我之前用objectProxy替换了object发送给Client了，它真正应该要访问的是object对象的add方法；于是Binder驱动通知Server进程，调用你的object对象的add方法，然后把结果发给我，Sever进程收到这个消息，照做之后将结果返回驱动，驱动然后把结果返回给Client进程；于是整个过程就完成了。

但事实上我们知道，Binder跨进程传输并不是真的把一个对象传输到了另外一个进程；传输过程好像是Binder跨进程穿越的时候，它在一个进程留下了一个真身，在另外一个进程幻化出一个影子（这个影子可以很多个）；Client进程的操作其实是对于影子的操作，影子利用Binder驱动最终让真身完成操作。

理解这一点非常重要；务必仔细体会。另外，Android系统实现这种机制使用的是代理模式, 对于Binder的访问，如果是在同一个进程（不需要跨进程），那么直接返回原始的Binder实体；如果在不同进程，那么就给他一个代理对象（影子）；我们在系统源码以及AIDL的生成代码里面可以看到很多这种实现。

另外我们为了简化整个流程，隐藏了SM这一部分驱动进行的操作；实际上，由于SM与Server通常不在一个进程，Server进程向SM注册的过程也是跨进程通信，驱动也会对这个过程进行暗箱操作：SM中存在的Server端的对象实际上也是代理对象，后面Client向SM查询的时候，驱动会给Client返回另外一个代理对象。Sever进程的本地对象仅有一个，其他进程所拥有的全部都是它的代理。

一句话总结就是：Client进程只不过是持有了Server端的代理；代理对象协助驱动完成了跨进程通信。

IBinder的主要API是transact()，与它对应另一方法是Binder.onTransact()。第一个方法使你可以向远端的IBinder对象发送发出调用，第二个方法使你自己的远程对象能够响应接收到的调用。IBinder的API都是同步执行的，比如transact()直到对方的Binder.onTransact()方法调用完成后才返回。调用发生在进程内时无疑是这样的，而在进程间时，在IPC的帮助下，也是同样的效果。

通过transact()发送的数据是Parcel，Parcel是一种一般的缓冲区，除了有数据外还带有一些描述它内容的元数据。元数据用于管理IBinder对象的引用，这样就能在缓冲区从一个进程移动到另一个进程时保存这些引用。这样就保证了当一个IBinder被写入到Parcel并发送到另一个进程中，如果另一个进程把同一个IBinder的引用回发到原来的进程，那么这个原来的进程就能接收到发出的那个IBinder的引用。这种机制使IBinder和Binder像唯一标志符那样在进程间管理。

系统为每个进程维护一个存放交互线程的线程池。这些交互线程用于派送所有从另外进程发来的IPC调用。例如：当一个IPC从进程A发到进程B，A中那个发出调用的线程(这个应该不在线程池中)就阻塞在transact()中了。进程B中的交互线程池中的一个线程接收了这个调用，它调用Binder.onTransact()，完成后用一个Parcel来做为结果返回。然后进程A中的那个等待的线程在收到返回的Parcel后得以继续执行。实际上，另一个进程看起来就像是当前进程的一个线程，但不是当前进程创建的。

Binder机制还支持进程间的递归调用。例如，进程A执行自己的IBinder的transact()调用进程B的Binder，而进程B在其Binder.onTransact()中又用transact()向进程A发起调用，那么进程A在等待它发出的调用返回的同时，还会用Binder.onTransact()响应进程B的transact()。总之Binder造成的结果就是让我们感觉到跨进程的调用与进程内的调用没什么区别。

三、Android进程相关接口

IInterface

Base class for Binder interfaces. When defining a new interface, you must derive it from IInterface.

Binder 接口的基类。定义新接口时，必须从 IInterface 派生该接口。

IInterface文件路径：

frameworks/base/core/java/android/os/IInterface.java

IInterface定义：

public interface IInterface {
    public IBinder asBinder(); //检索与此接口关联的 Binder 对象。
}

IBinder

Base interface for a remotable object, the core part of a lightweight remote procedure call mechanism designed for high performance when performing in-process and cross-process calls. This interface describes the abstract protocol for interacting with a remotable object.

可远程处理对象的基本接口，是轻量级远程过程调用机制的核心部分，旨在在执行进程内和跨进程调用时实现高性能。此接口描述用于与可远程处理对象交互的抽象协议。

IBinder文件路径：

frameworks/base/core/java/android/os/IBinder.java

IBinder定义：

public interface IBinder {
    static int getSuggestedMaxIpcSizeBytes(); //Limit that should be placed on IPC sizes,     in bytes, to keep them safely under the transaction buffer limit.
    public @Nullable String getInterfaceDescriptor(); //Get the canonical name of the interface supported by this binder.
    public boolean pingBinder(); //Check to see if the object still exists.
    public boolean isBinderAlive(); //Check to see if the process that the binder is in is still alive.
    public @Nullable IInterface queryLocalInterface(@NonNull String descriptor); //Attempt to retrieve a local implementation of an interface for this Binder object. 
    public void dump(@NonNull FileDescriptor fd, @Nullable String[] args); //Print the object's state into the given stream.
    public void dumpAsync(@NonNull FileDescriptor fd, @Nullable String[] args);
    public void shellCommand(@Nullable FileDescriptor in, @Nullable FileDescriptor out, @Nullable FileDescriptor err, @NonNull String[] args, @Nullable ShellCallback shellCallback, @NonNull ResultReceiver resultReceiver); //Execute a shell command on this object.  This may be performed asynchrously from the caller;
    public default @Nullable IBinder getExtension(); //Get the binder extension of this binder interface.
    public interface DeathRecipient { //Interface for receiving a callback when the process hosting an IBinder has gone away
        public void binderDied(); 
    }
    public void linkToDeath(@NonNull DeathRecipient recipient, int flags); //Register the recipient for a notification if this binder goes away. 
    public boolean unlinkToDeath(@NonNull DeathRecipient recipient, int flags); //Remove a previously registered death notification.
}

四、Android进程相关类

Process

Android中的Process类是用于管理和控制进程的类。它提供了一些静态方法，可以用来获取当前进程的信息，以及启动和停止其他进程。

Process文件路径：

frameworks/base/core/java/android/os/Process.java

Process定义：

public class Process {
    public static final class ProcessStartResult {}
}

Process 方法：

public static final int myPid() ：Returns the identifier of this process
public static final int myPpid() ：Returns the identifier of this process' parent.
public static final int myTid()：Returns the identifier of the calling thread
public static final int myUid() ：Returns the identifier of this process's uid. 
public static UserHandle myUserHandle()：Returns this process's user handle.
public static boolean isCoreUid(int uid)：Returns whether the given uid belongs to a system core component or not.
public static boolean isApplicationUid(int uid) ：Returns whether the given uid belongs to an application.
public static final boolean isIsolated() ：Returns whether the current process is in an isolated sandbox.
public static final boolean isIsolatedUid(int uid) ：Returns whether the process with the given {@code uid} is an isolated sandbox.
public static final native int getUidForName(String name)：Returns the UID assigned to a particular user name, or -1 if there is none. 
public static final native int getGidForName(String name)：Returns the GID assigned to a particular user name, or -1 if there is none. 
public static final int getUidForPid(int pid)：Returns a uid for a currently running process.
public static final int getParentPid(int pid)：Returns the parent process id for a currently running process.
public static final int getThreadGroupLeader(int tid)：Returns the thread group leader id for a currently running thread.
public static final native void setThreadPriority(int tid, int priority)：Set the priority of a thread, based on Linux priorities.
public static final native void setThreadPriority(int priority)：Set the priority of the calling thread, based on Linux priorities. 
public static final native void setThreadGroup(int tid, int group)：Sets the scheduling group for a thread.
public static final native void setThreadGroupAndCpuset(int tid, int group)：Sets the scheduling group and the corresponding cpuset group.
public static final native void setProcessGroup(int pid, int group)：Sets the scheduling group for a process and all child threads.
public static final native void setProcessFrozen(int pid, int uid, boolean frozen)：Freeze or unfreeze the specified process.
public static final native void enableFreezer(boolean enable)：Enable or disable the freezer.
public static final native int getProcessGroup(int pid)：Return the scheduling group of requested process.
public static final native int createProcessGroup(int uid, int pid)：Create a new process group in the cgroup uid/pid hierarchy
public static final native int getThreadPriority(int tid)：Return the current priority of a thread, based on Linux priorities.
public static final native void setThreadScheduler(int tid, int policy, int priority)：Set the scheduling policy and priority of a thread, based on Linux.
public static final native boolean setSwappiness(int pid, boolean is_increased)：Adjust the swappiness level for a process.
public static final void killProcess(int pid) ：Kill the process with the given PID.
public static final native void sendSignal(int pid, int signal)：Send a signal to the given process.

ZygoteProcess

Maintains communication state with the zygote processes.

ZygoteProcess文件路径：

frameworks/base/core/java/android/os/ZygoteProcess.java

ZygoteProcess定义：

public class ZygoteProcess {}

Binder

可远程处理对象的基类，是 IBinder 定义的轻量级远程过程调用机制的核心部分。

Binder文件路径：

frameworks/base/core/java/android/os/Binder.java

Binder定义：

public class Binder implements IBinder {
    private static class NoImagePreloadHolder {}
    public static class PropagateWorkSourceTransactListener implements ProxyTransactListener {}
}

BinderProxy

BinderProxy类是Binder类的一个代理类，它实现了IBinder接口的transact方法，通过调用Parcel类进行类似IO操作的数据传输。

BinderProxy文件路径：

frameworks/base/core/java/android/os/BinderProxy.java

BinBinderProxyder定义：

public final class BinderProxy implements IBinder {
    private static class BinderProxyMapSizeException extends AssertionError {}
    private static final class ProxyMap {}
    private static class NoImagePreloadHolder {}
}

RemoteCallbackList

RemoteCallbackList是Android框架中的一个类，用于管理回调接口对象。它提供了注册、注销和通知回调接口对象的功能。当客户端需要与服务端进行通信并接收回调时，可以使用RemoteCallbackList来管理回调接口对象。

在使用RemoteCallbackList时，可以通过调用registerCallback方法将回调接口对象添加到RemoteCallbackList中。当需要通知客户端时，可以调用notifyCallbacks方法，遍历RemoteCallbackList中所有的回调接口对象，并调用其相应的方法，实现回调的功能。当不再需要某个回调接口对象时，可以调用unregisterCallback方法将其从RemoteCallbackList中移除。

RemoteCallbackList内部使用了一些同步机制，以保证其在并发操作时的正确性。因此，可以在多线程环境下安全地使用RemoteCallbackList来管理回调接口对象。它在 Android 系统中广泛应用于各种系统服务和框架组件中，如通知服务、Activity 生命周期回调、媒体播放器等等。

RemoteCallbackList文件路径：

frameworks/base/core/java/android/os/RemoteCallbackList.java

RemoteCallbackList定义：

public class RemoteCallbackList<E extends IInterface> {
    private final class Callback implements IBinder.DeathRecipient {}
}

RemoteCallbackList 方法：

public boolean register(E callback)：注册一个回调接口对象。
public boolean register(E callback, Object cookie) ： 注册一个回调接口对象。
public boolean unregister(E callback)：注销一个回调接口对象。
public int beginBroadcast()：开始通知客户端，返回客户端数量。
public E getBroadcastItem(int index)：获取指定位置的回调接口对象。
public void finishBroadcast()：通知客户端结束。
public void kill() ：Disable this callback list.
public void onCallbackDied(E callback, Object cookie) ：Called when the process hosting a callback in the list has gone away.
public Object getBroadcastCookie(int index) ：Retrieve the cookie associated with the item returned by {@link #getBroadcastItem(int)}.
public int getRegisteredCallbackCount()：Returns the number of registered callbacks. 
public E getRegisteredCallbackItem(int index) ：Return a currently registered callback. 
public Object getRegisteredCallbackCookie(int index)：Return any cookie associated with a currently registered callback.

ProcessState

ProcessState用于管理Android系统中的进程状态。它具有一些成员变量和成员函数，用于处理进程间通信和线程管理等任务。

ProcessState文件路径：

frameworks/native/libs/binder/ProcessState.cpp

frameworks/native/include/binder/ProcessState.h

ProcessState定义：

class PoolThread : public Thread {}
class ProcessState : public virtual RefBase {}

ProcessState方法：

void startThreadPool()：For main functions - dangerous for libraries to use

三、Android进程相关流程分析

AIDL过程分析

Android AIDL过程分析-CSDN博客

一个学渣的自我救赎

关注

16
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
Android进程

进程是计算机中正在运行的程序的实例。每个进程都有自己的内存空间和系统资源，并且可以独立地执行任务。进程是操作系统进行资源分配和调度的基本单位。进程的基本概念包括以下几个方面：进程状态：进程在其生命周期中会经历不同的状态，包括就绪、运行、阻塞和终止等状态。就绪状态表示进程已经准备好执行，但还没有获得CPU的执行权；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，例如等待输入/输出操作完成；终止状态表示进程已经完成了它的任务并退出。
复制链接

扫一扫

专栏目录