android singleInstance 多进程 android多进程开发

转载

云端筑梦工匠 2023-10-03 11:19:48

文章标签 android一个apk多个进程 android ide 序列化 文章分类 Android 移动开发

前言

好久没有写学习心得了，最近看了Android多进程相关的知识，是时候总结一下了，也方便以后自己温习，我主要围绕以下几点展开：

为何使用ipc

两种序列化的区别

Binder简单了解

实现多进程的方式有哪些

IPC的必要性

如果要用到ipc，那么必须有多进程的存在，为何要使用多进程呢，这里给出两点：

防止oom，考虑增加应用的使用内存，一个应用分得的内存是有限的，我们为了增加应用的内存，将一些模块单独放在进程中去，这样系统就会给这些模块单独分配内存，降低应用oom的概率。

跨应用获取数据，有时候想获取其他应用中的一些数据，比如联系人的信息，这些信息在其他模块，我们肯定不能直接获取到，这就需要ipc了，事实上ContentProvier也是多进程通信的方式，只是一些细节被屏蔽掉了，我们无法感知而已。

序列化

当使用多进程传递数据的时候，为了数据的一致性，我们就必须要将对象序列化和反序列化，序列化不是Android中的新概念，在Java中就有，序列化有两种方式Serializable和Parcelable接口。

1.Serializable接口

java序列化就是将实现了Serializable的对象转换成字符序列形式保存在文件中，在需要的时候再将字符序列转换为对象恢复原来的结构，即反序列化。这样我们既然是字符序列，我们就可以很方便的传输了，比如intent，多进程，甚至网络通信等等。
//序列化操作1--FileOutputStream
ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream("worm.out"));
oos1.writeObject("Worm storage By FileOutputStream ");
oos1.writeObject(w);//必须所有引用的对象都实现序列化(本例终究是Data这个类)，否则抛出有java.io.NotSerializableException:这个异常
oos1.close();
//反序列化操作1---FileInputStream
ObjectInputStream ois1 = new ObjectInputStream(new FileInputStream("worm.out"));
String s1 = (String)ois1.readObject();
Worm w1 = (Worm)ois1.readObject();
ois1.close();
System.out.println("反序列化操作1之后");
System.out.println(s1);
System.out.println("w1:"+w1);
复制代码public class Data implements Serializable {
private static final long serialVersionUID = 7247714666080613254L;
public int n;
public Data(int n) {
this.n = n;
}
public String toString(){
return Integer.toString(n);
}
}
复制代码
以上就是对实现了Serializable的对象进行序列化和反序列化，可以看出，序列化和反序列化就是将对象写入文件和对文件进行读取的过程，这也太明了了，就是这么简单，需要注意的是，所有的操作都是针对字节。
序列化操纵之前
w=:a(853):b(119):c(802):d(788):e(199):f(881)
反序列化操作1之后
Worm storage By FileOutputStream
w1::a(853):b(119):c(802):d(788):e(199):f(881)
复制代码
这里说明一下，serialVersionUID，这个玩意我们经常看到，它是干嘛的，既然系统加入这个肯定是有它的作用的啦，这个很重要，我们进行序列化的时候也会写入这个值，当在反序列化的时候我们会对这个值做个比较，如果一致就可以成功反序列化操作，否则就会抛异常。
Parcelable
在Android中，出现了一种新的序列化方法，那就是使用Parcelable，使用它我们就可以很方便在intent，binder传递数据啦，使用方式很简单。
public class FilterEntity implements Parcelable{
private String name;
private String chooseStr;
private boolean hasSelected;
public FilterEntity(String name, String chooseStr, boolean hasSelected) {
this.name = name;
this.chooseStr = chooseStr;
this.hasSelected = hasSelected;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getChooseStr() {
return chooseStr;
}
public void setChooseStr(String chooseStr) {
this.chooseStr = chooseStr;
}
public boolean isHasSelected() {
return hasSelected;
}
public void setHasSelected(boolean hasSelected) {
this.hasSelected = hasSelected;
}
@Override
public String toString() {
return "FilterEntity{" +
"name='" + name + '\'' +
", chooseStr='" + chooseStr + '\'' +
", hasSelected=" + hasSelected +
'}';
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(this.name);
dest.writeString(this.chooseStr);
dest.writeByte(this.hasSelected ? (byte) 1 : (byte) 0);
}
public FilterEntity() {
}
protected FilterEntity(Parcel in) {
this.name = in.readString();
this.chooseStr = in.readString();
this.hasSelected = in.readByte() != 0;
}
public static final Creator CREATOR = new Creator() {
@Override
public FilterEntity createFromParcel(Parcel source) {
return new FilterEntity(source);
}
@Override
public FilterEntity[] newArray(int size) {
return new FilterEntity[size];
}
};
}复制代码
两种序列化的比较
Serializable是java的序列化方式，使用起来简单，但是开销比较大，在序列化和反序列化的时候会进行大量的读写操作。
Pacelable是android独有的，所以在Android平台下肯定是首选啦，它使用起来稍微复杂一点，但是非常高效。
Parcelable主要是将对象序列化到内存中，而Serializable主要是序列化到存储设备和网络通信中。
Binder
Binder是一个很复杂的概念，我们这里主要是谈谈它的上层应用使用方式，Binder是进程之间通信的桥梁，这里给一个远程service
public class BookManagerService extends Service {
private CopyOnWriteArrayList mBookList = new CopyOnWriteArrayList();
// private CopyOnWriteArrayList mListenList = new CopyOnWriteArrayList();
private RemoteCallbackList mListenList = new RemoteCallbackList<>();
@Nullable
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
private Binder mBinder = new IBookManager.Stub() {
@Override
public List getBookList() throws RemoteException {
Log.d("wangchao0000", "getBookList: ");
return mBookList;
}
@Override
public void addBook(Book book) throws RemoteException {
mBookList.add(book);
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
//可以做一些事，比如包验证
return super.onTransact(code, data, reply, flags);
}
};
@Override
public void onCreate() {
super.onCreate();
Log.d("wangchao0000", "onCreate: ");
// mBookList.add(new Book(1, "开发艺术探索"));
// mBookList.add(new Book(2, "Flutter进阶"));
ExecutorService executorService = Executors.newScheduledThreadPool(1);
((ScheduledExecutorService) executorService).scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
Log.d("wangchao0000", "run: ");
int bookId = mBookList.size() + 1;
notifyNewBookArrived(new Book(bookId, "new book--" + bookId));
}
},0, 5, TimeUnit.SECONDS);
}
}
复制代码
Manifest文件如下：
android:process=":remote"
android:enabled="true"
android:exported="true"
/>
复制代码
这样BookManagerService就运行在远程服务了。接下来就看客户端怎么和远程服务端怎么去通信了，我们新建一个AIDL文件，这个接口文件中去声明几个我们需要的方法。
interface IBookManager {
List getBookList();
void addBook(in Book book);
}
复制代码
系统会根据这个AIDL文件自动生成Binder类，这个类就是我们的核心类，利用它客户端和服务端就可以通信了哈，想起来就是兴奋，我们把这个类梳理一下就ok了。先上代码：
/*
* This file is auto-generated. DO NOT MODIFY.
* Original file: /Users/wangchao/code/TestProject/app/src/main/aidl/com/example/wangchao/testproject/IBookManager.aidl
*/
package com.example.wangchao.testproject;
// Declare any non-default types here with import statements
public interface IBookManager extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.example.wangchao.testproject.IBookManager
{
private static final java.lang.String DESCRIPTOR = "com.example.wangchao.testproject.IBookManager";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.example.wangchao.testproject.IBookManager interface,
* generating a proxy if needed.
*/
public static com.example.wangchao.testproject.IBookManager asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.example.wangchao.testproject.IBookManager))) {
return ((com.example.wangchao.testproject.IBookManager)iin);
}
return new com.example.wangchao.testproject.IBookManager.Stub.Proxy(obj);
}
@Override public android.os.IBinder asBinder()
{
return this;
}
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_getBookList:
{
data.enforceInterface(DESCRIPTOR);
java.util.List _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addBook:
{
data.enforceInterface(DESCRIPTOR);
com.example.wangchao.testproject.data.Book _arg0;
if ((0!=data.readInt())) {
_arg0 = com.example.wangchao.testproject.data.Book.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.example.wangchao.testproject.IBookManager
{
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
@Override public android.os.IBinder asBinder()
{
return mRemote;
}
public java.lang.String getInterfaceDescriptor()
{
return DESCRIPTOR;
}
@Override public java.util.List getBookList() throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.example.wangchao.testproject.data.Book.CREATOR);
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override public void addBook(com.example.wangchao.testproject.data.Book book) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((book!=null)) {
_data.writeInt(1);
book.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
public java.util.List getBookList() throws android.os.RemoteException;
public void addBook(com.example.wangchao.testproject.data.Book book) throws android.os.RemoteException;
}
复制代码
咋一眼看到这个代码是不是很头大，是的，我也很头痛，系统自动生成的，不过我们来梳理一下：这个类继承类IInterface，一旦继承了这个接口，系统就认为它是AIDL：
/**
* Base class for Binder interfaces. When defining a new interface,
* you must derive it from IInterface.
*/
public interface IInterface
{
/**
* Retrieve the Binder object associated with this interface.
* You must use this instead of a plain cast, so that proxy objects
* can return the correct result.
*/
public IBinder asBinder();
}
复制代码
没啥啊，里面就是只有asBinder一个方法，该方法就是返回binder对象的。
接下来看看：
public java.util.List getBookList() throws android.os.RemoteException;
public void addBook(com.example.wangchao.testproject.data.Book book) throws android.os.RemoteException;
复制代码
仔细一看，这不就是咱们在AIDL文件中定义的那两个方法嘛，这里对它进行了声明，看来在这个类中肯定是要用到了。然后定义了几个整型变量，用来告诉服务端目前客户端是调用的哪一个方法，不然服务端怎么知道呢。
接着看，重点来了，就是那个stub，这个概念我们并不陌生，它时常在service中出没：
private Binder mBinder = new IBookManager.Stub() {
@Override
public List getBookList() throws RemoteException {
Log.d("wangchao0000", "getBookList: ");
return mBookList;
}
@Override
public void addBook(Book book) throws RemoteException {
mBookList.add(book);
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
//可以做一些事，比如包验证
return super.onTransact(code, data, reply, flags);
}
};
复制代码
是吧，我没说错把。接下来我们就分析分析了。
它是一个内部类，它就是一个Binder类，它实现了IInterface接口。这个类中有几个重要的方法：
asInterface
onTransact
asBinder
Proxy，它是一个内部类
咱们分别来分析他们的实现逻辑：
asInterface
我们先来看看asInterface方法，用来获取服务端对象：
/**
* Cast an IBinder object into an com.example.wangchao.testproject.IBookManager interface,
* generating a proxy if needed.
*/
public static com.example.wangchao.testproject.IBookManager asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.example.wangchao.testproject.IBookManager))) {
return ((com.example.wangchao.testproject.IBookManager)iin);
}
return new com.example.wangchao.testproject.IBookManager.Stub.Proxy(obj);
}
复制代码
它是一个静态方法，调用的地方是在客户端，注释写得很清楚，如果客户端和服务端在同一进程中，直接返回service对象，否则返回Proxy。事实上，既然写这个类，那肯定是不在一个进程了，那么proxy就有用武之地了。
Proxy
Proxy是stub的内部类，它实现了AIDL接口，Proxy对象是返回给客户端的，客户端拿到后去调用里面
的方法：
ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
bookManager = IBookManager.Stub.asInterface(service);
try {
// Log.d("BookMnagerActivity", "query book list: -------" + Arrays.asList(list));
// list.add(new Book(3, "web进阶"));
// Log.d("BookMnagerActivity", "query book list: -------" + Arrays.asList(bookManager.getBookList()));
bookManager.registerListen(onNewBookArriveListen);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
复制代码
这个bookManager就是proxy的对象，这里可以通过断点进去看。
我们选一个方法去分析吧：
private static class Proxy implements com.example.wangchao.testproject.IBookManager
{
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
@Override public android.os.IBinder asBinder()
{
return mRemote;
}
public java.lang.String getInterfaceDescriptor()
{
return DESCRIPTOR;
}
@Override public java.util.List getBookList() throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.example.wangchao.testproject.data.Book.CREATOR);
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}
复制代码
当客户端去调用getBookList方法的时候，它就执行到这里，这里声明了_data, _reply， _result。调用过程如下：
首先把之前定义好的int标识符写到_data里面去，以便服务端去识别。
调用远程服务的transact，这时候客户端进程挂起，直到服务端执行完ontransact方法，返回结果之后才能唤醒。
返回结果后，唤醒，将数据返回给客户端的调用处。
onTransact
前面说了，客户端调用了服务端的transact方法，该方法属于Binder的方法，在Binder线程池中
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
复制代码
接下来看看，服务端干了啥。
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_getBookList:
{
data.enforceInterface(DESCRIPTOR);
java.util.List _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
return super.onTransact(code, data, reply, flags);
}
复制代码
该方法中，它会去根据code去判断调用哪个方法，这个code就是之前声明的那个id，哦，nice，原来这么简单：
根据code去查找需要调用的方法
调用服务端的getBookList
将返回的结果写到reply里面去，然后唤醒客户端
proxy和onTransact不就是两个相互应答的过程嘛。
这里需要说明一下，
客户端发起请求后当前线程就会被挂起，直到服务端进程返回结果，如果远程方法执行很耗时的操作，就会造成ANR，所以发起请求的线程不能是UI线程哈。
Binder方法运行在线程池中，这里要使用线程同步。
其实大家经常说的AIDL，有个啥用，它就是个工具而已，利用这个工具系统可以帮我们生成Binder类，但这个AIDL并不是必须的，我们可以自己去写Binder类。
Android中IPC的几种方式
Bundle
文件共享
Messenger
AIDL
ContentPrider
Bundle
相信大家对这个都不陌生，在Activity，Service使用intent传递数据的时候经常会用到，只要这个对象是已经序列化了的，它就可以放到Bundle里去传输，这不就是ipc了嘛。
文件共享
这个很简单，多个进程或者是应该去读写同一个文件，我们把序列化的对象写进去，另外一个进程从这个文件从去读取，然后再反序列化，就可以很顺利的拿到数据了。
Messenger AIDL
上面将binder的时候已经分析过AIDL了，不懂的大家可以专门去学学AIDL的使用，Messenger就是封装了AIDL而已，没啥好讲的。
ContentPrider
这玩意不就是Android四大组建之一吗，对，就是它，它天然带了IPC属性，比如获取联系人模块里面的数据。
好了，也写了不少了，主要理解原理，至于怎么使用不是这片文章的重点。

总结

序列化和反序列化就是将对象转换为字符序列存储到某个文件，之后就是读写文件获取，方便传输而已。

IPC要抓住那个桥梁，就是Binder，binder里面的方法就是服务端定义的方法，我们作为客户端就是想调用服务端的方法来实现一些功能，如果我们拿到了Binder，还愁不能调用服务端的方法吗，所以。。。。。

不要在UI线程中去bind 服务，因为远程进程在干啥，我们是不知道的

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。