Linux 进程间通讯

目录

Linux IPC 方式

几种常用的方式举例说明

1. 管道(Pipes):

2. 消息队列(Message Queues):

3. 共享内存(Shared Memory):

4. 信号量(Semaphores):

5. 套接字(Sockets):


Linux IPC 方式

在Linux系统中,进程间通信(IPC)是多个运行中的程序或进程之间交换数据和信息的关键机制。Linux提供了多种IPC机制,每种机制都有其特定的用途和优势。以下是Linux上主要的IPC通信方式:

  1. 管道(Pipes)

    • 管道是Linux中最古老的IPC机制之一,它允许数据从一个进程(生产者)流向另一个进程(消费者)。管道是半双工的,即数据只能在一个方向上传输。
    • 无名管道:仅在具有亲缘关系的进程(如父进程和子进程)之间可用,一旦创建了管道,它就与创建它的进程相关联。
    • 命名管道(FIFO):可以在没有亲缘关系的进程之间使用,它们是文件系统中的特殊文件,可以跨启动会话使用。
  2. 消息队列(Message Queues)

    • 消息队列允许进程之间传递结构化的消息,每个消息都有一个类型,这使得消息的过滤成为可能。
    • 消息队列是系统V IPC的一部分,可以在多个进程中使用,即使进程重启后仍然存在。
  3. 信号量(Semaphores)

    • 信号量用于控制对共享资源的访问,避免竞态条件。它们可以是二进制(只有0和1的状态)或计数信号量(可以有多个单位)。
    • 信号量同样属于系统V IPC的一部分,可以跨进程使用,用于同步进程间的操作。
  4. 共享内存(Shared Memory)

    • 共享内存允许多个进程直接访问同一块内存区域,这是最快的IPC机制,因为数据不需要复制。
    • 使用共享内存时,通常还需要信号量或互斥锁来防止多个进程同时修改同一数据。
  5. 信号(Signals)

    • 信号是软件中断,可以由硬件事件、软件异常或另一个进程发送给进程。它们主要用于通知进程发生了某些事件。
    • 信号本身并不携带大量数据,但是可以触发进程执行特定的操作。
  6. 套接字(Sockets)

    • 套接字提供了进程间通信的网络接口,不仅限于本地进程间通信,还可以用于网络通信。
    • 包括流式套接字(SOCK_STREAM,类似TCP)和数据报套接字(SOCK_DGRAM,类似UDP)。
  7. 流(Streams)

    • 流类似于管道,但它们提供了更复杂的通信机制,支持错误处理、流控制和多路复用。
  8. 内存映射文件(Memory-Mapped Files)

    • 虽然严格来说这不是传统的IPC机制,但通过将文件映射到内存中,进程可以像访问内存一样访问文件,从而实现进程间的数据共享。

选择IPC机制时,应考虑通信的需求(如速度、可靠性、复杂性、数据大小等),以及进程之间的关系(如是否在同一台机器上,是否有亲缘关系等)。例如,对于需要高速数据传输的场景,共享内存可能是最佳选择,而如果需要在网络上的多个机器之间通信,则应使用套接字。

几种常用的方式举例说明

1. 管道(Pipes)

  • 匿名管道(Anonymous Pipes):只能用于有亲缘关系的进程之间(如父子进程)。通过pipe()系统调用创建,数据以字节流的形式在进程之间传输。
    • 示例:
      int fd[2];
      pipe(fd);
      if (fork() == 0) {
          // 子进程
          close(fd[1]);
          char buf[100];
          read(fd[0], buf, sizeof(buf));
          printf("Child read: %s\n", buf);
          close(fd[0]);
      } else {
          // 父进程
          close(fd[0]);
          write(fd[1], "Hello from parent", 17);
          close(fd[1]);
      }
  • 命名管道(Named Pipes/FIFOs):可以用于没有亲缘关系的进程之间。通过mkfifo()系统调用创建。
    • 示例:
      mkfifo("/tmp/myfifo", 0666);
      if (fork() == 0) {
          // 子进程
          int fd = open("/tmp/myfifo", O_RDONLY);
          char buf[100];
          read(fd, buf, sizeof(buf));
          printf("Child read: %s\n", buf);
          close(fd);
      } else {
          // 父进程
          int fd = open("/tmp/myfifo", O_WRONLY);
          write(fd, "Hello from parent", 17);
          close(fd);
          wait(NULL); // 等待子进程结束
          unlink("/tmp/myfifo"); // 删除FIFO文件
      }

2. 消息队列(Message Queues)

  • 提供了一种基于消息的通信方式,允许发送和接收带类型的消息。通过msgget()msgsnd()msgrcv()系统调用进行操作。
    • 示例:
      key_t key = ftok("somefile", 65);
      int msgid = msgget(key, 0666 | IPC_CREAT);
      struct msg_buffer {
          long msg_type;
          char msg_text[100];
      } message;
      
      if (fork() == 0) {
          // 子进程
          message.msg_type = 1;
          msgrcv(msgid, &message, sizeof(message.msg_text), 1, 0);
          printf("Child received: %s\n", message.msg_text);
      } else {
          // 父进程
          message.msg_type = 1;
          strcpy(message.msg_text, "Hello from parent");
          msgsnd(msgid, &message, sizeof(message.msg_text), 0);
          wait(NULL); // 等待子进程结束
          msgctl(msgid, IPC_RMID, NULL); // 删除消息队列
      }

3. 共享内存(Shared Memory)

  • 允许多个进程直接访问同一块内存区域,通过shmget()shmat()shmdt()系统调用进行操作,通常需要配合信号量或互斥锁来控制访问。
    • 示例:
      key_t key = ftok("somefile", 65);
      int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
      char *str = (char*) shmat(shmid, NULL, 0);
      
      if (fork() == 0) {
          // 子进程
          sleep(1); // 确保父进程先写入
          printf("Child read: %s\n", str);
          shmdt(str);
      } else {
          // 父进程
          strcpy(str, "Hello from parent");
          wait(NULL); // 等待子进程结束
          shmdt(str);
          shmctl(shmid, IPC_RMID, NULL); // 删除共享内存
      }

4. 信号量(Semaphores)

  • 用于控制对共享资源的访问,通过semget()semop()semctl()系统调用进行操作。
    • 示例:
      key_t key = ftok("somefile", 65);
      int semid = semget(key, 1, 0666 | IPC_CREAT);
      semctl(semid, 0, SETVAL, 1); // 初始化信号量为1
      struct sembuf sb = {0, -1, 0}; // P操作
      
      if (fork() == 0) {
          // 子进程
          semop(semid, &sb, 1); // P操作
          printf("Child in critical section\n");
          sleep(2);
          sb.sem_op = 1; // V操作
          semop(semid, &sb, 1);
      } else {
          // 父进程
          semop(semid, &sb, 1); // P操作
          printf("Parent in critical section\n");
          sleep(2);
          sb.sem_op = 1; // V操作
          semop(semid, &sb, 1);
          wait(NULL); // 等待子进程结束
          semctl(semid, 0, IPC_RMID); // 删除信号量
      }

5. 套接字(Sockets)

  • 适用于网络通信,也可以用于同一台机器上的进程间通信,支持面向连接的TCP和无连接的UDP协议。
    • 示例(Unix域套接字):
      int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
      struct sockaddr_un addr = {0};
      addr.sun_family = AF_UNIX;
      strcpy(addr.sun_path, "/tmp/mysocket");
      
      if (fork() == 0) {
          // 子进程
          sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
          connect(sockfd, (struct sockaddr*)&addr, sizeof(addr));
          char buf[100];
          read(sockfd, buf, sizeof(buf));
          printf("Child read: %s\n", buf);
          close(sockfd);
      } else {
          // 父进程
          bind(sockfd, (struct sockaddr*)&addr, sizeof(addr));
          listen(sockfd, 5);
          int connfd = accept(sockfd, NULL, NULL);
          write(connfd, "Hello from parent", 17);
          close(connfd);
          close(sockfd);
          wait(NULL); // 等待子进程结束
          unlink("/tmp/mysocket"); // 删除套接字文件
      }

这些IPC机制在实际开发中各有其适用场景,选择适合的方式可以有效地实现进程间的通信和数据共享。

  • 7
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

telllong

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值