正文

掌握线程与进程通讯：轻松实现高效协作与数据共享

/0 浏览量
0608

在计算机科学中，线程和进程是两个核心概念，它们在操作系统中负责执行任务。线程是进程中的一个实体，是CPU调度和分配的基本单位。进程则是执行程序的基本单位，拥有独立的内存空间和其他资源。线程与进程之间的通讯是实现高效协作和数据共享的关键。本文将深入探讨线程与进程通讯的原理、方法以及在实际应用中的技巧。

线程与进程通讯的必要性

1. 提高效率

在多线程或多进程环境中，各个线程或进程往往需要协同工作，共同完成一个复杂的任务。通过通讯机制，可以使得不同线程或进程之间能够高效地交换信息，避免重复计算和资源浪费。

2. 数据共享

在多线程或多进程程序中，往往需要共享某些数据，如全局变量、文件等。通讯机制可以确保这些数据在各个线程或进程之间安全、可靠地传输。

线程与进程通讯的方法

1. 管道（Pipe）

管道是一种简单的线程或进程间通讯机制，它允许一个进程或线程向另一个进程或线程发送数据。管道分为无名管道和命名管道两种。

无名管道

#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, World!\n", 14);
        close(pipefd[1]); // 关闭写端
    } else {
        // 父进程
        close(pipefd[1]); // 关闭写端
        char buffer[1024];
        read(pipefd[0], buffer, sizeof(buffer));
        printf("%s", buffer);
        close(pipefd[0]); // 关闭读端
    }

    return 0;
}

命名管道

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

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

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

    if (pid == 0) {
        // 子进程
        close(pipefd);
        int fifo_fd = open("myfifo", O_WRONLY);
        write(fifo_fd, "Hello, World!\n", 14);
        close(fifo_fd);
    } else {
        // 父进程
        int fifo_fd = open("myfifo", O_RDONLY);
        char buffer[1024];
        read(fifo_fd, buffer, sizeof(buffer));
        printf("%s", buffer);
        close(fifo_fd);
        unlink("myfifo");
    }

    return 0;
}

2. 套接字（Socket）

套接字是一种用于不同主机上的进程间通讯的机制。它支持网络通信，可以实现跨主机、跨平台的数据传输。

TCP套接字

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

int main() {
    int server_fd, client_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);

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

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(8080);

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

    listen(server_fd, 5);

    client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_addr_len);
    if (client_fd == -1) {
        perror("accept");
        return 1;
    }

    char buffer[1024];
    read(client_fd, buffer, sizeof(buffer));
    printf("%s", buffer);

    close(client_fd);
    close(server_fd);

    return 0;
}

UDP套接字

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

int main() {
    int server_fd, client_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);

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

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(8080);

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

    char buffer[1024];
    int recv_len = recvfrom(server_fd, buffer, sizeof(buffer), 0, (struct sockaddr *)&client_addr, &client_addr_len);
    if (recv_len == -1) {
        perror("recvfrom");
        return 1;
    }

    printf("%s", buffer);

    close(server_fd);

    return 0;
}

3. 共享内存（Shared Memory）

共享内存是一种高效的线程或进程间通讯机制，它允许不同线程或进程访问同一块内存区域。

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

int main() {
    key_t key = ftok("keyfile", 65);
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        return 1;
    }

    char *shared_memory = shmat(shmid, NULL, 0);
    if (shared_memory == (char *)(-1)) {
        perror("shmat");
        return 1;
    }

    strcpy(shared_memory, "Hello, World!");

    printf("%s\n", shared_memory);

    shmdt(shared_memory);
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

4. 信号量（Semaphore）

信号量是一种用于同步多个线程或进程的机制，它可以确保同一时间只有一个线程或进程访问共享资源。

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

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

int main() {
    key_t key = ftok("keyfile", 65);
    int semid = semget(key, 1, 0666 | IPC_CREAT);
    if (semid == -1) {
        perror("semget");
        return 1;
    }

    union semun arg;
    arg.val = 1;
    semctl(semid, 0, SETVAL, arg);

    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        return 1;
    }

    char *shared_memory = shmat(shmid, NULL, 0);
    if (shared_memory == (char *)(-1)) {
        perror("shmat");
        return 1;
    }

    strcpy(shared_memory, "Hello, World!");

    printf("%s\n", shared_memory);

    shmdt(shared_memory);
    shmctl(shmid, IPC_RMID, NULL);
    semctl(semid, 0, IPC_RMID, arg);

    return 0;
}

总结

线程与进程通讯是实现高效协作和数据共享的关键。本文介绍了管道、套接字、共享内存和信号量等常见的通讯机制，并提供了相应的代码示例。在实际应用中，可以根据具体需求选择合适的通讯机制，以实现高效、可靠的数据传输。

-- 展开阅读全文 --