在 Linux 系统中，一切都看成文件，当进程打开现有文件时，会返回一个文件描述符。
文件描述符是操作系统为了管理已经被进程打开的文件所创建的索引，用来指向被打开的文件。
当我们的进程启动之后，操作系统会给每一个进程分配一个 PCB 控制块，PCB 中会有一个文件描述符表，存放当前进程所有的文件描述符，即当前进程打开的所有文件。

? 进程中的文件描述符是如何和系统文件对应起来的？
在内核中，系统会维护另外两种表

  • 打开文件表(Open file table)
  • i-node 表(i-node table)

文件描述符就是数组的下标，从0开始往上递增，0/1/2 默认是我们的输入/输出/错误流的文件描述符
在 PCB 中维护的文件描述表中，可以根据文件描述符找到对应了文件指针，找到对应的打开文件表
打开文件表中维护了：文件偏移量(读写文件的时候会更新)；对于文件的状态标识；指向 i-node 表的指针
想要真正的操作文件，还得靠 i-node 表，能够获取到真实文件的相关信息

他们之间的关系

image

图解

  • 在进程 A 中，文件描述符1/20均指向了同一打开文件表项23，这可能是对同一文件多次调用了 open 函数形成的
  • 进程 A/B 的文件描述符2都指向同一文件，这可能是调用了 fork 创建子进程，A/B 是父子关系进程
  • 进程 A 的文件描述符0和进程 B 的文件描述符指向了不同的打开文件表项，但这些表项指向了同一个文件，这可能是 A/B 进程分别对同一文件发起了 open 调用

总结

  • 同一进程的不同文件描述符可以指向同一个文件
  • 不同进程可以拥有相同的文件描述符
  • 不同进程的同一文件描述符可以指向不同的文件
  • 不同进程的不同文件描述符可以指向同一个文件

每次读写进程的时候，都是从文件描述符下手，找到对应的打开文件表项，再找到对应的 i-node 表

?如何实现文件描述符重定向？
因为在文件描述符表中，能够找到对应的文件指针，如果我们改变了文件指针，是不是后续的两个表内容就发生了改变
例如：文件描述符1指向的显示器，那么将文件描述符1指向 log.txt 文件，那么文件描述符 1 也就和 log.txt 对应起来了

是输出重定向符号，< 是输入重定向符号，它们是文件描述符操作符
和 < 通过修改文件描述符改变了文件指针的指向，来能够实现重定向的功能

我们使用cat hello.txt时，默认会将结果输出到显示器上，使用 > 来重定向。cat hello.txt 1 > log.txt 以输出的方式打开文件 log.txt，并绑定到文件描述符1上

image

dup 函数是用来打开一个新的文件描述符，指向和 oldfd 同一个文件，共享文件偏移量和文件状态，

  1. int main(int argc, char const *argv[])
  2. {
  3.     int fd = open("log.txt");
  4.     int copyFd = dup(fd);
  5.     //将fd阅读文件置于文件末尾，计算偏移量。
  6.     cout << "fd = " << fd << " 偏移量： " << lseek(fd, 0, SEEK_END) << endl;
  7.     //现在我们计算copyFd的偏移量
  8.     cout << "copyFd = " << copyFd << "偏移量：" << lseek(copyFd, 0, SEEK_CUR) << endl;
  9.     return 0;
  10. }

image

调用 dup(3) 的时候，会打开新的最小描述符，也就是4，这个4指向了3所指向的文件，操作任意一个 fd 都是修改的一个文件

dup2 函数，把指定的 newfd 也指向 oldfd 指向的文件。执行完dup2之后，newfd 和 oldfd 同时指向同一个文件，共享文件偏移量和文件状态

  1. int main(int argc, char const *argv[])
  2. {
  3.     int oldfd = open("log.txt");
  4.     int newfd = open("log1.txt");
  5.     dup2(oldfd, newfd);
  6.     //将fd阅读文件置于文件末尾，计算偏移量。
  7.     cout << "fd = " << fd << " 偏移量： " << lseek(fd, 0, SEEK_END) << endl;
  8.     //现在我们计算copyFd的偏移量
  9.     cout << "copyFd = " << copyFd << "偏移量：" << lseek(copyFd, 0, SEEK_CUR) << endl;
  10.     return 0;
  11. }

image

Node 中的 IPC 通道具体实现是由 libuv 提供的。根据系统的不同实现方式不同，window 下采用命名管道实现，*nix 下采用 Domain Socket 实现。在应用层只体现为 message 事件和 send 方法。

image

父进程在实际创建子进程之前，会创建 IPC 通道并监听它，等到创建出真实的子进程后，通过环境变量(NODE_CHANNEL_FD)告诉子进程该 IPC 通道的文件描述符。

子进程在启动的过程中，会根据该文件描述符去连接 IPC 通道，从而完成父子进程的连接。

建立连接之后可以自由的通信了，IPC 通道是使用命名管道或者 Domain Socket 创建的，属于双向通信。并且它是在系统内核中完成的进程通信

image

⚠️ 只有在启动的子进程是 Node 进程时，子进程才会根据环境变量去连接对应的 IPC 通道，对于其他类型的子进程则无法实现进程间通信，除非其他进程也按着该约定去连接这个 IPC 通道。

我们知道经典的通信方式是有 Socket，我们平时熟知的 Socket 是基于网络协议的，用于两个不同主机上的两个进程通信，通信需要指定 IP/Host 等。
但如果我们同一台主机上的两个进程想要通信，如果使用 Socket 需要指定 IP/Host，经过网络协议等，会显得过于繁琐。所以 Unix Domain Socket 诞生了。

UDS 的优势：

  • 绑定 socket 文件而不是绑定 IP/Host；不需要经过网络协议，而是数据的拷贝
  • 也支持 SOCK_STREAM(流套接字)和 SOCK_DGRAM(数据包套接字)，但由于是在本机通过内核通信，不会丢包也不会出现发送包的次序和接收包的次序不一致的问题

参考 前端面试题详细解答

image

  1. int main(int argc, char *argv[])
  2. {
  3.     int server_fd ,ret, client_fd;
  4.     struct sockaddr_un serv, client;
  5.     socklen_t len = sizeof(client);
  6.     char buf[1024] = {0};
  7.     int recvlen;
  9.     // 创建 socket
  10.     server_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
  12.     // 初始化 server 信息
  13.     serv.sun_family = AF_LOCAL;
  14.     strcpy(serv.sun_path, "server.sock");
  16.     // 绑定
  17.     ret = bind(server_fd, (struct sockaddr *)&serv, sizeof(serv));
  19.     //设置监听，设置能够同时和服务端连接的客户端数量
  20.     ret = listen(server_fd, 36);
  22.     //等待客户端连接
  23.     client_fd = accept(server_fd, (struct sockaddr *)&client, &len);
  24.     printf("=====client bind file:%s\n", client.sun_path);
  26.     while (1) {
  27.         recvlen = recv(client_fd, buf, sizeof(buf), 0);
  28.         if (recvlen == -1) {
  29.             perror("recv error");
  30.             return -1;
  31.         } else if (recvlen == 0) {
  32.             printf("client disconnet...\n");
  33.             close(client_fd);
  34.             break;
  35.         } else {
  36.             printf("recv buf %s\n", buf);
  37.             send(client_fd, buf, recvlen, 0);
  38.         }
  39.     }
  41.     close(client_fd);
  42.     close(server_fd);
  43.     return 0;
  44. }
  1. int main(int argc, char *argv[])
  2. {
  3.     int client_fd ,ret;
  4.     struct sockaddr_un serv, client;
  5.     socklen_t len = sizeof(client);
  6.     char buf[1024] = {0};
  7.     int recvlen;
  9.     //创建socket
  10.     client_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
  12.     //给客户端绑定一个套接字文件
  13.     client.sun_family = AF_LOCAL;
  14.     strcpy(client.sun_path, "client.sock");
  15.     ret = bind(client_fd, (struct sockaddr *)&client, sizeof(client));
  17.     //初始化server信息
  18.     serv.sun_family = AF_LOCAL;
  19.     strcpy(serv.sun_path, "server.sock");
  20.     //连接
  21.     connect(client_fd, (struct sockaddr *)&serv, sizeof(serv));
  23.     while (1) {
  24.         fgets(buf, sizeof(buf), stdin);
  25.         send(client_fd, buf, strlen(buf)+1, 0);
  27.         recv(client_fd, buf, sizeof(buf), 0);
  28.         printf("recv buf %s\n", buf);
  29.     }
  31.     close(client_fd);
  32.     return 0;
  33. }

命名管道是可以在同一台计算机的不同进程之间，或者跨越一个网络的不同计算机的不同进程之间的可靠的单向或者双向的数据通信。
创建命名管道的进程被称为管道服务端(Pipe Server)，连接到这个管道的进程称为管道客户端(Pipe Client)。

命名管道的命名规范：\server\pipe[\path]\name

  • 其中 server 指定一个服务器的名字，本机适用 . 表示，\192.10.10.1 表示网络上的服务器
  • \pipe 是一个不可变化的字串，用于指定该文件属于 NPFS(Named Pipe File System)
  • [\path]\name 是唯一命名管道名称的标识

image

  1. void ServerTest()
  2. {
  3.     HANDLE  serverNamePipe;
  4.     char    pipeName[MAX_PATH] = {0};
  5.     char    szReadBuf[MAX_BUFFER] = {0};
  6.     char    szWriteBuf[MAX_BUFFER] = {0};
  7.     DWORD   dwNumRead = 0;
  8.     DWORD   dwNumWrite = 0;
  10.     strcpy(pipeName, "\\\\.\\pipe\\shuangxuPipeTest");
  11.     // 创建管道实例
  12.     serverNamePipe = CreateNamedPipeA(pipeName,
  13.         PIPE_ACCESS_DUPLEX|FILE_FLAG_WRITE_THROUGH,
  14.         PIPE_TYPE_BYTE|PIPE_READMODE_BYTE|PIPE_WAIT,
  15.         PIPE_UNLIMITED_INSTANCES, 0, 0, 0, NULL);
  16.     WriteLog("创建管道成功...");
  17.     // 等待客户端连接
  18.     BOOL bRt= ConnectNamedPipe(serverNamePipe, NULL );
  19.     WriteLog( "收到客户端的连接成功...");
  20.     // 接收数据
  21.     memset( szReadBuf, 0, MAX_BUFFER );
  22.     bRt = ReadFile(serverNamePipe, szReadBuf, MAX_BUFFER-1, &dwNumRead, NULL );
  23.     // 业务逻辑处理 （只为测试用返回原来的数据）
  24.     WriteLog( "收到客户数据:[%s]", szReadBuf);
  25.     // 发送数据
  26.     if( !WriteFile(serverNamePipe, szWriteBuf, dwNumRead, &dwNumWrite, NULL ) )
  27.     {
  28.         WriteLog("向客户写入数据失败:[%#x]", GetLastError());
  29.         return ;
  30.     }
  31.     WriteLog("写入数据成功...");
  32. }
  1. void ClientTest()
  2. {
  3.     char    pipeName[MAX_PATH] = {0};
  4.     HANDLE  clientNamePipe;
  5.     DWORD   dwRet;
  6.     char    szReadBuf[MAX_BUFFER] = {0};
  7.     char    szWriteBuf[MAX_BUFFER] = {0};
  8.     DWORD   dwNumRead = 0;
  9.     DWORD   dwNumWrite = 0;
  11.     strcpy(pipeName, "\\\\.\\pipe\\shuangxuPipeTest");
  12.     // 检测管道是否可用
  13.     if(!WaitNamedPipeA(pipeName, 10000)){
  14.         WriteLog("管道[%s]无法打开", pipeName);
  15.         return ;
  16.     }
  17.     // 连接管道
  18.     clientNamePipe = CreateFileA(pipeName,
  19.         GENERIC_READ|GENERIC_WRITE,
  20.         0,
  21.         NULL,
  22.         OPEN_EXISTING,
  23.         FILE_ATTRIBUTE_NORMAL,
  24.         NULL);
  25.     WriteLog("管道连接成功...");
  26.     scanf( "%s", szWritebuf );
  27.     // 发送数据
  28.     if( !WriteFile(clientNamePipe, szWriteBuf, strlen(szWriteBuf), &dwNumWrite, NULL)){
  29.         WriteLog("发送数据失败,GetLastError=[%#x]", GetLastError());
  30.         return ;
  31.     }
  32.     printf("发送数据成功:%s\n", szWritebuf );
  33.     // 接收数据
  34.     if( !ReadFile(clientNamePipe, szReadBuf, MAX_BUFFER-1, &dwNumRead, NULL)){
  35.         WriteLog("接收数据失败,GetLastError=[%#x]", GetLastError() );
  36.         return ;
  37.     }
  38.     WriteLog( "接收到服务器返回:%s", szReadBuf );
  39.     // 关闭管道
  40.     CloseHandle(clientNamePipe);
  41. }

image

对于创建子进程、创建管道、重定向管道均是在 c++ 层实现的

  1. int main(int argc,char *argv[]){
  2.     pid_t pid = fork();
  3.     if (pid < 0) {
  4.         // 错误
  5.     } else if(pid == 0) {
  6.         // 子进程
  7.     } else {
  8.         // 父进程
  9.     }
  10. }

使用 socketpair 创建管道，其创建出来的管道是全双工的，返回的文件描述符中的任何一个都可读和可写

  1. int main ()
  2. {
  3.     int fd[2];
  4.     int r = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
  6.     if (fork()){ /* 父进程 */
  7.         int val = 0;
  8.         close(fd[1]);
  9.         while (1){
  10.             sleep(1);
  11.             ++val;
  12.             printf("发送数据: %d\n", val);
  13.             write(fd[0], &val, sizeof(val));
  14.             read(fd[0], &val, sizeof(val));
  15.             printf("接收数据: %d\n", val);
  16.         }
  17.     } else {  /*子进程*/
  18.         int val;
  19.         close(fd[0]);
  20.         while(1){
  21.             read(fd[1], &val, sizeof(val));
  22.             ++val;
  23.             write(fd[1], &val, sizeof(val));
  24.         }
  25.     }
  26. }

当我们使用 socketpair 创建了管道之后，父进程关闭了 fd[1]，子进程关闭了 fd[0]。子进程可以通过 fd[1] 读写数据；同理主进程通过 fd[0]读写数据完成通信。

fork 函数开启一个子进程的流程

image

  • 初始化参数中的 options.stdio，并且调用 spawn 函数

    1. function spawn(file, args, options) {
    2.   const child = new ChildProcess();
    4.   child.spawn(options);
    5. }

  • 创建 ChildProcess 实例，创建子进程也是调用 C++ 层 this._handle.spawn 方法

    1. function ChildProcess() {
    2.     // C++层定义
    3.     this._handle = new Process();
    4. }

  • 通过 child.spawn 调用到 ChildProcess.prototype.spawn 方法中。其中 getValidStdio 方法会根据 options.stdio 创建和 C++ 交互的 Pipe 对象，并获得对应的文件描述符，将文件描述符写入到环境变量 NODE_CHANNEL_FD 中，调用 C++ 层创建子进程，在调用 setupChannel 方法

    1. ChildProcess.prototype.spawn = function(options) {
    2.   // 预处理进程间通信的数据结构
    3.     stdio = getValidStdio(stdio, false);
    4.     const ipc = stdio.ipc;
    5.     const ipcFd = stdio.ipcFd;
    6.     //将文件描述符写入环境变量中
    7.     if (ipc !== undefined) {
    8.     ArrayPrototypePush(options.envPairs, `NODE_CHANNEL_FD=${ipcFd}`);
    9.   }
    10.     // 创建进程
    11.     const err = this._handle.spawn(options);
    12.     // 添加send方法和监听IPC中数据
    13.     if (ipc !== undefined) setupChannel(this, ipc, serialization);
    14. }

  • 子进程启动时，会根据环境变量中是否存在 NODE_CHANNEL_FD 判断是否调用 _forkChild 方法，创建一个 Pipe 对象, 同时调用 open 方法打开对应的文件描述符，在调用setupChannel

    1. function _forkChild(fd, serializationMode) {
    2.   const p = new Pipe(PipeConstants.IPC);
    3.   p.open(fd);
    4.   p.unref();
    5.   const control = setupChannel(process, p, serializationMode);
    6. }

setupChannel
主要是完成了处理接收的消息、发送消息、处理文件描述符传递等

  1. function setipChannel(){
  2.     channel.onread = function(arrayBuffer){
  3.         //...
  4.     }
  5.     target.on('internalMessage', function(message, handle){
  6.         //...
  7.     })
  8.     target.send = function(message, handle, options, callback){
  9.         //...
  10.     }
  11.     target._send = function(message, handle, options, callback){
  12.         //...
  13.     }
  14.     function handleMessage(message, handle, internal){
  15.         //...
  16.     }
  17. }
  • target.send: process.send 方法，这里 target 就是进程对象本身.
  • target._send: 执行具体 send 逻辑的函数, 当参数 handle 不存在时, 表示普通的消息传递；若存在，包装为内部对象，表明是一个 internalMessage 事件触发。调用使用JSON.stringify 序列化对象, 使用channel.writeUtf8String 写入文件描述符中
  • channel.onread: 获取到数据时触发, 跟 channel.writeUtf8String 相对应。通过 JSON.parse 反序列化 message 之后, 调用 handleMessage 进而触发对应事件
  • handleMessage: 用来判断是触发 message 事件还是 internalMessage 事件
  • target.on(‘internalMessage’): 针对内部对象做特殊处理，在调用 message 事件

image

进程间消息传递

  • 父进程通过 child.send 发送消息 和 server/socket 句柄对象

  • 普通消息直接 JSON.stringify 序列化；对于句柄对象来说，需要先包装成为内部对象

    1. message = {
    2.     cmd: 'NODE_HANDLE',
    3.     type: null,
    4.     msg: message
    5. };

    通过 handleConversion.[message.type].send 的方法取出句柄对象对应的 C++ 层面的 TCP 对象，在采用JSON.stringify 序列化

    1. const handleConversion = {
    2.     'net.Server': {
    3.     simultaneousAccepts: true,
    5.     send(message, server, options) {
    6.       return server._handle;
    7.     },
    9.     got(message, handle, emit) {
    10.       const server = new net.Server();
    11.       server.listen(handle, () => {
    12.         emit(server);
    13.       });
    14.     }
    15.   }
    16. //....
    17. }

  • 最后将序列化后的内部对象和 TCP 对象写入到 IPC 通道中

  • 子进程在接收到消息之后，使用 JSON.parse 反序列化消息，如果为内部对象触发 internalMessage 事件

  • 检查是否带有 TCP 对象，通过 handleConversion.[message.type].got 得到和父进程一样的句柄对象

  • 最后发触发 message 事件传递处理好的消息和句柄对象，子进程通过 process.on 接收

版权声明：本文为coder2028原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/coder2028/p/16962950.html