正文

Linux系统下进程线程通信技巧与实例解析

/0 浏览量
0610

在Linux系统中，进程和线程之间的通信是程序设计中的重要环节。有效的通信机制可以提高程序的效率和性能，尤其是在多线程或多进程环境下。本文将介绍Linux系统下几种常见的进程线程通信技巧，并通过实例进行解析。

1. 管道（Pipe）

管道是Linux中最基本的进程间通信（IPC）机制之一。它允许一个进程向另一个进程传递数据。管道可以是单向的或双向的。

实例：使用无名管道进行父子进程通信

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    int pipe_fd[2];
    pid_t pid;

    if (pipe(pipe_fd) == -1) {
        perror("pipe");
        return 1;
    }

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

    if (pid == 0) { // 子进程
        close(pipe_fd[0]); // 关闭读端
        char *message = "Hello, parent!";
        write(pipe_fd[1], message, strlen(message)); // 写入数据
        close(pipe_fd[1]); // 关闭写端
    } else { // 父进程
        close(pipe_fd[1]); // 关闭写端
        char buffer[100];
        read(pipe_fd[0], buffer, sizeof(buffer)); // 读取数据
        printf("Received message: %s\n", buffer);
        close(pipe_fd[0]); // 关闭读端
        wait(NULL); // 等待子进程结束
    }

    return 0;
}

2. 命名管道（FIFO）

命名管道是一种更为灵活的IPC机制，允许任意两个进程进行通信，无论它们是否具有共同的祖先。

实例：使用命名管道进行进程间通信

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

int main() {
    int fifo_fd;
    const char *fifo_path = "/tmp/my_fifo";

    // 创建命名管道
    mkfifo(fifo_path, 0666);

    // 父进程
    if (fork() == 0) {
        char message[] = "Hello, child!";
        fifo_fd = open(fifo_path, O_WRONLY);
        write(fifo_fd, message, strlen(message));
        close(fifo_fd);
        unlink(fifo_path);
    } else {
        // 子进程
        fifo_fd = open(fifo_path, O_RDONLY);
        char buffer[100];
        read(fifo_fd, buffer, sizeof(buffer));
        printf("Received message: %s\n", buffer);
        close(fifo_fd);
    }

    return 0;
}

3. 消息队列（Message Queue）

消息队列允许不同进程传递消息。消息是固定长度的，可以携带不同类型的数据。

实例：使用消息队列进行进程间通信

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

#define MSGSZ 256

struct msgbuf {
    long msgtype;
    char msgtext[MSGSZ];
};

int main() {
    key_t key = 1234;
    int msgid;
    struct msgbuf msg;

    // 创建消息队列
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(1);
    }

    // 父进程
    if (fork() == 0) {
        strcpy(msg.msgtext, "Hello, child!");
        msg.msgtype = 1;
        msgsnd(msgid, &msg, strlen(msg.msgtext), 0);
    } else {
        // 子进程
        msg.msgtype = 1;
        msgrcv(msgid, &msg, MSGSZ, 1, 0);
        printf("Received message: %s\n", msg.msgtext);
    }

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

    return 0;
}

4. 信号量（Semaphore）

信号量用于进程或线程同步，防止竞态条件。

实例：使用信号量进行进程间同步

#include <stdio.h>
#include <stdlib.h>
#include <unistd.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 = 1234;
    int semid;
    struct sembuf sop;

    // 创建信号量集
    semid = semget(key, 1, 0666 | IPC_CREAT);
    if (semid == -1) {
        perror("semget");
        exit(1);
    }

    // 初始化信号量
    union semun init_union;
    init_union.val = 1;
    if (semctl(semid, 0, SETVAL, init_union) == -1) {
        perror("semctl");
        exit(1);
    }

    // 父进程
    if (fork() == 0) {
        // 等待信号量
        sop.sem_num = 0;
        sop.sem_op = -1;
        sop.sem_flg = 0;
        semop(semid, &sop, 1);

        printf("Child process is running.\n");
        sleep(1);

        // 释放信号量
        sop.sem_op = 1;
        semop(semid, &sop, 1);
    } else {
        // 父进程
        sleep(1);

        // 获取信号量
        sop.sem_num = 0;
        sop.sem_op = 1;
        sop.sem_flg = 0;
        semop(semid, &sop, 1);

        printf("Parent process is running.\n");
        wait(NULL);

        // 删除信号量集
        if (semctl(semid, 0, IPC_RMID, init_union) == -1) {
            perror("semctl");
            exit(1);
        }
    }

    return 0;
}

5. 共享内存（Shared Memory）

共享内存允许多个进程共享一块内存区域，从而实现高效的数据交换。

实例：使用共享内存进行进程间通信

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

#define SHM_SIZE 1024

int main() {
    key_t key = 1234;
    int shmid;
    char *shm, *s;

    // 创建共享内存
    shmid = shmget(key, SHM_SIZE, 0666 | IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }

    // 连接共享内存
    shm = shmat(shmid, (void *)0, 0);
    if (shm == (char *)(-1)) {
        perror("shmat");
        exit(1);
    }

    // 父进程
    if (fork() == 0) {
        // 写入数据
        s = shm;
        while (*s != '\0') {
            *s++ = 'A';
        }
        *s = '\0';
    } else {
        // 子进程
        // 读取数据
        s = shm;
        while (*s != '\0') {
            *s++ = 'B';
        }
        *s = '\0';
    }

    // 删除共享内存
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl");
        exit(1);
    }

    return 0;
}

通过以上实例，我们可以看到在Linux系统中，进程和线程之间的通信可以通过多种方式进行。每种方式都有其适用场景和特点。在实际应用中，选择合适的通信机制可以提高程序的效率和性能。

-- 展开阅读全文 --