正文

进程间通信：掌握高效框架，轻松实现数据共享与同步

/0 浏览量
0331

在操作系统中，进程是系统进行资源分配和调度的基本单位。不同的进程可能需要相互通信，以实现数据共享和同步。进程间通信（Inter-Process Communication，IPC）是操作系统提供的一种机制，允许不同进程之间进行数据交换。本文将详细介绍几种常见的进程间通信方法，帮助读者掌握高效框架，轻松实现数据共享与同步。

1. 管道（Pipe）

管道是一种简单的进程间通信方式，它允许一个进程向另一个进程发送数据。管道分为无名管道和命名管道两种。

1.1 无名管道

无名管道是半双工的，即数据只能在一个方向上传输。它适用于父子进程之间的通信。

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

int main() {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        close(pipefd[0]); // 关闭读端
        write(pipefd[1], "Hello, IPC!", 14);
        close(pipefd[1]); // 关闭写端
    } else { // 父进程
        close(pipefd[1]); // 关闭写端
        char buffer[100];
        read(pipefd[0], buffer, sizeof(buffer));
        printf("Received: %s\n", buffer);
        close(pipefd[0]); // 关闭读端
    }

    return 0;
}

1.2 命名管道

命名管道是一种可以持久化的管道，它允许任意两个进程进行通信。

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

int main() {
    int pipefd;
    if (mkfifo("my_fifo", 0666) == -1) {
        perror("mkfifo");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) { // 子进程
        close(pipefd);
        pipefd = open("my_fifo", O_WRONLY);
        write(pipefd, "Hello, IPC!", 14);
        close(pipefd);
    } else { // 父进程
        close(pipefd);
        pipefd = open("my_fifo", O_RDONLY);
        char buffer[100];
        read(pipefd, buffer, sizeof(buffer));
        printf("Received: %s\n", buffer);
        close(pipefd);
        unlink("my_fifo");
    }

    return 0;
}

2. 套接字（Socket）

套接字是一种用于网络通信的接口，它也可以用于进程间通信。

2.1 流式套接字

流式套接字提供全双工、双向的数据传输，适用于传输大量数据。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == -1) {
        perror("socket");
        return 1;
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        return 1;
    }

    if (listen(sock, 5) == -1) {
        perror("listen");
        return 1;
    }

    int connfd;
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    connfd = accept(sock, (struct sockaddr *)&client_addr, &client_addr_len);
    if (connfd == -1) {
        perror("accept");
        return 1;
    }

    char buffer[100];
    read(connfd, buffer, sizeof(buffer));
    printf("Received: %s\n", buffer);

    close(connfd);
    close(sock);

    return 0;
}

2.2 数据报套接字

数据报套接字提供无连接、不可靠的数据传输，适用于传输少量数据。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock == -1) {
        perror("socket");
        return 1;
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        return 1;
    }

    char buffer[100];
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&client_addr, &client_addr_len);
    printf("Received: %s\n", buffer);

    close(sock);

    return 0;
}

3. 信号量（Semaphore）

信号量是一种用于进程同步的机制，它可以防止多个进程同时访问共享资源。

3.1 信号量初始化

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void *thread_func(void *arg) {
    pthread_mutex_lock(&mutex);
    // ... 临界区代码 ...
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

3.2 信号量等待

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void *thread_func(void *arg) {
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    // ... 临界区代码 ...
    pthread_mutex_unlock(&mutex);
    return NULL;
}

4. 总结

进程间通信是操作系统中的重要机制，它允许不同进程之间进行数据交换和同步。本文介绍了管道、套接字和信号量等常见的进程间通信方法，并通过示例代码进行了详细说明。掌握这些方法，可以帮助开发者轻松实现数据共享与同步。

-- 展开阅读全文 --