linux进程间通讯指南-打通IPC大门,高效沟通无阻_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操作，send和recv函数在数据发送或接收完成之前会阻塞。在实际的网络编程中，你可能需要处理更多的错误情况，并可能需要使用非阻塞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进行写入但没有进程读取数据，写入操作也将阻塞。为了处理这种情况，通常需要使用非阻塞打开或配合使用信号和多路复用技术（如select或poll）。

此外，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函数从共享内存分离，使用shmctl和semctl函数分别删除共享内存段和信号量集。

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

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

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。然后创建了两个线程t1和t2，它们都尝试执行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工具。

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

• Linux信号大揭秘-从中断到控制进程，一步步掌握进程通信利器!
• linux信号集与信号掩码-保护信号处理程序，确保进程正确运行
• linux进程家族-管理子进程，确保进程族稳健运行

四、结语

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