Linux 和 Android 中的 IPC 机制

IPC全称 Inter-Process Communication，进程间通信，是指两个进程之间进行数据交换的过程。Android 和Linux 中都有各自的 IPC 机制。

1 Linux 中的 IPC 机制

Linux 中提供了很多进程间通信机制，主要有管道（Pipe）、信号（Single）、信号量（Semophore）、消息队列（Message）、共享内存（Share Memory）和套接字（Socket）等。

1.1 管道

管道是 Linux 由 UNIX 继承过来的进程间通信机制，它是 UNIX 早期的一个重要通信机制。管道的主要思想是在内存中创建一个共享文件，从而使通信双方利用这个共享文件来传递信息。另外，管道采用半双工通信方式，数据只能在一个方向上流动。

数据在线路上的传送方式可以分为单工通信、半双工通信和全双工通信三种。

• 单工通信：是指消息只能单方向传输，比如遥控。单工通信的发送端和接收端的身份是固定的，发送端只能发送消息，不能接收消息；接收端只能接收消息，不能发送消息
• 半双工通信（双向交替通信）：是指数据可以沿两个方向传送，但不能双方同时发送或接收。 半双工通信方式要求两端都有发送装置和接收装置，由于这种方式要频繁的变换信道方向，效率较低，但是可以节约传输线路。
• 全双工通信（双向同时通信）：通信的双方可以同时发送和接收信息的交互方式。通信系统的每一端都有发送器和接收器。

管道的简单模型如下图所示：

进程 1 和 程序 2 分立在管道两侧，进行数据传输。由于管道采用半双工通行方式，进程 1 和进程 2 都有发送装置和接收装置，但不能同时发送或接收数据，如果要同时进行，需要建立两条管道。

管道也是有容量限制的，当管道满时，发送（write）将阻塞；管道空时，接收（read）将阻塞。

1.2 信号

信号是软件层次上对中断机制的一种模拟，是一种异步通信方式。 进程不知道信号什么时候到达，也就不必通过任何操作来等待信号。信号可以在用户空间和内核之间直接交互，内核可以利用信号来通知用户空间的发生了哪些系统事件。信号不适用于信息交换，比较适合于进程中断控制。

1.3 信号量

信号量是一个计数器，用来控制多个进程对共享资源的访问。信号量常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。信号量主要作为进程间及同一进程内不同线程之间的同步手段。

信号量包括以下几个元素：

• Semaphore S ——信号量，指示共享资源的可用数量；
• Operation P ——荷兰语 proberen，减小 S 的计数；
• Operation V ——荷兰语 verhogen，增加 S 的计数；

当某个进程想要进入共享区时，首先执行 P 操作；同理要想退出共享区时执行 V 操作。P/V 操作都属于原子操作（Atomic Operations），意味着它们的执行过程是不允许被中断的。

V 操作的执行过程：

• 信号量自增 1；
• 如果此时 S > 0，说明当前没有希望访问资源的等待者，所以直接返回；
• 如果此时 S <= 0，说明要唤醒等待队列中的相关进程，对应P操作中的“被唤醒”；

P 操作的执行过程：

• 信号量自减 1;
• 如果此时 S >= 0，说明共享资源此时是允许被访问的，此时，调用者会直接返回，然后对共享资源进行相关操作；
• 如果此时 S < 0，说明共享资源此时不允许被访问，需要等待其他进程释放资源，这种情况下调用者会被加入等待队列中，直到被唤醒；
• 当某个进程释放了共享资源后，等待队列中的相关进程就会被唤醒，此时，被唤醒的进程就具备了资源的访问权；

1.4 消息队列

消息队列是消息的链表，具有特定的格式，消息队列存放在内存中由消息队列标识符进行标识，并且允许一个或多个进程向它写入和读取消息。使用消息队列会使信息复制两次，因此对于频繁通信或者信息量大的通信不宜使用消息队列。

1.5 共享内存

共享内存的多个进程可以直接读写一块内存空间，减少数据的复制，是最快的 IPC 方式，针对其他通信机制运行效率较低而设计的。 为了在多个进程间交换信息，内核专门留出了一块内存区域，可以由需要访问的进程将其映射到自己的私有地址空间。这样，进程就可以直接读写着块内存而不需要进行数据的复制，从而大幅度提高效率。它往往和其他通信机制，比如信号量结合使用，来达到进程间同步或互斥。

1.6 套接字（socket）

套接字是更基础的进程间通信机制，与其他通信机制不同的是，套接字可以用于不同的机器之间的进程间通信。

2. Android 中的 IPC 机制

Android 系统是基于 Linux 内核的，在 Linux 内核基础上又扩展出了一些 IPC 机制。Android 系统除了支持套接字，还支持序列化、Messenger、AIDL、Bundle、文件共享、ContentProvider 和 Binder 等。

2.1 序列化

序列化指的是 Serializable/Parcelable 接口，Serializable 接口是 Java 提供的一个序列化接口，是一个空接口，为对象提供标准的序列化和反序列化操作。Parcelable 接口是 Android 中的序列化方式，更适合在 Android 平台上使用。虽然 Parcelable 接口用来来比较麻烦，但是其效率很高。

2.2 Messenger

Messenger 在 Android 应用开发中的使用频率不高，可以在不同进程中传递 Message 对象，在 Message 中加入想要传递的数据就可以在进程间进行数据传递了。Messager 是一种轻量级的 IPC 方案，并对 AIDL 进行封装。

首先写服务端（MessengerService.java），在 onBind 方法中创建 Messenger，关联接受消息的 Handler 调用 getBinder 来获取 Binder 对象，在 handleMessage 方法中接收客户端发来的信息：

public class MessengerService extends Service {

    public static final String TAG = "MoonMessenger";
    public static final int MSG_FROMCLIENT = 1000;

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MSG_FROMCLIENT:
                    System.out.println("收到客户端消息 -- " + msg.getData().get("msg"));
                    break;
            }
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new Messenger(mHandler).getBinder();
    }
}

需要注意的是注册服务时要另开启一个进程：

<service
    android:name=".messenger.MessengerService"
    android:process=":remote" />

接下来创建客户端（MessengerService），绑定另一个进程服务，绑定成功后根据服务端返回的 Binder 对象创建 Messenger，并用 Messenger 向服务端发送信息。

public class MessengerService extends Service {

    public static final String TAG = "MoonMessenger";
    public static final int MSG_FROMCLIENT = 1000;

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MSG_FROMCLIENT:
                    System.out.println("收到客户端消息 -- " + msg.getData().get("msg"));
                    break;
            }
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new Messenger(mHandler).getBinder();
    }
}

运行程序后得到的 log 信息如下所示：

// System.out: 收到客户端消息 -- 这里是客户端，服务端收到了吗

服务端收到了客户端的信息，但是服务端现在无法回应客户端。下面实现服务端回应客户端，客户端也能收到服务端的回应。

首先修改服务端，在 handleMessage 回调中收到客户端信息时，调用 Message.replyTo 得到客户端传递过来的 Messenger 对象，创建消息并通过 Messenger 发送给客户端。

// MessengerService
private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(@NonNull Message msg) {
        switch (msg.what) {
            case MSG_FROMCLIENT:
                System.out.println("收到客户端消息 -- " + msg.getData().get("msg"));
                // 得到客户端传来的 Messenger 对象
                Messenger messenger = (Messenger) msg.replyTo;
                Message message = Message.obtain(null, MessengerService.MSG_FROMCLIENT);
                Bundle bundle = new Bundle();
                bundle.putString("rep", "这里是服务端，我们收到消息了");
                message.setData(bundle);
                try {
                    messenger.send(message);
                } catch (RemoteException e) {
                    throw new RuntimeException(e);
                }
                break;
        }
    }
};

然后修改客户端，客户端需要创建一个 Handler 来接收服务端的信息，如下所示：

private Handler handler = new Handler() {
    @Override
    public void handleMessage(@NonNull Message msg) {
        switch (msg.what) {
            case MessengerService.MSG_FROMCLIENT:
                System.out.println("收到服务端消息 -- " + msg.getData().get("rep"));
                break;
        }
    }
};

在服务端调用 Message.replyTo 得到客户端传递过来的 Messenger 对象，可是客户端并没有传递 Messenger 对象，现在加上这段代码将 Messenger 对象传递给服务端，需要关联定义的 Handler：

private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        messenger = new Messenger(service);
        Message message = Message.obtain(null, MessengerService.MSG_FROMCLIENT);
        Bundle bundle = new Bundle();
        bundle.putString("msg", "这里是客户端，服务端收到了吗");
        message.setData(bundle);
        message.replyTo = new Messenger(handler);
        try {
            messenger.send(message);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {

    }
};

最后运行代码查看 log：

// System.out: 收到客户端消息 -- 这里是客户端，服务端收到了吗
// System.out: 收到服务端消息 -- 这里是服务端，我们收到消息了

2.3 AIDL

AIDL 全称为 Android Interface Definition Language，即 Andorid 接口定义语言。 Messenger 是以串行的方式来处理客户端发来的信息的，如果有大量的消息发送到服务端，那么服务端仍然逐个处理再响应客户端显然是不合适的。虽然 Messenger 可以用于进程间数据传递，但是却不能满足跨进程的方法调用，这个时候就需要使用 AIDL 了。

2.3.1 创建 AIDL 文件

将项目结构调整为 Android 模式，在 java 同级目标下创建 aidl 文件夹，在文件夹中创建一个包，其包名和应用包名一致，如下所示：

先创建一个 IGameManager.aidl 的文件，这里面有两个方法，分别是 addGame 方法和 getGameList 方法，代码如下所示：

// IGameManager.aidl
package com.example.myapplication;
import com.example.cah.myapplication.Game;

interface IGameManager{
    List<Game> getGameList();
    void addGame(in Game game);
}

在 AIDL 文件中支持的数据类型如下：

• 基本数据类型；
• String 和 CharSequence；
• List：只支持 ArrayList，里面的元素都必须被 AIDL 支持；
• Map：只支持 HashMap，里面的元素都必须被 AIDL 支持；
• 实现 Parcelable 接口的对象；
• 所有 AIDL 接口；

在 IGameManager.aidl 中用到了 Game 类，这个类实现了 Parcelable 接口，在 AIDL 文件中需要 import 来查看 Game 类：

// Game.java
public class Game implements Parcelable {

    public String gameName;
    public String gameDescribe;

    public Game(String gameName, String gameDescribe) {
        this.gameName = gameName;
        this.gameDescribe = gameDescribe;
    }

    protected Game(Parcel in) {
        gameName = in.readString();
        gameDescribe = in.readString();
    }

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

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

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

    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        dest.writeString(gameName);
        dest.writeString(gameDescribe);
    }
}

在 IGameManager.aidl 文件中使用了 Game 类，所以要创建 Game.aidl 来申明 Game 类实现了 Parcelable 接口：

package com.example.myapplication;
parcelable Game;

重新编译程序，工程会自动生成 IGameManager.aidl 对应的接口文件，文件目录如下：

2.3.2 创建服务端

在服务端 onCreate 方法中创建了两个游戏的信息，并创建了 Binder 对象实现了 AIDL 的接口文件中的方法，在 onBind 方法中将 Binder 对象返回。

public class AIDLService extends Service {

    private CopyOnWriteArrayList<Game> mGameList = new CopyOnWriteArrayList<>();

    private Binder mBinder = new IGameManager.Stub() {
        @Override
        public List<Game> getGameList() throws RemoteException {
            return mGameList;
        }

        @Override
        public void addGame(Game game) throws RemoteException {
            mGameList.add(game);
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
        mGameList.add(new Game("天龙八部", "武侠小说"));
        mGameList.add(new Game("雍正王朝", "权谋小说"));
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
}

这个服务运行在另一个进程，在 AndroidManifes.xml 文件中进行配置：

<service
    android:name=".AIDLService"
    android:process=":remote" />

2.3.3 客户端调用

最后在客户端 onCreate 方法中调用 bindService 方法绑定远程服务，绑定成功后将返回的 Binder 对象转换为 AIDL 接口，这样就可以通过这个接口来调用远程服务端的方法了：

public class AIDLActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_aidl);

        Intent intent = new Intent(AIDLActivity.this, AIDLService.class);
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
    }

    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            IGameManager iGameManager = IGameManager.Stub.asInterface(service);
            Game game = new Game("仙剑奇侠转", "仙侠剧");
            try {
                iGameManager.addGame(game);
                List<Game> mList = iGameManager.getGameList();
                for (int i = 0; i < mList.size(); i++) {
                    Game g = mList.get(i);
                    System.out.println(g.gameName + " ========== " + g.gameDescribe);
                }
            } catch (RemoteException e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(serviceConnection);
    }
}

绑定成功后，创建一个新的 Game 类调用远程服务的 addGame 方法将游戏添加进去，然后调用循环将远端服务中的所有 Game 都打印出来：

// I/System.out: 天龙八部 ========== 武侠小说
// I/System.out: 雍正王朝 ========== 权谋小说
// I/System.out: 仙剑奇侠转 ========== 仙侠剧

打印出了远程服务端的所有游戏，这样就成功的在客户端通过 AIDL 来调用远程服务的端的方法了。

2.4 Bundle

Bundle 实现了 Parcelable 接口，所以它可以在不同的进程间传输。Activity、Service、Receiver 都是在 Intent 中通过 Bundle 来进行数据传递的。

2.5 文件共享

两个进程通过读写同一个文件来进行数据共享，共享的文件可以是文本、XML、JSON。文件共享适用于对数据同步要求不高的进程间通信。

2.6 ContentProvider

ContentProvider 为存储和获取数据提供统一的接口，它可以在不同的应用程序之间共享数据。ContentProvider 本身就是适合进程间通信的。ContentProvider 底层实现也是 Binder，但是使用起来比 AIDL 要容易许多。系统中很多操作都采用了 ContentProvider，例如通讯录、音视频等，这些操作本身就是跨进程进行通信的。

跨进程共享数据——ContentProvider

2.7 Socket

Socket 是位于应用层和传输层之间的一个抽象层，把 TCP/IP 层复杂的操作抽象为几个简单的接口，供应用层调用以实现进程在网络中通信。

Socket 分为流式套接字和数据包套接字，分别对应网络传输控制层的 TCP 协议和 UDP 协议：

• TCP 协议是一种面向连接的、可靠的、基于字节流的传输层通信协议，它使用三次握手协议建立连接，并且提供了超时重传机制，具有很高的稳定性。
• UDP 协议则是一种无连接的协议，且不对传送数据包进行可靠性保证，适合一次传输少量数据，UDP 的可靠性由应用层负责。在网络质量令人不满的环境下，UDP 协议数据包丢失会比较严重。但是由于 UDP 协议的特性：它不属于连接型协议，因而具有资源损耗小，处理速度快的优点，所以通常音频、视频和普通数据在传送时使用 UDP 协议较多。

以下通过 Socket 实现跨进程聊天程序。

2.7.1 配置

在使用 Sokcet 之前，首先需要在 AndroidManifest.xml 文件中声明如下权限：

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

需要实现一个远程的服务来当作聊天程序的服务端，在 AndroidManifest.xml 文件冲配置 service：

<service
    android:name=".socket.SocketServerService"
    android:process=":remote" />

2.7.2 实现 Service

在 Service 启动时，在线程中创建 TCP 服务，监听 8688 端口，等待客户端连接，当客户端连接时就会生成 Socket。通过每次创建的 Socket 就可以和不同的客户端通信了。当客户端断开连接时，服务端也会关闭 Socket 并结束通话线程。服务端首先会向客户端发送一条消息：“您好，我是服务端”，并接收客户端发来的消息，将收到的消息进行加工再返回给客户端。

public class SocketServerService extends Service {

    private boolean isServiceDestroyed = false;

    @Override
    public void onCreate() {
        new Thread(new TCPService()).start();
        super.onCreate();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    @Override
    public void onDestroy() {
        isServiceDestroyed = true;
        super.onDestroy();
    }

    private class TCPService implements Runnable {

        @Override
        public void run() {
            ServerSocket serverSocket;
            try {
                serverSocket = new ServerSocket(8688);
            } catch (IOException e) {
                return;
            }
            while (!isServiceDestroyed) {
                try {
                    // 接受客户端请求，并且阻塞直到接收到消息
                    final Socket client = serverSocket.accept();
                    new Thread() {
                        @Override
                        public void run() {
                            try {
                                responseClient(client);
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }.start();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }

            }


        }
    }

    private void responseClient(Socket client) throws IOException {
        // 用于接收客户端消息
        BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
        // 用于向客户端发送消息
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())), true);
        out.println("您好，我是服务端");
        while (!isServiceDestroyed) {
            String str = in.readLine();
            System.out.println("收到客户端发来的信息：" + str);
            if (TextUtils.isEmpty(str)) {
                // 客户端断开了连接
                System.out.println("客户端断开连接");
                break;
            }
            String message = "收到客户端的信息为：" + str;
            // 从客户端收到的消息加工再发送给客户端
            out.println(message);
        }
        out.close();
        in.close();
        client.close();
    }
}

2.7.3 实现聊天程序客户端

客户端 Activity 会在 onCreate 方法中启动服务端，并开启线程链接服务器 Socket。为了确保服务端 Socket 能连接成功，采用了超时重连的策略，每次连接失败时都会重新建立连接。连接成功后，客户端会收到服务端发送的消息：“您好，我是服务端”，也可以用 EditText 输入字符并发送到服务端。

public class SocketClientActivity extends AppCompatActivity {

    private TextView message;
    private EditText sender;
    private Button sendBtn;

    private Socket mClientSocket;
    private PrintWriter mPrintWriter;


    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_socket);

        initView();

        Intent service = new Intent(this, SocketServerService.class);
        startService(service);

        new Thread() {
            @Override
            public void run() {
                connectSocketServer();
            }
        }.start();
    }

    private void initView() {
        message = (TextView) findViewById(R.id.message);
        sender = (EditText) findViewById(R.id.sender);
        sendBtn = (Button) findViewById(R.id.send);
        sendBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                final String msg = sender.getText().toString();
                // 向服务器端发送信息
                if (!TextUtils.isEmpty(msg) && mPrintWriter != null) {
                    new Thread() {
                        @Override
                        public void run() {
                            mPrintWriter.println(msg);
                        }
                    }.start();
                    message.setText(message.getText() + "\n" + "客户端：" + msg);
                    sender.setText("");
                }
            }
        });
    }

    private void connectSocketServer() {
        Socket socket = null;
        while (socket == null) {
            try {
                // 选择和服务器相同的端口 8688
                socket = new Socket("localhost", 8688);
                mClientSocket = socket;
                mPrintWriter = new PrintWriter(
                        new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
            } catch (IOException e) {
                SystemClock.sleep(1000);
            }
        }

        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while (!isFinishing()) {
                final String msg = br.readLine();
                if (msg != null) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            message.setText(message.getText() + "\n" + "服务端：" + msg);
                        }
                    });
                }
            }

            mPrintWriter.close();
            br.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}

页面布局如下所示

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    
    <TextView
        android:id="@+id/message"
        android:layout_width="wrap_content"
        android:layout_height="400dp" />

    <androidx.appcompat.widget.LinearLayoutCompat
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:layout_alignParentBottom="true"
        android:orientation="horizontal">

        <EditText
            android:id="@+id/receiver"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="2" />

        <Button
            android:id="@+id/send"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:text="发送" />


    </androidx.appcompat.widget.LinearLayoutCompat>

</RelativeLayout>

2.7.4 运行聊天程序

运行程序，查看进程信息：

客户端首先会收到服务端的信息：“您好，我是服务端”，接下来客户端向服务端发送“您好，我是橙子”，这时候服务端收到了这条信息并将该信息加工后返回客户端：

参考

https://www.linuxprobe.com/linux-process-method.html