Linux进程间通信

进程间通信的方式有很多，主要有六种方式，分别为：管道、FIFO、消息队列、共享内存、信号、信号量。

一、管道

Linux进程间通信可以使用管道（pipe）来实现。管道是一种半双工的通信方式，只能在具有亲缘关系的进程之间使用。下面是一个简单的示例代码，演示了如何使用管道进行进程间通信：

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

#define BUFFER_SIZE 1024

int main()
{
    int fd[2];
    pid_t pid;
    char buffer[BUFFER_SIZE];

    // 创建管道
    if (pipe(fd) < 0) {
        perror("pipe error");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    if ((pid = fork()) < 0) {
        perror("fork error");
        exit(EXIT_FAILURE);
    } else if (pid > 0) { // 父进程
        close(fd[0]); // 关闭读端
        printf("Parent process: Enter a message to send to child process:\n");
        fgets(buffer, BUFFER_SIZE, stdin);
        write(fd[1], buffer, strlen(buffer));
        close(fd[1]); // 关闭写端
    } else { // 子进程
        close(fd[1]); // 关闭写端
        read(fd[0], buffer, BUFFER_SIZE);
        printf("Child process: Received message from parent process: %s", buffer);
        close(fd[0]); // 关闭读端
    }

    return 0;
}

在这个示例代码中，首先创建了一个管道，然后创建了一个子进程。父进程关闭了读端，从标准输入中读取一条消息，然后将消息写入管道的写端，最后关闭写端。子进程关闭了写端，从管道的读端读取消息，然后将消息打印出来，最后关闭读端。这样就完成了进程间的通信。

二、FIFO

Linux进程间通信可以使用FIFO（命名管道）来实现。FIFO是一种特殊的文件，可以在不具有亲缘关系的进程之间使用。下面是一个简单的示例代码，演示了如何使用FIFO进行进程间通信：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define BUFFER_SIZE 1024
#define FIFO_NAME "/tmp/myfifo"

int main()
{
    int fd;
    pid_t pid;
    char buffer[BUFFER_SIZE];

    // 创建FIFO
    if (mkfifo(FIFO_NAME, 0666) < 0) {
        perror("mkfifo error");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    if ((pid = fork()) < 0) {
        perror("fork error");
        exit(EXIT_FAILURE);
    } else if (pid > 0) { // 父进程
        printf("Parent process: Enter a message to send to child process:\n");
        fgets(buffer, BUFFER_SIZE, stdin);
        fd = open(FIFO_NAME, O_WRONLY);
        write(fd, buffer, strlen(buffer));
        close(fd);
    } else { // 子进程
        fd = open(FIFO_NAME, O_RDONLY);
        read(fd, buffer, BUFFER_SIZE);
        printf("Child process: Received message from parent process: %s", buffer);
        close(fd);
    }

    // 删除FIFO
    unlink(FIFO_NAME);

    return 0;
}

在这个示例代码中，首先创建了一个FIFO，然后创建了一个子进程。父进程从标准输入中读取一条消息，然后打开FIFO的写端，将消息写入FIFO，最后关闭FIFO。子进程打开FIFO的读端，从FIFO中读取消息，然后将消息打印出来，最后关闭FIFO。这样就完成了进程间的通信。最后，删除FIFO文件。

需要注意的是，FIFO是一种特殊的文件，需要使用mkfifo()函数创建，使用open()函数打开，使用unlink()函数删除。在使用FIFO进行进程间通信时，需要注意文件权限和文件打开方式等问题。

三、消息队列

Linux进程间通信可以使用消息队列来实现。消息队列是一种进程间通信机制，可以在不同进程之间传递数据。下面是一个简单的示例代码，演示了如何使用消息队列进行进程间通信：

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

#define BUFFER_SIZE 1024

struct message {
    long type;
    char text[BUFFER_SIZE];
};

int main()
{
    int msgid;
    pid_t pid;
    struct message msg;

    // 创建消息队列
    if ((msgid = msgget(IPC_PRIVATE, 0666)) < 0) {
        perror("msgget error");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    if ((pid = fork()) < 0) {
        perror("fork error");
        exit(EXIT_FAILURE);
    } else if (pid > 0) { // 父进程
        printf("Parent process: Enter a message to send to child process:\n");
        fgets(msg.text, BUFFER_SIZE, stdin);
        msg.type = 1;
        msgsnd(msgid, &msg, strlen(msg.text) + 1, 0);
    } else { // 子进程
        msgrcv(msgid, &msg, BUFFER_SIZE, 1, 0);
        printf("Child process: Received message from parent process: %s", msg.text);
    }

    // 删除消息队列
    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

在这个示例代码中，首先创建了一个消息队列，然后创建了一个子进程。父进程从标准输入中读取一条消息，然后将消息发送到消息队列中，最后关闭消息队列。子进程从消息队列中接收消息，然后将消息打印出来，最后关闭消息队列。这样就完成了进程间的通信。最后，删除消息队列。

需要注意的是，消息队列是一种特殊的IPC机制，需要使用msgget()函数创建，使用msgsnd()函数发送消息，使用msgrcv()函数接收消息，使用msgctl()函数删除消息队列。在使用消息队列进行进程间通信时，需要注意消息类型、消息长度和消息队列的权限等问题。

四、共享内存

Linux进程间通信还可以使用共享内存来实现。共享内存是一种进程间通信机制，可以在不同进程之间共享同一块内存区域。下面是一个简单的示例代码，演示了如何使用共享内存进行进程间通信：

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

#define BUFFER_SIZE 1024

int main()
{
    int shmid;
    pid_t pid;
    char *shmaddr;

    // 创建共享内存
    if ((shmid = shmget(IPC_PRIVATE, BUFFER_SIZE, 0666)) < 0) {
        perror("shmget error");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    if ((pid = fork()) < 0) {
        perror("fork error");
        exit(EXIT_FAILURE);
    } else if (pid > 0) { // 父进程
        printf("Parent process: Enter a message to send to child process:\n");
        fgets(shmaddr, BUFFER_SIZE, stdin);
        printf("Parent process: Message sent to child process: %s", shmaddr);
    } else { // 子进程
        shmaddr = shmat(shmid, NULL, 0);
        printf("Child process: Received message from parent process: %s", shmaddr);
        shmdt(shmaddr);
    }

    // 删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

在这个示例代码中，首先创建了一个共享内存，然后创建了一个子进程。父进程从标准输入中读取一条消息，然后将消息写入共享内存中，最后关闭共享内存。子进程从共享内存中读取消息，然后将消息打印出来，最后关闭共享内存。这样就完成了进程间的通信。最后，删除共享内存。

需要注意的是，共享内存是一种特殊的IPC机制，需要使用shmget()函数创建，使用shmat()函数将共享内存映射到进程的地址空间中，使用shmdt()函数解除共享内存的映射，使用shmctl()函数删除共享内存。在使用共享内存进行进程间通信时，需要注意共享内存的大小、权限和选项等问题。

五、信号

Linux进程间通信还可以使用信号来实现。信号是一种异步通知机制，可以在不同进程之间发送信号，以便进行进程间通信。下面是一个简单的示例代码，演示了如何使用信号进行进程间通信：
 

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

void sig_handler(int signo)
{
    if (signo == SIGUSR1) {
        printf("Received SIGUSR1 signal from parent process\n");
    }
}

int main()
{
    pid_t pid;

    // 创建子进程
    if ((pid = fork()) < 0) {
        perror("fork error");
        exit(EXIT_FAILURE);
    } else if (pid > 0) { // 父进程
        printf("Parent process: Sending SIGUSR1 signal to child process\n");
        kill(pid, SIGUSR1);
    } else { // 子进程
        signal(SIGUSR1, sig_handler);
        printf("Child process: Waiting for signal from parent process\n");
        pause();
    }

    return 0;
}

在这个示例代码中，首先创建了一个子进程。父进程向子进程发送SIGUSR1信号，子进程等待信号的到来，一旦收到信号，就调用sig_handler()函数进行处理。在sig_handler()函数中，可以根据信号的类型进行不同的处理。

需要注意的是，信号是一种异步通知机制，进程在收到信号时，可能正在执行某个操作，因此需要在信号处理函数中进行合适的处理，以避免出现不可预料的错误。此外，不同的信号有不同的含义和用途，需要根据实际情况选择合适的信号进行进程间通信。

六、信号量

除了信号以外，Linux进程间通信还可以使用信号量来实现。信号量是一种计数器，用于控制多个进程对共享资源的访问。下面是一个简单的示例代码，演示了如何使用信号量进行进程间通信：
 

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

#define KEY 1234

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

int main()
{
    int semid;
    union semun arg;
    struct sembuf sb;

    // 创建信号量
    if ((semid = semget(KEY, 1, IPC_CREAT | 0666)) < 0) {
        perror("semget error");
        exit(EXIT_FAILURE);
    }

    // 初始化信号量
    arg.val = 1;
    if (semctl(semid, 0, SETVAL, arg) < 0) {
        perror("semctl error");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    pid_t pid;
    if ((pid = fork()) < 0) {
        perror("fork error");
        exit(EXIT_FAILURE);
    } else if (pid > 0) { // 父进程
        sb.sem_num = 0;
        sb.sem_op = -1;
        sb.sem_flg = 0;
        printf("Parent process: Waiting for semaphore\n");
        if (semop(semid, &sb, 1) < 0) {
            perror("semop error");
            exit(EXIT_FAILURE);
        }
        printf("Parent process: Acquired semaphore\n");
    } else { // 子进程
        sb.sem_num = 0;
        sb.sem_op = 1;
        sb.sem_flg = 0;
        printf("Child process: Releasing semaphore\n");
        if (semop(semid, &sb, 1) < 0) {
            perror("semop error");
            exit(EXIT_FAILURE);
        }
    }

    // 删除信号量
    if (semctl(semid, 0, IPC_RMID, arg) < 0) {
        perror("semctl error");
        exit(EXIT_FAILURE);
    }

    return 0;
}

在这个示例代码中，首先创建了一个信号量，并将其初始化为1。然后创建了一个子进程，父进程等待信号量的释放，一旦信号量被释放，就输出一条信息。子进程释放信号量，然后退出。

需要注意的是，信号量是一种计数器，可以用于控制多个进程对共享资源的访问。在使用信号量时，需要注意避免死锁和竞争条件等问题。此外，不同的信号量有不同的含义和用途，需要根据实际情况选择合适的信号量进行进程间通信。