Android IPC机制

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为每一个进程分配了一个独立的虚拟机，具有不同的地址空间，导致每个虚拟机访问同一个类会产生多个副本，也就是说两个虚拟机数据、对象不共享，各用个的（在一个进程中改变了值，在另一个进程中不会改变，是两个单独的空间）

问题：
1. 静态成员和单例设计模式完全失效
2. 线程同步机制完全失效（不同进程锁的对象不同）
3. SharedPreferences的可靠性降低（不支持两个进程同时执行写操作，会导致数据丢失）
4. 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进行了封装。它一次只处理一个请求，因此在服务端不用考虑线程同步的问题。