linux ipc 编程

一、基础概念

定义
- Linux中的IPC（Inter - Process Communication，进程间通信）是指不同进程之间交换数据、共享信息的机制。由于每个进程都有自己独立的地址空间，进程间不能直接访问彼此的数据，所以需要特定的IPC机制来实现通信。

目的
- 主要目的是实现进程之间的数据共享、同步操作以及消息传递等功能。例如，在一个多任务的操作系统中，不同的应用程序或者同一应用程序的不同进程可能需要协同工作，IPC机制就提供了这种协同的途径。

二、相关优势

资源共享
- 多个进程可以共享数据，如共享内存允许进程直接访问同一块物理内存区域，提高了数据的共享效率，避免了数据的多次拷贝。

任务协作
- 进程间可以通过信号量进行同步操作，确保多个进程对共享资源的有序访问。例如，在生产者 - 消费者模型中，生产者进程生产数据放入缓冲区，消费者进程从缓冲区取数据，信号量可以用来控制缓冲区的空位和满位情况，保证两个进程的正确协作。
灵活性
- 不同的IPC机制适用于不同的场景。消息队列适合于异步消息传递，管道适合于父子进程间的单向数据传输等，开发者可以根据具体需求选择合适的机制。

三、类型及应用场景

管道（Pipe）
- 类型特点
  - 管道是一种半双工的通信方式，数据只能单向流动，并且只能在具有亲缘关系（如父子进程）的进程间使用。
- 应用场景
  - 常用于简单的进程间数据传递，例如在一个命令行管道操作中，ls | grep "txt"，ls命令的输出通过管道传递给grep命令进行处理。
- 示例代码（C语言）

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[256];

    if (pipe(pipefd)== -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程，关闭读端，向写端写入数据
        close(pipefd[0]);
        const char *message = "Hello from child process";
        write(pipefd[1], message, strlen(message)+1);
        close(pipefd[1]);
        exit(EXIT_SUCCESS);
    } else {
        // 父进程，关闭写端，从读端读取数据
        close(pipefd[1]);
        read(pipefd[0], buffer, sizeof(buffer));
        printf("Parent received: %s
", buffer);
        close(pipefd[0]);
    }
    return 0;
}

消息队列（Message Queue）
- 类型特点
  - 消息队列是一种基于消息的通信方式，进程可以将消息发送到队列中，其他进程可以从队列中接收消息。它支持多对多的通信模式，并且消息有类型区分。
- 应用场景
  - 在分布式系统或者多进程的任务调度系统中，用于异步消息传递。例如，一个日志收集进程可以从多个应用程序进程的消息队列中接收日志消息。
- 示例代码（C语言，使用System V消息队列）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

struct msgbuf {
    long mtype;
    char mtext[100];
};

int main() {
    key_t key;
    int msgid;
    struct msgbuf sbuf, rbuf;

    key = ftok(".", 'a');
    msgid = msgget(key, 0666 | IPC_CREAT);

    // 发送消息
    sbuf.mtype = 1;
    strcpy(sbuf.mtext, "Hello from sender");
    msgsnd(msgid, &sbuf, sizeof(sbuf.mtext), 0);

    // 接收消息
    msgrcv(msgid, &rbuf, sizeof(rbuf.mtext), 1, 0);
    printf("Received: %s
", rbuf.mtext);

    msgctl(msgid, IPC_RMID, NULL);
    return 0;
}

共享内存（Shared Memory）
- 类型特点
  - 共享内存是允许多个进程共享同一块物理内存区域的IPC机制。它是所有IPC机制中速度最快的，因为数据不需要在进程间进行拷贝。但是需要配合信号量等机制来保证数据的一致性。
- 应用场景
  - 在需要对大量数据进行高效共享的场景，如图形处理程序中多个进程共享图像数据，或者数据库系统中多个进程共享数据缓存。
- 示例代码（C语言，使用System V共享内存）

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main() {
    key_t key;
    int shmid;
    char *str;

    key = ftok(".", 'b');
    shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    str = (char *) shmat(shmid, (void *)0, 0);

    strcpy(str, "Hello from shared memory");

    printf("Data written in memory: %s
", str);

    shmdt(str);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

信号量（Semaphore）
- 类型特点
  - 信号量是一个整型变量，主要用于进程间的同步操作。它可以用来控制多个进程对共享资源的访问数量。
- 应用场景
  - 在多进程并发访问有限资源（如打印机、文件等）时，用于防止竞争条件。例如，在生产者 - 消费者模型中，控制缓冲区的访问。
- 示例代码（C语言，使用System V信号量）

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int main() {
    key_t key;
    int semid;
    union semun arg;
    struct sembuf sb = {0, -1, SEM_UNDO};

    key = ftok(".", 'c');
    semid = semget(key, 1, 0666 | IPC_CREAT);
    arg.val = 1;
    semctl(semid, 0, SETVAL, arg);

    // 模拟临界区访问
    semop(semid, &sb, 1);
    printf("Entering critical section
");
    sleep(2);
    printf("Exiting critical section
");
    sb.sem_op = 1;
    semop(semid, &sb, 1);

    semctl(semid, 0, IPC_RMID, arg);
    return 0;
}

四、常见问题及解决方法

数据不一致问题（以共享内存为例）
- 原因
  - 当多个进程同时访问和修改共享内存中的数据时，如果没有适当的同步机制（如信号量），就会导致数据不一致。例如，两个进程同时读取一个变量的值，然后分别进行加1操作，最后写回共享内存，这样就会导致这个变量的值只增加了1而不是2。
- 解决方法
  - 使用信号量或者互斥锁来保证对共享内存的互斥访问。在访问共享内存之前，进程获取信号量（使得其他进程不能访问），访问结束后释放信号量。

死锁问题（在信号量或多进程同步场景下）
- 原因
  - 当多个进程互相等待对方释放资源时就会发生死锁。例如，进程A持有资源1并请求资源2，而进程B持有资源2并请求资源1。
- 解决方法
  - 遵循资源分配顺序原则，确保所有进程以相同的顺序请求资源；或者使用超时机制，在等待资源一定时间后放弃并重新尝试。
消息丢失问题（消息队列）
- 原因
  - 如果消息队列已满，发送方进程发送消息时可能会失败而导致消息丢失；或者在接收方进程异常退出时没有正确处理未接收的消息。
- 解决方法
  - 对于队列满的情况，可以采用非阻塞发送或者循环发送直到成功；对于接收方异常退出的情况，可以使用持久化消息队列或者对消息进行备份处理。