Android IPC机制
Android中多进程模式
如何开启多进程模式
在Android中只有一种方法，那就是在AndroidMenifest文件中给四大组件(Activity,Service,Receiver,ContentProvider)指定android:process属性
- 使用
:的进程是当前应用的私有进程，其他应用组件不能和它跑在同一个进程 - 使用
.是全局进程，其他应用通过ShareUID方式可以和它跑在同一个进程
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity
android:name=".MessengerActivity"
android:launchMode="standard">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<!--使用点，要指定全包名 -->
<activity
android:name=".SecondActivity"
android:process=":rcom.zhc.androidarttravel.remote">
</activity>
<!--使用冒号，默认会补全包名，与上述activity不是同一个进程 -->
<service
android:name=".service.MessengerService"
android:process=":remote" />
<activity android:name=".MainActivity"></activity>
</application>
多进程模式的运行机制
- Android为每一个进程分配了一个独立的虚拟机，具有不同的地址空间，导致每个虚拟机访问同一个类会产生多个副本，也就是说两个虚拟机数据、对象不共享，各用个的（在一个进程中改变了值，在另一个进程中不会改变，是两个单独的空间）
问题：
- 静态成员和单例设计模式完全失效
- 线程同步机制完全失效（不同进程锁的对象不同）
- SharedPreferences的可靠性降低（不支持两个进程同时执行写操作，会导致数据丢失）
- Application会多次创建（不同进程是不同的虚拟机，就是需要重新启动应用，所以创建新的Application）
IPC基础介绍
Serializable与Parcelable
区别：
- Serializable是Java中的序列化接口，使用简单但是开销大，因为序列化和反序列化是需要大量的I/O操作
- Parcelable是Android中的序列化方式，高效但稍显麻烦，首选Parcelable
- 但是在序列化存储到设备中或将对象序列化后通过网络传输还是用Serializable，更方便
Serializable接口
只需要在类中声明一个serialVersionUID，也可以不需要指定UID，这个UID是在反序列化的时候判断一下是否是相同的UID对象，相同才可以反序列化
这种方式要避免并发读写，内容可能不是最新，
-
该方式适合对数据同步要求不高的进程之间通信
//值随便取，唯一即可
private static final long serialVersionUID = 2313186133168643352l;
序列化过程，采用ObjectOutputStream和ObjectInputStream，例如下：
//序列化
try {
User user = new User("zhc",007,true);
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("cache.txt"));
out.writeObject(user);
out.close();
} catch (IOException e) {
e.printStackTrace();
}
//反序列化
try {
ObjectInputStream in = new ObjectInputStream(
new FileInputStream("cache.txt"));
User newUser = (User) in.readObject();
in.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
反序列化后的对象内容和之前的一样，但是是两个不同的对象
Parcelable
先定义好变量和构造方法再实现接口
public class UserP implements Parcelable {
private String userName;
private int userID;
private boolean isMale;
public UserP(String userName, int userID, boolean isMale) {
this.userName = userName;
this.userID = userID;
this.isMale = isMale;
}
protected UserP(Parcel in) {
userName = in.readString();
userID = in.readInt();
isMale = in.readByte() != 0;
}
//反序列化，配合以上方法
public static final Creator<UserP> CREATOR = new Creator<UserP>() {
@Override
public UserP createFromParcel(Parcel in) {
return new UserP(in);
}
@Override
public UserP[] newArray(int size) {
return new UserP[size];
}
};
@Override
public int describeContents() {
return 0;
}
//序列化
@Override
public void writeToParcel(Parcel parcel, int i) {
parcel.writeString(userName);
parcel.writeInt(userID);
parcel.writeByte((byte) (isMale ? 1 : 0));
}
}
Android中的IPC方式
使用Bundle
四大组件中的三大组件都可以用Bundle来传递数据，对象序列化之后也可以放入Bundle来传递，基本数据类型和String都是实现了序列化的。
使用文件共享
由于Android是基于Linux的，使得其并发读/写文件可以没有限制的进行，写序列化文件到SD卡中存储，另一个进程读取
//序列化
public void persistToFile() {
new Thread(new Runnable() {
@Override
public void run() {
User user = new User("zhc",007,true);
File dir = new File(MyConstants.CHAPTER_2_PATH);
if (dir != null){
dir.mkdirs();
}
ObjectOutputStream outputStream = null;
File cacheFile = new File(MyConstants.CACHE_FILE_PATH);
try {
outputStream =
new ObjectOutputStream(new FileOutputStream(cacheFile));
outputStream.writeObject(user);
Log.d("user","persist File : " + user);
} catch (IOException e) {
e.printStackTrace();
}finally {
MyUtils.close(outputStream);
}
}
}).start();
}
//反序列化
public void recoverFromFile() {
new Thread(new Runnable() {
@Override
public void run() {
User newUser = null;
ObjectInputStream objectInputStream = null;
File cacheFile = new File(MyConstants.CACHE_FILE_PATH);
if (cacheFile.exists()) {
try {
objectInputStream = new ObjectInputStream(
new FileInputStream(cacheFile));
newUser = (User) objectInputStream.readObject();
Log.d("user", "recover from File : " + newUser);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
MyUtils.close(objectInputStream);
}
}
}
}).start();
}
使用Messenger
Messenger是信使，他可以在不同进程中传递message对象，底层实现是AIDL，对AIDL进行了封装。它一次只处理一个请求，因此在服务端不用考虑线程同步的问题。
