简介

Inter-Process Communication的缩写，含义是进程间通信或者跨进程通信，是指两个进程之间进行数据交换的过程。

通信方式

Bundle，文件共享，AIDL，Messenger，ContentProvider和Socket等等通信方式，后面我们会一一介绍到。

使用场景

  第一种：由于应用本身需要多进程模式来实现（某个模块需要运行在单独进程中，使用多进程来获取多份内存空间）
  第二种：需要向其他应用获取数据

开启多进程模式

开启多进程的只有一种方法，那就是给四大组件在AndroidMenifest文件中指定android:process的属性，当然也可以通过JNI在native层去fork一个新的进程，这种情况特殊，暂不做考虑。
如下，我们有三个界面，分别是从第一个页面跳转到第二个页面，然后再从第二个页面跳转到第三个页面，并给指定android:process的属性；

 <activity
        android:name=".MainActivity"
        android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity
            android:name=".SecondActivity"
            android:configChanges="screenLayout"
            android:process="com.example.testipc2.remote"
           />

        <activity
            android:name=".ThirdActivity"
            android:configChanges="screenLayout"
            android:process=":remote" />

当跳转到第三个界面时候，我们会发现如下：

QQ截图20160912150240.png

可以看到又分别创建了两个新的进程，进程id分别是8526,8549,8572，需要注意的是SecondActivity和ThirdActivity指定android:process的方式并不一样，前者命名是com.example.testipc2.remote，进程名是com.example.testipc2.remote；后者命名是:remote，而进程名是com.example.testipc:remote,此处需要说明的是项目包名是com.example.testipc。可以看的出来ThirdActivity命名时候如果是以":"开头，它的含义就是当前的进程名前面附加上当前的包名，它属于当前应用的私有进程，其他的应用组件不可以和它在一个进程中，SecondActivity的写法是一种完整的写法，不会附加包名信息，它属于全局进程，其他应用可以通过ShareUID的方式和它运行在一个进程之中（两个应用的ShareUID和签名必须相同）。

多进程模式的运行机制

通过了解如何开启一个新进程之后，可能会觉得很简单，但事实并非如此，虽然指定一个android:process的属性很简单，但它也会随之带来一系列的问题：

（1）静态成员和单例模式完全失效
（2）线程同步机制完全失效
（3）Shareprefrences的可靠性下降
（4）Application会被多次创建

可以做一个很简单的实验，就拿刚刚的例子来讲，比如说你声明一个公共的静态变量：

public class UserManager {
    public static int sUserId=1;
}

在MainActivity赋值为2，然后在SecondActivity中去打印sUserId，你会发现sUserId依然是“1”，理论上讲静态变量是共享的，且一个地方修改之后也会同步，但实际情况并非如此。出现上述情况的原因是什么呢？上面SecondActivity是在一个单独的进程中的，我们知道Android为每个应用分配了一个独立的虚拟机，或者说为每个进程都分配了一个独立的虚拟机，不同的虚拟机在内存上有不同的地址空间，这就导致不同的虚拟机在访问同一个类的对象时候会产生多份副本。回到上面的例子，也就是两个进程中都会有个 UserManager，在MainActivity中修改的值不会影响com.example.testipc2.remote进程中的SecondActivity。

当然多进程带来的问题也不是不可以解决的，为了解决这个问题，系统提供了很多跨进程的方法，虽然不可以直接共享内存，当可以通过跨进程通信并可以进行数据交换，跨进程的方式也有很多，后期我们一一了解，我们先来了解序列化和Binder，因为这两者是一个基础。

序列化的方式有Serializable和Parcelable，都可以完成对象序列化的过程当我们需要通过Intent和Binder传输数据时候就会用到Serializable或者Parcelable。我们先来看看Serializable；

Serializable实例

Serializable它是一个java提供的序列化接口，是一个空接口，为序列化提供标准的序列化和反序列化操作;实现如下：

import java.io.Serializable;

public class SUser implements Serializable{
      private static final long serialVersionUID=4545125745456545L;
      public int userId;
      public String userName;
      public boolean isMale;
      ..................
}

//序列化

 SUser suser=new SUser();
        suser.isMale=true;
        suser.userId=101;
        suser.userName="jack";
        try {
            String str=Environment.getExternalStorageDirectory()+"/cache.txt";
            File file=new File(str);
            ObjectOutputStream outputStream=new ObjectOutputStream(new FileOutputStream(file));
            outputStream.writeObject(suser);
            outputStream.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

//反序列化

      try {
                    String str=Environment.getExternalStorageDirectory()+"/cache.txt";
                    File file=new File(str);
                    ObjectInputStream in=new ObjectInputStream(new FileInputStream(file));
                    SUser newsuers=(SUser) in.readObject();
                    Log.e("TAG", newsuers.userName+"="+newsuers.userId+"="+newsuers.isMale);
                    in.close();
                } catch (StreamCorruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }catch (ClassNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

可以看到在反序列化时候打印了反序列化的结果：

QQ截图20160912174502.png

可以看到恢复之后的对象内容完全一样，但两者并不是同一个对象。Java中ObjectInputStream 与 ObjectOutputStream这两个包装类可用于输入流中读取对象类数据和将对象类型的数据写入到底层输入流
。ObjectInputStream 与 ObjectOutputStream 类所读写的对象必须实现了 Serializable 接口。

注意：

1.static关键字，拥有static关键字的属性不会自动序列化，除非你writeInt,writeString等将其写出 
2.transient关键字，修饰的字段属性不会被序列化，此关键字只对属性有效
3.serialVersionUID关键字，将class与serialVersionUID相联系，用于在反序列化的时候验证序列化时使用的类和加载时是否使用的是一个类，否则抛出InvalidClassException

在SUser 类中我们还定义了一个serialVersionUID，它有什么用呢？其实它是辅助序列化和反序列化的，原则上序列化之后的serialVersionUID和当前类的serialVersionUID相同才可以正常的序列化，它的详细工作机制是：序列化的时候会将当前类的serialVersionUID写入序列化文件中；反序列化时候会去检测文件中的serialVersionUID，看它是否和当前类的serialVersionUID一致，如果一致说明序列化的类和当前类的版本是一致的，可以序列化成功；否则失败，说明成员变量的数量或者类型发生了改变。

Parcelable实例

它也是一个接口，实现这个接口，就可以实现序列化并可以通过Intent和Binder传递。
实现如下：
User.java

public class User implements Parcelable{
    public int userId;
    public String userName;
    public boolean isMale;

    public Book book;

    public User(int userId,String userName,boolean isMale)
    {
        this.userId=userId;
        this.userName=userName;
        this.isMale=isMale;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeInt(userId);
        parcel.writeString(userName);
        parcel.writeByte((byte) (isMale ? 1 : 0));
        parcel.writeParcelable(book,0);
    }

    protected User(Parcel in) {
        userId = in.readInt();
        userName = in.readString();
        isMale = in.readByte() != 0;
        book=in.readParcelable(Thread.currentThread().getContextClassLoader());
    }

    public static final Creator<User> CREATOR = new Creator<User>() {
        @Override
        public User createFromParcel(Parcel in) {
            return new User(in);
        }

        @Override
        public User[] newArray(int size) {
            return new User[size];
        }
    };

}

Book.java

public class Book implements Parcelable{
    public int bookId;
    public String bookName;

    public Book(int bookId,String bookName)
    {
        this.bookId=bookId;
        this.bookName=bookName;
    }

    @Override
    public int describeContents() {
        return 0;
    }


    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeInt(bookId);
        parcel.writeString(bookName);
    }


    protected Book(Parcel in) {
        bookId=in.readInt();
        bookName=in.readString();
    }

    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };

}

Parcelable接口特点：

Parcelable接口会实现3个函数，和一个CREATOR（假定定义类ParcelableClass实现了Parcelable接口）
   1. protected ParcelableClass(Parcel in) ：将数据从parcel读入到对象中

   2. public static final Creator CREATOR:构造器，两个方法，一个创建一个对象，另一个创建一个对象数组 

   3. public int describeContents()：描述Parcelable实例的排列形式，一般会返回0 

   4. public void writeToParcel(Parcel dest, int flags)：将数据写入parcel对象，以什么样的顺序写入就会以什么样的顺序读出。

至于Parcelable如何使用这里就不多说了，我们来比较一下Serializable和Parcelable；
Serializable

java序列化接口 使用简单,开销很大，序列化和反序列化都需要大量的I/O操作。另一个原因是使用了反射机制，从而引起频繁的GC，而相比之下Parcelable的
性能更高

Parcelable

Android平台推荐使用，但使用较复杂，效率高。所以在内存之间进行数据传递的时候候建议首选Parcelable。

注意：在将对象序列化到存储设备或者将对象序列化通过网络传输这两种情况下，建议选择Serializable。

以上就为IPC机制基础的一部分，至于Binder放到下一章节，相对来说它也是一个深入的话题。