进程间通信

• 管道：管道是一种半双工的通信方式，允许数据在一个方向上传输，管道分为匿名管道和命名管道
  • 特点：匿名管道：只能在具有亲缘关系的进程中使用(父子进程),数据只能单向流动。命名管道(FIFO)：通过文件系统中的特殊文件实现，支持无亲缘关系的进程通信，数据可以双向流动。

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

int main() {
    int fd[2];
    pipe(fd);  // 创建管道

    if (fork() == 0) {
        // 子进程：写入数据
        close(fd[0]);  // 关闭读端
        write(fd[1], "Hello, Pipe!", 13);
        close(fd[1]);
    } else {
        // 父进程：读取数据
        close(fd[1]);  // 关闭写端
        char buffer[100];
        read(fd[0], buffer, sizeof(buffer));
        printf("Parent received: %s\n", buffer);
        close(fd[0]);
    }
    return 0;
}

• 消息队列：消息队列是一种通过内核维护的消息链表，允许进程以消息的形式发送和接受数据，每条消息都有一个类型标识，接收方可以选择性的读取消息。
  • 特点：支持异步通信，不受进程终止的影响(数据存储在内核中)，消息大小有限制。

#include <stdio.h>
#include <sys/msg.h>
#include <string.h>

struct msg_buffer {
    long msg_type;
    char msg_text[100];
};

int main() {
    key_t key = ftok("progfile", 65);  // 生成唯一键值
    int msgid = msgget(key, 0666 | IPC_CREAT);  // 创建消息队列

    struct msg_buffer message;
    message.msg_type = 1;
    strcpy(message.msg_text, "Hello, Message Queue!");

    msgsnd(msgid, &message, sizeof(message), 0);  // 发送消息
    printf("Message sent: %s\n", message.msg_text);

    msgrcv(msgid, &message, sizeof(message), 1, 0);  // 接收消息
    printf("Message received: %s\n", message.msg_text);

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

• 共享内存：共享内存允许多个进程访问同一个内存区域，从而实现高效的数据共享。需要使用信号量或其他同步机制来避免竞争条件
  • 特点：最快的IPC方式，因为数据直接在内存中共享，需要显示的同步机制(如信号量，读写锁)

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

int main() {
    key_t key = ftok("shmfile", 65);  // 生成唯一键值
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);  // 创建共享内存
    char *str = (char *)shmat(shmid, NULL, 0);  // 连接共享内存

    if (fork() == 0) {
        // 子进程：写入数据
        strcpy(str, "Hello, Shared Memory!");
        printf("Child wrote: %s\n", str);
    } else {
        // 父进程：读取数据
        wait(NULL);  // 等待子进程完成
        printf("Parent read: %s\n", str);
        shmdt(str);  // 断开共享内存连接
        shmctl(shmid, IPC_RMID, NULL);  // 删除共享内存
    }
    return 0;
}

• 信号：信号是一种常见的进程间的通信方式，用于通知进程发生了某个时间，常见信号包括SIGINT(中断信号)、SIGKILL(强制终止信号)
  • 特点：轻量级，但只能传递简单的信号，无法传输复杂数据。信号处理函数可能打断正常的程序执行。

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

void handler(int sig) {
    printf("Received signal: %d\n", sig);
}

int main() {
    signal(SIGINT, handler);  // 注册信号处理函数
    while (1) {
        printf("Waiting for signal...\n");
        sleep(1);
    }
    return 0;
}

• 信号量：信号量是一种用于进程同步的机制，通常与共享内存结合使用，信号量本质是一个计数器，用于控制对共享资源的访问。
  • 特点：主要用于解决进程间的同步问题，不直接传输数据。

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

int main() {
    key_t key = ftok("semfile", 65);  // 生成唯一键值
    int semid = semget(key, 1, 0666 | IPC_CREAT);  // 创建信号量
    semctl(semid, 0, SETVAL, 1);  // 初始化信号量为 1

    struct sembuf sb = {0, -1, 0};  // P 操作
    semop(semid, &sb, 1);  // 获取信号量

    printf("Critical section accessed.\n");

    sb.sem_op = 1;  // V 操作
    semop(semid, &sb, 1);  // 释放信号量

    semctl(semid, 0, IPC_RMID);  // 删除信号量
    return 0;
}

• 套接字：套接字是一种支持跨网络通信的IPC机制，也可以用于本地进程通信，常见协议包括TCP和UDP。
  • 特点：支持跨主机通信，实现复杂，但功能强大

// 服务端代码
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);

    bind(server_fd, (struct sockaddr *)&address, sizeof(address));
    listen(server_fd, 3);

    int new_socket = accept(server_fd, NULL, NULL);
    char buffer[1024] = {0};
    read(new_socket, buffer, 1024);
    printf("Message received: %s\n", buffer);

    send(new_socket, "Hello from server", 18, 0);
    close(new_socket);
    return 0;
}