当前位置:   article > 正文

linux进程间通讯指南-打通IPC大门,高效沟通无阻

linux进程间通讯指南-打通IPC大门,高效沟通无阻

在现代操作系统中,进程就像独立的个体,有时需要相互合作、数据共享,这就要求进程间能够高效通信。本文将为你揭开Linux进程间通信(IPC)的神秘面纱,探讨各种IPC工具的运作原理,同步机制的重要性,以及如何规避潜在风险。我们将通过丰富的C++示例,让你融会贯通IPC实践。


一、IPC概述:进程间畅所欲言


所谓IPC(Inter-Process Communication),就是指允许进程之间传递数据或进行通信控制的机制。在Linux下,主要的IPC工具包括管道(Pipe)、FIFO、消息队列(Message Queue)、共享内存(Shared Memory)、信号(Signal)等。


IPC工具可以分为两大类:

  • 数据传输工具:如管道、消息队列等,用于在进程间传递数据。

在这里插入图片描述


  • 同步工具:信号量、文件锁等同步工具,则控制对共享资源的访问顺序,避免竞争条件。

    在这里插入图片描述


二、选择恰当的IPC工具


1、数据传输工具

从上面的分类中我们可以看到,IPC 工具有很多,而区分这些工具的关键因素就是数据读取和写入的形式。

比如说,一些
IPC 工具要求在写数据时将数据从用户内存传输至内核内存,读取数据时则将数据从内核内存输入到用户内存。

其中最典型的就是流 式
socket 和管道。


(1)、流 式
socket

流式
socket 数据必须从用户缓冲区写入至
TCP 连接的发送缓冲区中 ,读取数据时则从
TCP 连接的接收缓冲区进行读取。

流式socket通常指的是面向连接的TCP socket,数据的发送和接收通过socket描述符来进行。

以下是一个简单的示例,演示如何使用TCP socket进行数据的发送和接收:

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    const int server_port = 8080;
    const char* server_ip = "127.0.0.1";
    int sock_fd;
    struct sockaddr_in server_addr;

    // 创建socket
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd < 0) {
        std::cerr << "Failed to create socket" << std::endl;
        return 1;
    }

    // 设置服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(server_port);
    if (inet_pton(AF_INET, server_ip, &server_addr.sin_addr) <= 0) {
        std::cerr << "Invalid address" << std::endl;
        close(sock_fd);
        return 1;
    }

    // 连接到服务器
    if (connect(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr << "Failed to connect to the server" << std::endl;
        close(sock_fd);
        return 1;
    }

    // 发送数据
    const char* message = "Hello, Server!";
    if (send(sock_fd, message, strlen(message), 0) < 0) {
        std::cerr << "Send failed" << std::endl;
        close(sock_fd);
        return 1;
    }
    std::cout << "Message sent" << std::endl;

    // 接收数据
    char buffer[1024] = {0};
    ssize_t bytes_received = recv(sock_fd, buffer, sizeof(buffer) - 1, 0);
    if (bytes_received < 0) {
        std::cerr << "Receive failed" << std::endl;
        close(sock_fd);
        return 1;
    }
    std::cout << "Message received: " << buffer << std::endl;

    // 关闭socket
    close(sock_fd);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59

在这个示例中,我们首先创建了一个TCP socket,然后设置了服务器的地址和端口,并尝试连接到服务器。一旦连接成功,我们使用send函数将一个字符串消息发送到服务器,消息数据从用户缓冲区(在这个例子中是message字符串)写入到TCP连接的发送缓冲区中。


接收数据时,我们使用recv函数从TCP连接的接收缓冲区读取数据到用户缓冲区(buffer数组)。如果recv函数成功,它返回接收到的字节数,我们将其打印出来。


最后,我们使用close函数关闭socket。

请注意,这个示例是一个阻塞的socket操作,sendrecv函数在数据发送或接收完成之前会阻塞。在实际的网络编程中,你可能需要处理更多的错误情况,并可能需要使用非阻塞socket或信号驱动I/O等技术来提高程序的响应性和性能。


(2)、管道

在Linux中,管道(pipe)是一种进程间通信(IPC)机制,允许一个进程(生产者)与另一个进程(消费者)通过一个缓冲区交换数据。管道是单向的,数据只能在一个方向上流动,并且通常用于父子进程或者兄弟进程之间的通信。

在这里插入图片描述


以下是演示管道通信的基本流程:

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <cerrno>
#include <cstring>

int main() {
    int pipefds[2];
    pid_t pid;
    const char *message = "Hello, this is the message going through the pipe!";
    char readbuffer[128];

    // 创建管道
    if (pipe(pipefds) == -1) {
        std::cerr << "Pipe failed: " << strerror(errno) << std::endl;
        return 1;
    }

    // 创建子进程
    pid = fork();
    if (pid == -1) {
        std::cerr << "Fork failed" << std::endl;
        close(pipefds[0]); // 读取端
        close(pipefds[1]); // 写入端
        return 1;
    }

    if (pid > 0) {
        // 父进程,关闭读取端,使用写入端
        close(pipefds[0]);

        // 写数据到管道
        if (write(pipefds[1], message, strlen(message)) == -1) {
            std::cerr << "Write to pipe failed: " << strerror(errno) << std::endl;
        }
        close(pipefds[1]); // 关闭写入端

        // 等待子进程结束
        wait(NULL);
    } else {
        // 子进程,关闭写入端,使用读取端
        close(pipefds[1]);

        // 从管道读取数据
        if (read(pipefds[0], readbuffer, sizeof(readbuffer)) == -1) {
            std::cerr << "Read from pipe failed: " << strerror(errno) << std::endl;
        }
        readbuffer[strcspn(readbuffer, "\n")] = 0; // 去除换行符
        std::cout << "Message received through pipe: " << readbuffer << std::endl;

        close(pipefds[0]); // 关闭读取端
    }

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

在这个示例中,我们首先使用pipe系统调用创建了一个管道,并获取了两个文件描述符:pipefds[0](用于读取)和pipefds[1](用于写入)。


然后,我们使用fork创建了一个子进程。

在父进程中,我们关闭了读取端(pipefds[0]),并通过写入端发送了一个字符串消息到管道。

在子进程中,我们关闭了写入端(pipefds[1]),并从读取端读取了管道中的数据。

请注意,管道的缓冲区大小通常是有限的,Linux中默认的管道缓冲区大小为65536字节。如果生产者写入的数据超过了缓冲区的大小,写入操作将会阻塞,直到消费者读取了足够的数据,释放了缓冲区空间。


此外,由于管道是单向的,所以通常需要两个管道来进行双向通信:一个用于从父进程到子进程的通信,另一个用于从子进程到父进程的通信。而且,管道是半双工的,意味着在任何给定时间,只能进行一个方向的通信。


(3)、FIFO


FIFO(也称为命名管道或具名管道)提供了一种在不相关的进程之间进行通信的方式,与管道类似,但具有文件系统中的名称。这意味着任何进程都可以通过FIFO的路径名来打开它,进行读写操作。

以下演示FIFO通信的基本流程:

#include <iostream>
#include <fcntl.h>    // 包含 open 函数
#include <unistd.h>   // 包含 read, write 函数
#include <sys/stat.h>// 包含 S_IRUSR, S_IWUSR, S_IRGRP, S_IWGRP, S_IROTH, S_IWOTH
#include <cstring>

// 创建FIFO
bool create_fifo(const char* fifo_name) {
    // 使用mkfifo创建FIFO
    if (mkfifo(fifo_name, 0666) == -1) { // 0666 表示读写权限给所有用户
        std::cerr << "Failed to create FIFO: " << strerror(errno) << std::endl;
        return false;
    }
    return true;
}

// 写入FIFO
bool write_fifo(const char* fifo_name, const char* message) {
    int fd = open(fifo_name, O_WRONLY);
    if (fd == -1) {
        std::cerr << "Failed to open FIFO for writing: " << strerror(errno) << std::endl;
        return false;
    }

    if (write(fd, message, strlen(message)) == -1) {
        std::cerr << "Failed to write to FIFO: " << strerror(errno) << std::endl;
        close(fd);
        return false;
    }

    close(fd);
    return true;
}

// 从FIFO读取
bool read_fifo(const char* fifo_name) {
    int fd = open(fifo_name, O_RDONLY);
    if (fd == -1) {
        std::cerr << "Failed to open FIFO for reading: " << strerror(errno) << std::endl;
        return false;
    }

    char buffer[1024];
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
    if (bytes_read == -1) {
        std::cerr << "Failed to read from FIFO: " << strerror(errno) << std::endl;
        close(fd);
        return false;
    }
    buffer[bytes_read] = '\0'; // 确保字符串以null结尾

    std::cout << "Message received from FIFO: " << buffer << std::endl;
    close(fd);
    return true;
}

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

    // 创建FIFO
    if (!create_fifo(fifo_name)) {
        return 1;
    }

    // 写入FIFO
    if (!write_fifo(fifo_name, "Hello, this is the message going through the FIFO!")) {
        return 1;
    }

    // 读取FIFO
    if (!read_fifo(fifo_name)) {
        return 1;
    }

    // 可以选择删除FIFO
    // unlink(fifo_name);

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79

在这个示例中,我们首先定义了三个函数:

  • create_fifo:创建一个FIFO。
  • write_fifo:向FIFO写入数据。
  • read_fifo:从FIFO读取数据。

main函数中,我们首先创建了一个FIFO,然后向其写入了一条消息,最后从FIFO中读取消息并打印出来。

请注意,FIFO是一个阻塞设备,如果打开FIFO进行读取但没有进程写入数据,读取操作将阻塞。同样,如果打开FIFO进行写入但没有进程读取数据,写入操作也将阻塞。为了处理这种情况,通常需要使用非阻塞打开或配合使用信号和多路复用技术(如selectpoll)。

此外,FIFO的权限可以通过mkfifo的第二个参数来设置,类似于文件的权限设置。在上面的示例中,我们使用了0666,这表示FIFO对所有用户都是可读可写的。在实际应用中,应根据需要设置适当的权限。


(4)、其他数据传输工具-消息队列和udp

消息队列和UDP(用户数据报协议)是两种不同的进程间通信(IPC)和网络通信机制。它们都通过将数据写入内核来进行操作,但是它们在数据传输的方式和特性上有所不同。

  • 消息队列

消息队列是UNIX系统提供的一种IPC机制,允许进程发送和接收消息。消息队列通过key来标识,进程可以通过这个key来发送和接收消息。


以下是消息队列的演示:

#include <iostream>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <cstring>

// 消息结构体
struct msgbuf {
    long mtype;
    char mtext[256];
};

int main() {
    key_t key = ftok("some_file", 'a');  // 创建唯一的key
    if (key == -1) {
        perror("ftok");
        return 1;
    }

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

    // 初始化消息
    msgbuf msg;
    msg.mtype = 1;
    strcpy(msg.mtext, "Hello, this is a message in the queue!");

    // 发送消息
    if (msgsnd(msgid, &msg, sizeof(msg.mtext), 0) == -1) {
        perror("msgsnd");
        msgctl(msgid, IPC_RMID, NULL);
        return 1;
    }

    // 接收消息
    msgrcv(msgid, &msg, sizeof(msg.mtext), msg.mtype, 0);
    std::cout << "Received message: " << msg.mtext << std::endl;

    // 删除消息队列
    if (msgctl(msgid, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        return 1;
    }

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

在上面的示例中,我们首先使用ftok函数创建一个唯一的key,然后使用msgget函数创建或获取一个消息队列。我们定义了一个msgbuf结构体来存储消息的类型和内容。然后,我们使用msgsnd函数发送消息,使用msgrcv函数接收消息。最后,我们使用msgctl函数删除消息队列。


  • UDP套接字

UDP是一种无连接的网络通信协议,它允许应用程序发送和接收数据报(datagrams)。UDP不保证数据报的顺序、完整性或可靠性,因此它通常用于那些可以容忍一定丢包率的应用,如视频会议或在线游戏。


以下代码演示UDP通信:

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
    int sockfd;
    struct sockaddr_in server_addr, client_addr;
    const char *message = "Hello, this is a UDP datagram!";
    char buffer[1024];

    // 创建UDP socket
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        perror("socket");
        return 1;
    }

    // 设置服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    // 发送数据
    if (sendto(sockfd, message, strlen(message), 0,
               (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("sendto");
        close(sockfd);
        return 1;
    }
    std::cout << "UDP datagram sent" << std::endl;

    // 接收数据
    socklen_t len = sizeof(client_addr);
    ssize_t bytes_received = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0,
                                      (struct sockaddr*)&client_addr, &len);
    if (bytes_received < 0) {
        perror("recvfrom");
        close(sockfd);
        return 1;
    }
    buffer[bytes_received] = '\0'; // 确保字符串以null结尾
    std::cout << "UDP datagram received: " << buffer << std::endl;

    // 关闭socket
    close(sockfd);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

在这个示例中,我们首先使用socket函数创建了一个UDP socket。然后,我们设置了服务器的地址和端口,并使用sendto函数发送了一个数据报。我们使用recvfrom函数接收了数据报,并打印了接收到的数据。最后,我们关闭了socket。

请注意,UDP是面向数据报的,每次发送和接收操作都是独立的,没有顺序或连接的概念。因此,每次写入和读取都是完整的一条消息,不能使用字节流的方式进行写入。


2、共享内存

共享内存是一种高效的进程间通信(IPC)机制,它允许两个或多个进程共享一个给定的存储区。由于共享内存允许进程直接访问同一块内存,因此它比管道、消息队列或套接字等其他IPC机制具有更高的性能。但是,共享内存需要适当的同步机制来避免竞态条件和数据不一致的问题。


以下是一个简单的示例,演示了如何使用共享内存和信号量来实现进程间的同步:

#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <cstring>

int main() {
    key_t key = ftok("some_file", 'a');
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    // 创建共享内存段
    int shm_id = shmget(key, sizeof(int), IPC_CREAT | 0666);
    if (shm_id < 0) {
        perror("shmget");
        return 1;
    }

    // 附加共享内存
    int *shared_mem = (int *)shmat(shm_id, NULL, 0);
    if (shared_mem == (void *)-1) {
        perror("shmat");
        return 1;
    }

    // 创建信号量
    int sem_id = semget(key, 1, IPC_CREAT | 0666);
    if (sem_id < 0) {
        perror("semget");
        return 1;
    }

    // 设置信号量的值
    if (semctl(sem_id, 0, SETVAL, 1) == -1) { // 初始值设为1
        perror("semctl SETVAL");
        return 1;
    }

    // 写入共享内存的进程
    *shared_mem = 42; // 写入数据

    // 等待信号量
    struct sembuf p_op = {sem_id, 0, -1};
    semop(sem_id, &p_op, 1);

    // 执行其他任务...

    // 通知信号量
    struct sembuf v_op = {sem_id, 0, 1};
    semop(sem_id, &v_op, 1);

    // 从共享内存分离
    if (shmdt(shared_mem) == -1) {
        perror("shmdt");
        return 1;
    }

    // 删除共享内存和信号量
    if (shmctl(shm_id, IPC_RMID, NULL) == -1) {
        perror("shmctl IPC_RMID");
        return 1;
    }
    if (semctl(sem_id, 0, IPC_RMID) == -1) {
        perror("semctl IPC_RMID");
        return 1;
    }

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71

在这个示例中,我们首先使用ftok函数创建一个唯一的key,然后使用shmget函数创建一个共享内存段。我们使用shmat函数将共享内存附加到当前进程的地址空间,并将其映射到一个int指针上。

接着,我们使用semget函数创建一个信号量集,并使用semctl函数将其初始值设置为1。我们定义了两个信号量操作:p_op用于等待(P操作),v_op用于通知(V操作)。

在写入共享内存之前,我们执行了P操作,这会等待信号量的值为正。写入完成后,我们执行了V操作,这会增加信号量的值,允许其他进程访问共享内存。

最后,我们使用shmdt函数从共享内存分离,使用shmctlsemctl函数分别删除共享内存段和信号量集。

请注意,这个示例仅演示了单个进程中共享内存和信号量的使用。在实际的多进程环境中,你需要创建多个进程,并在它们之间同步对共享内存的访问。通常,这是通过在父进程中创建共享内存和信号量,然后在子进程中附加共享内存和操作信号量来实现的。


三、同步机制:规避惊心动魄


1、信号量

信号量(Semaphore)是一种同步机制,用于控制多个进程或线程对共享资源的访问。本质上就是内核维护的一个整数,其值永远不会小于
0。如果 一个进程试图将信号量的值减少至小于
0,那么内核会阻塞该操作,直到信号量增长到允许执行该操作的程度。


通常我们会使用一个二元信号量,也就是信号量的值要么是
0,要么是
1。此时非常类似于
mutex,mutex 的状态要么是已上锁,要么是未上锁 。


在C++中,可以使用 POSIX 线程库(pthread)提供的信号量功能。以下是使用二元信号量(也称为互斥锁,mutex)的一个简单示例:

#include <iostream>
#include <pthread.h>
#include <semaphore.h>

// 创建一个信号量对象
sem_t sem;

// 线程函数,尝试对共享资源进行操作
void* thread_function(void* arg) {
    // 等待(P操作)信号量,直到信号量的值大于0
    sem_wait(&sem);

    // 临界区开始
    std::cout << "Thread " << std::this_thread::get_id()
              << " is in the critical section." << std::endl;

    // ... 执行对共享资源的操作 ...

    // 临界区结束
    // 通知(V操作)信号量,增加其值
    sem_post(&sem);

    return nullptr;
}

int main() {
    // 初始化信号量,设置其值为1
    sem_init(&sem, 0, 1);

    // 创建线程
    pthread_t t1, t2;
    pthread_create(&t1, NULL, thread_function, NULL);
    pthread_create(&t2, NULL, thread_function, NULL);

    // 等待线程结束
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    // 销毁信号量
    sem_destroy(&sem);

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

在这个示例中,我们首先使用sem_init函数初始化了一个信号量sem,其初始值为1。然后创建了两个线程t1t2,它们都尝试执行thread_function函数。

thread_function函数中,我们首先调用sem_wait函数来执行P操作,这会阻塞线程直到信号量的值大于0。一旦信号量的值大于0,sem_wait函数会减少信号量的值,然后线程可以进入临界区。在临界区内,线程可以安全地访问共享资源。

当线程完成对共享资源的访问后,它会调用sem_post函数来执行V操作,这会增加信号量的值,允许其他等待的线程进入临界区。

最后,在main函数中,我们等待所有线程结束,然后使用sem_destroy函数销毁信号量。

请注意,这个示例演示了如何使用信号量来同步两个线程对共享资源的访问。在实际应用中,信号量可以用于更复杂的同步场景,包括跨进程同步。此外,使用信号量时需要小心,以避免死锁和其他同步问题。


2、文件锁

文件锁是一种用于进程间同步的机制,它通过锁定文件的特定部分来实现。在UNIX和类UNIX系统中,文件锁通常通过fcntl函数来管理。

文件锁分为两种类型:

  • 读锁(共享锁):允许多个进程读取文件,但不能写入。

  • 写锁(互斥锁):只允许一个进程写入文件,其他进程不能读取也不能写入。

文件锁是自动释放的,当进程终止或完成对文件的访问时,内核会自动移除锁。

以下是使用C++演示文件锁的基本流程:

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

int main() {
    const char* filename = "example.txt";

    // 创建或打开文件
    int fd = open(filename, O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    // 锁定文件
    struct flock lock;
    memset(&lock, 0, sizeof(lock));
    lock.l_type = F_WRLCK; // 请求写锁
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0; // 0表示锁定整个文件

    // 使用fcntl尝试锁定文件
    if (fcntl(fd, F_SETLKW, &lock) == -1) {
        perror("fcntl F_SETLKW");
        close(fd);
        return 1;
    }

    // 临界区开始:文件已被锁定,可以安全写入
    std::cout << "File is locked for writing." << std::endl;

    // 执行写操作...
    // write(fd, "data", 4);

    // 临界区结束:解锁文件
    lock.l_type = F_UNLCK; // 请求解锁
    if (fcntl(fd, F_SETLK, &lock) == -1) {
        perror("fcntl F_SETLK");
    }

    close(fd); // 关闭文件描述符
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

在上述代码中,我们首先使用open函数打开或创建一个文件,并获取文件描述符fd。然后,我们设置了struct flock结构体来定义锁的参数,包括锁的类型(读锁或写锁)、起始位置、长度等。


我们使用fcntl函数与F_SETLKW命令来请求锁。F_SETLKW命令会阻塞调用进程,直到锁被成功设置。一旦获得锁,我们就可以安全地执行文件的写入操作。

完成操作后,我们将锁的类型设置为F_UNLCK,再次使用fcntl函数与F_SETLK命令来释放锁。


请注意,文件锁的行为可能会受到操作系统和文件系统的影响。在某些系统中,文件锁可能不是强制性的,这意味着其他进程可能能够忽略这些锁。在使用文件锁时,务必要确保正确地请求和释放锁,以避免死锁或资源泄露。


3、信号 (Signal)


我们还可以利用信号(Signal)在进程间传递消息,比如父进程通过信号通知子进程其已退出。不过,信号应用于IPC的情况并不常见,主要有以下两方面原因:

  • 信号遵循可靠传递原则,不会排队,可能会丢失;
  • 信号携带的信息量有限,不太适合传输大量数据。

因此,信号更多被用作进程间的"小纸条",告知对方发生了某些事件,具体数据传输还需要借助其他IPC工具。


需要详细了解信号 相关知识的通讯,请查阅往期文章:


四、结语


总的来说,选择IPC工具时需要考虑通信双方、数据量、同步需求等多方面因素,合理权衡就能找到最佳选择。这个领域学习曲线平缓,但内功修炼到极致,却又别有一番天地。你是否已跃跃欲试,迫不及待想投身到IPC的海洋中?本文仅作了简单探讨,若想彻底掌握该领域的精髓,不妨持续关注我们的后续分享。


声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家小花儿/article/detail/685353
推荐阅读
相关标签
  

闽ICP备14008679号