IPC（进程间通信），是 Linux 系统中不同进程间进行数据交换的机制。主要包括
- 管道（Pipe）：主要用于父子进程通信，分为匿名管道和命名管道（FIFO）两种。
- 信号（Signal）：一种异步通信方式，用于通知接收信号的进程某个事件已经发生。
- 消息队列（Message Queue）：一种队列结构，可以存储要发送的消息。Linux 提供了 System V 和 POSIX 两种消息队列。
- 共享内存（Shared Memory）：最快的 IPC 机制，允许多个进程共享一段内存区域。Linux 同样提供了 System V 和 POSIX 两种共享内存。
- 信号量（Semaphore）：主要用于同步和互斥，防止多个进程同时访问共享资源。Linux 提供了 System V 和 POSIX 两种信号量。
- 套接字（Socket）：可以用于不同机器之间的进程通信，也可以用于同一机器上的进程通信（Unix Domain Socket）。
这些 IPC 机制各有优缺点，选择哪种机制取决于具体的应用需求。例如，如果需要跨网络通信，那么套接字可能是最好的选择。如果需要高速通信，那么共享内存可能是最好的选择。如果只是简单的父子进程通信，那么管道可能就足够了。
例如在常用在命令行环境中的 |，就是匿名管道，它能够将一个命令的输出作为另一个命令的输入，从而使两个命令能够协同工作，如ls -l | grep "txt"、cat file.txt | wc -l。
管道
在 Linux 系统中，管道通常是匿名的，这意味着他们没有在文件系统中显示的路径，而是通过在内核中创建的特殊文件描述符来实现。
创建匿名管道（Anonymous Pipes），需使用系统调用 int pipe(int fd[2]) ，这里表示创建一个匿名管道，并返回两个描述符。一个是管道的读取端描述符fd[0]，另一个是写入端描述符fd[1]。匿名管道是特殊的文件，只存在于内存，不存在于文件系统中。
这里需要注意的是，在某个进程创建匿名管道，该管道的两个描述符在同一进程中，如何起到跨进程通信的作用？
实际上，匿名管道用于具具有亲缘关系的进程之间的通信，当我们在父进程中调用 fork() 系统调用创建子进程并需要父子进程通信时，父进程和子进程可以通过共享的文件描述符进行通信。
一般情况下，父进程关闭管道的读取端，子进程关闭管道的写入端。这样，父进程只写入，子进程只读取，避免了同时写或同时读的情况。
通信完成后，父子进程应该关闭不再需要的文件描述符。关闭管道的写入端（读取端）会导致对应读取端（写入端）收到一个文件结束符，这样读取操作就会返回 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
|
//匿名管道示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define BUFFER_SIZE 25
#define READ_END 0
#define WRITE_END 1
int main() {
char write_msg[BUFFER_SIZE] = "Hello, pipe!";
char read_msg[BUFFER_SIZE];
int fd[2];
pid_t pid;
// 创建管道
if (pipe(fd) == -1) {
fprintf(stderr, "Pipe failed");
return 1;
}
// 创建子进程
pid = fork();
if (pid < 0) {
fprintf(stderr, "Fork failed");
return 1;
}
if (pid > 0) { // 父进程
close(fd[READ_END]); // 关闭读取端
// 写入数据到管道
write(fd[WRITE_END], write_msg, strlen(write_msg) + 1);
close(fd[WRITE_END]); // 关闭写入端
printf("Parent process wrote to the pipe: %s\n", write_msg);
} else { // 子进程
close(fd[WRITE_END]); // 关闭写入端
// 从管道中读取数据
read(fd[READ_END], read_msg, BUFFER_SIZE);
printf("Child process read from the pipe: %s\n", read_msg);
close(fd[READ_END]); // 关闭读取端
}
return 0;
}
|
对于命名管道（Named Pipes，或 FIFOs），它是一种具有名称的特殊文件，存储在文件系统中，可以通过文件系统路径进行访问，允许无关进程之间进行通信，通过 mkfifo 命令或 mkfifo() 函数创建。
一个进程可以向命名管道中写入数据，另一个进程可以从命名管道中读取数据。其读写操作和普通文件的读写操作类似，可以使用文件 I/O 函数（opoen()/read()//write()/close()）来进行。
命名管道区别于匿名管道的主要特征在于持久性，即使创建它的进程终止，命名管道仍然存在于文件系统中，直到显示地被删除。
所谓管道，其实就是内核里面的一串缓存。
当进程向管道写入数据时，内核会将数据缓存到管道的内部缓冲区。如果管道的缓冲区已满，写入操作会被阻塞，直到有足够的空间可以写入数据。类似的，当进程从管道读取数据时，内核会从管道的内部缓冲区中读取数据，并将其提供给进程。如果管道的缓冲区为空，读取操作会被阻塞，直到有数据可供读取。
管道的读写操作通常会涉及到进程的同步和通知机制。内核需要保证在多个进程同时访问管道时，数据的读写操作是安全和正确的。为了实现进程的同步和通知，Linux 内核可能会使用信号量、锁或者其它同步机制来保护管道的读写操作，以确保数据的一致性和正确性。
因此，管道这种通信方式效率低，不适合进程间频繁地交换数据。
总的来说，管道作为一种基本的进程间通信机制，在使用时虽然简单方便，但也存在一些弊端，主要体现在：
- 单向通信：这意味着如果需要双向通信，需要创建两个管道，增加复杂度和开销；
- 容量限制：管道有一个固定容量限制，一般取决于操作系统的设置。一旦缓冲区达到容量上限，写入操作将被阻塞，可能导致进程间通信的延迟或死锁；
- 阻塞式读写：管道空或满时，读写操作会被阻塞，这可能导致进程被挂起，降低系统的响应速度；
- 没有数据完整性保证：管道进提供数据流传输，对完整性和可靠性没有保证，通常需要在应用层面实现额外的机制，如校验和、确认应答等；
- 无法在网络上使用：管道只能在同一台主机的进程间通信，无法用于网络通信。
消息队列
对于更高效、频繁传递数据的场景，可以选择使用消息队列。一般在 Linux 中，消息队列是保存在内核中的消息链表。
数据传输单位是用户自定义的数据，收发双方需要在传输前约定好消息体的数据类型，每个消息体都是固定大小的存储块，不像管道是无格式的字节流数据。
生命周期跟随系统内核，如果没有主动释放消息队列或没有关闭操作系统，消息队列会一直存在。
虽然消息队列可以便捷地在进程间传递数据，但它不适合大数据传输，因为在内核中每个消息体都有一个最大长度限制，同时所有队列所包含的全部消息体的总长度也有上限。内核中有两个宏定义，MSGMAX 和 MSGMNB，以字节为单位，分别定义了一条消息的最大长度和一个队列的最大长度。
另外在运行效率上，通信过程存在用户态和内核态之间的数据拷贝开销，因为进程写入数据到内核中的消息队列时，会发生从用户态拷贝数据到内核态的过程，反之亦然。
因此，基于以上两点，消息队列更适合应用于小规模、低频率数据传输，比如任务队列（每个消息代表一个待处理的任务）、日志数据、状态更新、请求响应、数据流（数据在多个进程之间流式传输，每个消息包含流的一部分）等。
主要应用场景：
- 异步处理：消息队列可以用于实现异步处理，这样一来，一个进程可以将任务放入队列中，然后立即返回，而不需要等待任务完成。这对于需要长时间运行的任务特别有用，例如大数据计算或复杂的文件操作。
- 负载均衡：如果有大量的任务需要处理，可以使用消息队列来分发这些任务。每个工作进程可以从队列中取出一个任务，处理它，然后再取出下一个任务。这样可以确保所有的工作进程都保持忙碌，而且可以根据需要添加更多的工作进程。
- 解耦：消息队列可以用于解耦系统的不同部分。这意味着一个部分的改变不会直接影响到其他部分。例如，一个服务可以发布消息到队列，而不需要知道哪些消费者会接收和处理这些消息。
- 容错：如果处理消息的进程失败，消息可以留在队列中，然后由另一个进程重新处理。这可以提高系统的可靠性。
- 日志记录：消息队列可以用于收集系统的日志信息。应用程序可以将日志消息发送到队列，然后由专门的日志服务从队列中读取和处理这些消息。
消息队列的常用系统调用接口：mq_open() / mq_send() / mq_receive() / mq_close() / mq_unlink()
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
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <mqueue.h>
#define QUEUE_NAME "/my_message_queue"
#define MAX_MSG_SIZE 256
#define MAX_MSG_COUNT 10
int main() {
mqd_t mq;
struct mq_attr attr;
char buffer[MAX_MSG_SIZE + 1];
int msg_flags = O_CREAT | O_RDWR;
mode_t mode = S_IRUSR | S_IWUSR; // Permissions for the message queue
// Set up the attributes of the message queue
attr.mq_maxmsg = MAX_MSG_COUNT;
attr.mq_msgsize = MAX_MSG_SIZE;
attr.mq_flags = 0;
// Create the message queue
mq = mq_open(QUEUE_NAME, msg_flags, mode, &attr);
if (mq == (mqd_t)-1) {
perror("mq_open");
exit(1);
}
printf("Message queue created.\n");
// Send a message to the queue
printf("Enter message to send: ");
fgets(buffer, MAX_MSG_SIZE, stdin);
if (mq_send(mq, buffer, strlen(buffer), 0) == -1) {
perror("mq_send");
exit(1);
}
printf("Message sent.\n");
// Receive a message from the queue
ssize_t bytes_read = mq_receive(mq, buffer, MAX_MSG_SIZE, NULL);
if (bytes_read == -1) {
perror("mq_receive");
exit(1);
}
buffer[bytes_read] = '\0';
printf("Received message: %s\n", buffer);
// Close the message queue
mq_close(mq);
// Remove the message queue
mq_unlink(QUEUE_NAME);
return 0;
}
|
共享内存
现代操作系统的内存管理，采用虚拟内存技术，即每个进程有自己独立的虚拟内存空间，不同进程的虚拟内存映射到不同的物理内存中。所以，即使进程 A 和进程 B 的虚拟地址一样，其访问的物理内存地址也是不同的，对于数据的增删改查互不影响。
而共享内存则是将相同的虚拟地址空间映射到同一的物理内存中，以实现不同进程在同一内存区域共同增删改查，从而无需拷贝、无需进行用户态内核态切换，大大提升了 IPC 速度，且相对于消息队列而言，其传递数据的大小仅受限于系统的物理内存大小，处理大数据的能力远大于消息队列。常用于数据库系统、图像处理和科学计算等。
使用共享内存作为 IPC 方式，需要重点关注同步和安全问题。多个进程同时访问共享内存可能导致数据不一致，因此需要使用同步机制（如信号量）来确保数据一致性。另外，任何可以访问共享内存的进程都可以修改数据，容易导致安全问题（如意外或恶意篡改）。因此在创建共享内存时，可以通过设置权限进行访问控制，读写数据时进行适当的完整性校验，以增强安全性。
这里提供一个简单示例，首先是创建和向共享内存写数据的进程：
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
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <semaphore.h>
int main()
{
const int SIZE = 4096;
const char *name = "OS";
const char *message_0 = "Hello";
const char *message_1 = "World!";
const char *sem_name = "sem";
int shm_fd;
void *ptr;
sem_t *sem;
/* 创建共享内存对象 */
shm_fd = shm_open(name, O_CREAT | O_RDWR, 0666);
if (shm_fd == -1) {
perror("In shm_open");
exit(1);
}
/* 配置共享内存对象的大小 */
if (ftruncate(shm_fd, SIZE) == -1) {
perror("In ftruncate");
exit(1);
}
/* 将共享内存对象映射到内存 */
ptr = mmap(0, SIZE, PROT_WRITE, MAP_SHARED, shm_fd, 0);
if (ptr == MAP_FAILED) {
perror("In mmap");
exit(1);
}
/* 创建信号量 */
sem = sem_open(sem_name, O_CREAT, 0666, 0);
if (sem == SEM_FAILED) {
perror("In sem_open");
exit(1);
}
/* 将数据写入共享内存对象 */
sprintf(ptr, "%s", message_0);
ptr += strlen(message_0);
sprintf(ptr, "%s", message_1);
ptr += strlen(message_1);
/* 通过信号量通知其他进程可以读取数据 */
if (sem_post(sem) == -1) {
perror("In sem_post");
exit(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
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <semaphore.h>
int main()
{
const int SIZE = 4096;
const char *name = "OS";
const char *sem_name = "sem";
int shm_fd;
void *ptr;
sem_t *sem;
/* 打开共享内存对象 */
shm_fd = shm_open(name, O_RDONLY, 0666);
if (shm_fd == -1) {
perror("In shm_open");
exit(1);
}
/* 将共享内存对象映射到内存 */
ptr = mmap(0, SIZE, PROT_READ, MAP_SHARED, shm_fd, 0);
if (ptr == MAP_FAILED) {
perror("In mmap");
exit(1);
}
/* 打开信号量 */
sem = sem_open(sem_name, 0);
if (sem == SEM_FAILED) {
perror("In sem_open");
exit(1);
}
/* 等待信号量 */
if (sem_wait(sem) == -1) {
perror("In sem_wait");
exit(1);
}
/* 从共享内存中读取数据 */
printf("%s\n", (char *)ptr);
/* 删除共享内存对象 */
if (shm_unlink(name) == -1) {
perror("In shm_unlink");
exit(1);
}
/* 删除信号量 */
if (sem_unlink(sem_name) == -1) {
perror("In sem_unlink");
exit(1);
}
return 0;
}
|
在这个示例中，使用了一个信号量来同步两个进程的操作。写入进程在写入数据后通过信号量通知读取进程可以读取数据。读取进程在读取数据前等待信号量。另外，添加了一些错误处理和安全性检查，例如检查 shm_open、ftruncate、mmap、sem_open、sem_post、sem_wait、shm_unlink 和 sem_unlink 的返回值，并在出错时打印错误消息并退出。
这里可以明显看出，相较于前两种 IPC 机制，要想获得更高的效率，就要关注更多的细节，这里有几个要点需要关注：
- 同步访问：当多个进程访问共享内存时，必须使用某种同步机制（如信号量或互斥锁）来确保数据的一致性和完整性。
- 清理共享内存：当所有进程都不再需要共享内存时，应该删除它以释放系统资源。在 Linux 中，可以使用
shmctl 函数（对于 System V 共享内存）或 shm_unlink 函数（对于 POSIX 共享内存）来删除共享内存。
- 错误处理：在使用共享内存的过程中，应该检查所有可能的错误条件，并适当地处理错误。
- 避免使用过大的共享内存区域：虽然共享内存是一种高效的 IPC 机制，但是使用过大的共享内存区域可能会消耗大量的系统资源，并可能导致性能问题。
- 使用适当的数据结构：在共享内存中，应该使用适合并发访问的数据结构。例如，如果多个进程需要同时读写一个数据结构，那么应该使用一个可以支持并发访问的数据结构，如链表或哈希表。
- 避免使用指针：在共享内存中，不应该使用指向非共享内存区域的指针，因为这些指针在其他进程中可能无效。
- 安全性：共享内存可以被任何具有适当权限的进程访问，因此应该考虑数据的安全性。如果需要，可以使用加密和解密机制来保护数据。
信号量
在上面的示例代码中，除了共享内存，还引入了另一种 IPC 机制，信号量（Semaphore），以解决共享内存的访问同步问题。
信号量其实是一个整形的计数器，主要用于实现进程间的互斥与同步，而不是用于缓存进程间通信的数据。
其在 Linux 内核中的定义为：
1
2
3
4
5
|
struct semaphore {
raw_spinlock_t lock;
unsigned int count;
struct list_head wait_list;
};
|
其中：
lock 是一个原始的自旋锁，用于保护信号量的数据结构。count 是信号量的当前值。当一个进程调用 down 或 sem_wait 函数试图获取信号量时，如果 count 大于 0，那么 count 将减 1，进程将继续执行。如果 count 等于 0，那么进程将被阻塞，直到 count 变为非 0.wait_list 是一个链表，包含了所有等待这个信号量的进程。
控制信号量的方式有两种原子操作，P 操作和 V 操作。
- P 操作，也被称为 ”wait” 或 “down” 操作。当一个进程需要访问共享资源时，它会执行 P 操作，在 P 操作中，信号量的值会减 1。
- V 操作，也被称为 “signal” 或 ”up“ 操作。当一个进程完成对共享资源的访问后，它会执行 V 操作，在 V 操作中，信号量的值会加 1。
P 操作和 V 操作这两种术语源自荷兰语，P 操作来自 “Proberen”，意为“尝试”，V 操作来自 “Verhogen”， 意为“增加“。
原子操作是指在多线程环境中，一个不可被中断的操作，也就是说这个操作要么完全执行，要么完全不执行，不会出现执行一半的情况。在执行过程中，不会被其他线程打断。
前面我们提到，信号量相当于一个计数器，当信号量被初始化为 1 时，先到来的 P 操作进程先占用资源，后来的 P 操作都得阻塞等待，保证共享内存在任何时刻只有一个进程在访问，此时的信号量是作为互斥信号量。
如果初始化为 0 呢？
通常在多进程里，每个进程各自独立运行，先后顺序不可知，当我们希望多个进程能合作实现一个任务时，可以将信号量初始化为 0。例如，进程 A 是数据生产者，进程 B 是数据消费者，显然 B 依赖 A，此时若 B 比 A 先执行，当其执行到 P 操作时，由于信号量为 0，B 阻塞，直到 A 执行了 V 操作，相当于唤醒了阻塞在 P 操作的 B 进程，此时的信号量是作为同步信号量，保证进程 A 的 V 操作先于进程 B 的 P 操作执行。
这是经典的生产者-消费者问题，也是信号量比较常见的应用场景。
比较常用的信号量操作如sem_init()/sem_wait()/sem_post()/sem_destroy()等，可以在semaphore.h头文件中找到，这里做个简单记录：
int sem_init(sem_t *sem, int pshared, unsigned int value);：
- 初始化一个新的信号量。
sem：指向要初始化的信号量的指针。pshared：指定信号量的共享性质，如果为 0 则表示信号量是进程内共享，非 0 值表示信号量是在进程之间共享的（通常用于线程间通信）。value：指定信号量的初始值。
int sem_wait(sem_t *sem);：
- 等待信号量，如果信号量的值大于 0，则将其减一；如果信号量的值为 0，则阻塞直到信号量的值大于 0。
sem：指向待操作的信号量的指针。
int sem_post(sem_t *sem);：
- 释放信号量，将信号量的值加一。
sem：指向待操作的信号量的指针。
int sem_destroy(sem_t *sem);：
- 销毁信号量，释放信号量相关的资源。
sem：指向待销毁的信号量的指针。
使用信号量时有两个要注意的点，一是注意处理各种边界条件以防死锁，二是确保使用完后及时释放信号量避免资源泄露。以如下代码为例
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
|
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define BUFFER_SIZE 5
sem_t mutex, empty, full;
int buffer[BUFFER_SIZE];
int in = 0, out = 0;
void *producer(void *arg) {
int item = 0;
while (1) {
item = rand() % 100;
sem_wait(&empty);
sem_wait(&mutex);
buffer[in] = item;
printf("Produced item: %d\n", item);
in = (in + 1) % BUFFER_SIZE;
sem_post(&mutex);
sem_post(&full);
// Sleep for random time
sleep(rand() % 3);
}
}
void *consumer(void *arg) {
int item = 0;
while (1) {
sem_wait(&full);
sem_wait(&mutex);
item = buffer[out];
printf("Consumed item: %d\n", item);
out = (out + 1) % BUFFER_SIZE;
sem_post(&mutex);
sem_post(&empty);
// Sleep for random time
sleep(rand() % 3);
}
}
int main() {
// Initialize semaphores
sem_init(&mutex, 0, 1);
sem_init(&empty, 0, BUFFER_SIZE);
sem_init(&full, 0, 0);
// Create producer and consumer threads
pthread_t producer_thread, consumer_thread;
pthread_create(&producer_thread, NULL, producer, NULL);
pthread_create(&consumer_thread, NULL, consumer, NULL);
// Join threads
pthread_join(producer_thread, NULL);
pthread_join(consumer_thread, NULL);
// Destroy semaphores
sem_destroy(&mutex);
sem_destroy(&empty);
sem_destroy(&full);
return 0;
}
|
在这个示例中，边界条件主要涉及到缓冲区的使用和信号量的初始值设置。
- 缓冲区边界：
- 在生产者往缓冲区写入数据时，需要确保缓冲区不会溢出，即当
in指针超出缓冲区边界时，将其置为 0，实现循环缓冲。
- 在消费者从缓冲区读取数据时，需要确保缓冲区不会读取到无效数据，即当
out指针超出缓冲区边界时，将其置为 0，实现循环缓冲。
- 信号量初始值：
empty信号量的初始值应该等于缓冲区的大小，表示缓冲区中可用的空闲位置数量。full信号量的初始值应该为 0，表示缓冲区中已经存放的数据数量。
通过正确处理这些边界条件，可以确保生产者和消费者线程在访问共享资源（即缓冲区）时不会发生溢出或越界的情况，保证程序的正确性和稳定性。
信号
以上 IPC 机制，主要用于程序正常运行时，在程序异常时，就需要另一种 IPC 机制–信号，来进行跨进程通信。
信号允许一个进程向另一个进程发送通知，告诉对方某个事件已经发生或请求执行某个操作。信号是一种轻量级通信方式，常用于实现进程的异步事件处理、进程间同步和异常处理等。
信号有如下四种基本特性：
- 编号：每个信号都有一个唯一的编号，通常用整数表示，例如 SIGINT 表示中断信号。
- 发送：一个进程可以通过调用
kill()函数向另一个进程发送信号，或者在终端键入特定的终端控制字符（比如 Ctrl+C 发送 SIGINT 信号）。
- 处理：接收到信号的进程可以选择忽略信号、执行默认操作或者注册信号处理函数。
- 异步：信号是异步事件，即发送信号的进程和接收信号的进程之间没有直接的通信通道。
常见的系统信号（部分信号在不同的系统上可能有所不同）：
- SIGINT：中断信号，通常由用户按下 Ctrl+C 发送，用于中断进程。
- SIGTERM：终止信号，用于请求进程正常终止。
- SIGKILL：强制终止信号，用于立即终止进程。
- SIGUSR1和SIGUSR2：用户定义的信号，可以由应用程序自定义使用。
- SIGSEGV：段错误信号，表示进程访问了无效的内存地址。
- SIGCHLD：子进程状态改变信号，用于通知父进程子进程的状态改变。
对于每个信号，操作系统都定义了默认的处理方式，比如终止进程或者忽略信号。不过进程可以为特定信号注册自定义的信号处理函数，当接收到该信号时，执行相应的处理逻辑。另外，可以通过设置信号屏蔽来暂时阻塞某些信号，以避免在关键时刻被中断。信号的操作以轻、快为主，其处理函数要尽量保持简单和安全，避免调用不可重入函数、执行复杂或阻塞的操作。
基本使用方式如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
void signal_handler(int signum) {
printf("Received signal: %d\n", signum);
}
int main() {
// 注册信号处理函数
signal(SIGINT, signal_handler); // Ctrl+C中断信号
signal(SIGTERM, signal_handler); // 终止信号
// 进入无限循环等待信号
while(1) {
sleep(1);
}
return 0;
}
|
Socket
前面五中 IPC 机制都是在同一台主机上进行进程间通信，而 Socket 可以实现跨网络、跨主机的进程间通信，当然它也可以用于同主机的进程间通信。而在前面介绍的 IPC 机制中，在进程间通信时都是通过 PID 来唯一标识进程，在跨主机的情况下，Socket 该如何唯一标识一个进程？
Socket 表面上是一个 Linux 文件系统的特殊文件，一组 API，实际上它还是 TCP/IP 协议族的应用层抽象。借助 TCP/IP，可以通过网络层的 IP 地址唯一标识网络中的主机，通过传输层的协议和端口唯一标识主机中的进程。IP+协议+端口，便是 Socket 唯一标识一个进程的方式。
Socket API 的调用流程受创建 Socket 时选择的通信类型影响，这是创建 socket 的系统调用：
int socket(int domain, int type, int protocal)
domain：指定地址族，常见的有AF_INET（IPv4 地址族）和AF_INET6（IPv6 地址族）等。type：指定 Socket 的类型，常见的有SOCK_STREAM（流式 Socket，用于 TCP）和SOCK_DGRAM（数据报 Socket，用于 UDP）等。protocol：指定协议，通常为 0 表示使用默认协议。
当创建的 socket 类型为 TCP 时，服务端需要监听 socket 以等待连接请求，在客户端发来连接请求时，双方需要进行三次握手，连接成功后会创建一个新的 socket 用于与客户端通信，而后进行正式的数据传输。以下是一个简单的 TCP Socket 示例，包括一个简单的服务器端和一个客户端，演示了如何建立 TCP 连接并进行数据传输：
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
|
//tcp_server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int addrlen = sizeof(address);
char buffer[BUFFER_SIZE] = {0};
char *welcome_message = "Welcome to the server!";
// 创建TCP Socket
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}
// 绑定地址和端口
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror("bind failed");
exit(EXIT_FAILURE);
}
// 监听连接
if (listen(server_fd, 3) < 0) {
perror("listen");
exit(EXIT_FAILURE);
}
// 等待连接
if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
perror("accept");
exit(EXIT_FAILURE);
}
// 发送欢迎消息给客户端
send(new_socket, welcome_message, strlen(welcome_message), 0);
printf("Welcome message sent to client\n");
// 接收客户端消息并回复
int valread;
if ((valread = read(new_socket, buffer, BUFFER_SIZE)) > 0) {
printf("Client: %s\n", buffer);
send(new_socket, buffer, strlen(buffer), 0);
}
printf("Closing connection...\n");
close(new_socket);
close(server_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
|
//tcp_client.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
int sock = 0, valread;
struct sockaddr_in serv_addr;
char buffer[BUFFER_SIZE] = {0};
char *message = "Hello from client";
// 创建TCP Socket
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket creation error");
exit(EXIT_FAILURE);
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
// 将IP地址转换为网络字节序
if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) {
perror("Invalid address/ Address not supported");
exit(EXIT_FAILURE);
}
// 连接服务器
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
perror("Connection failed");
exit(EXIT_FAILURE);
}
// 发送消息给服务器
send(sock, message, strlen(message), 0);
printf("Message sent to server\n");
// 接收服务器的回复
valread = read(sock, buffer, BUFFER_SIZE);
printf("Server: %s\n",buffer);
close(sock);
return 0;
}
|
在 TCP Socket 通信的过程中，数据的可靠传输是由 TCP 协议来保证的，它会确保数据的顺序交付和可靠性。因此，在使用 TCP Socket 进行通信时，无需过多考虑数据的丢失和顺序问题，只需要关注如何正确地发送和接收数据即可。
当创建的 socket 类型为 UDP 时，与 TCP 不同，UDP 不会事先建立连接（也就是不握手），也不维护连接的状态信息，这就导致每个数据包都是独立的，发送和接收都是无状态的。而相应的这种机制也造就了其低延迟高效率的优势，适用于对数据传输实时性要求较高的场景。以下是一个简单的 UDP Socket 示例，包括一个服务器端和一个客户端，演示了如何使用 UDP Socket 进行通信：
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
|
//udp_server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
int sockfd;
struct sockaddr_in servaddr, cliaddr;
char buffer[BUFFER_SIZE];
// 创建UDP Socket
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
memset(&cliaddr, 0, sizeof(cliaddr));
// 设置服务器地址信息
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(PORT);
// 将Socket绑定到地址和端口上
if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("bind failed");
exit(EXIT_FAILURE);
}
int len, n;
len = sizeof(cliaddr);
while (1) {
// 接收数据
n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, MSG_WAITALL, (struct sockaddr *)&cliaddr, &len);
buffer[n] = '\0';
printf("Client : %s\n", buffer);
// 发送数据
sendto(sockfd, (const char *)buffer, strlen(buffer), MSG_CONFIRM, (const struct sockaddr *)&cliaddr, len);
printf("Message sent to client.\n");
}
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
|
//udp_client.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
int sockfd;
struct sockaddr_in servaddr;
char buffer[BUFFER_SIZE];
char *message = "Hello from client";
// 创建UDP Socket
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
// 设置服务器地址信息
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
servaddr.sin_addr.s_addr = INADDR_ANY;
int n, len;
len = sizeof(servaddr);
// 发送数据
sendto(sockfd, (const char *)message, strlen(message), MSG_CONFIRM, (const struct sockaddr *)&servaddr, len);
printf("Message sent to server.\n");
// 接收回复
n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, MSG_WAITALL, (struct sockaddr *)&servaddr, &len);
buffer[n] = '\0';
printf("Server : %s\n", buffer);
close(sockfd);
return 0;
}
|
POSIX & System V
POSIX (Portable Operating System Interface) 和 System V 是两种不同的 Unix 标准。它们在很多方面都有所不同，包括它们提供的进程间通信（IPC）机制。
以下是它们在 IPC 方面的一些主要区别：
- 消息队列：System V 提供了
msgget，msgsnd，msgrcv 和 msgctl 系统调用来操作消息队列。而 POSIX 提供了 mq_open，mq_send，mq_receive，mq_close 和 mq_unlink 函数来操作消息队列。POSIX 消息队列支持优先级，而 System V 消息队列支持消息类型。
- 信号量：System V 提供了
semget，semop 和 semctl 系统调用来操作信号量。而 POSIX 提供了 sem_open，sem_wait，sem_post，sem_close 和 sem_unlink 函数来操作信号量。POSIX 信号量可以在进程间或线程间使用，而 System V 信号量主要用于进程间。
- 共享内存：System V 提供了
shmget，shmat，shmdt 和 shmctl 系统调用来操作共享内存。而 POSIX 提供了 shm_open，mmap，munmap，shm_unlink 函数来操作共享内存。
- 命名和生命周期：System V IPC 对象通过 key 和 id 来标识，需要显式删除，否则会一直存在。而 POSIX IPC 对象通过名字来标识，可以设置自动删除，当最后一个引用关闭后，对象会被自动删除。
- 接口：POSIX 的接口通常更简单，更易于使用，而 System V 的接口则更复杂，提供了更多的选项和功能。
至于选择哪种类型的 IPC 机制，主要取决于具体的应用需求和开发者的偏好。
一般情况下，我们可能会偏向于选择 POSIX IPC 机制，主要原因在于：
- 接口一致性：POSIX IPC 机制的接口在不同的 Unix-like 系统（包括 Linux）之间保持一致，这有助于提高代码的可移植性。
- 更现代的特性：相比于 System V，POSIX IPC 机制提供了一些更现代的特性，例如更好的线程支持、更灵活的命名机制以及更好的资源管理等。
然而，这并不意味着 System V IPC 机制没有用武之地。在一些特定的场景下，System V IPC 机制可能会是更好的选择，例如：
- 更丰富的功能：System V IPC 机制提供了一些 POSIX IPC 机制所不具备的功能，例如消息队列中的消息类型、信号量操作的原子性等。
- 更广泛的兼容性：由于 System V IPC 机制的历史更为悠久，因此它在一些较旧的系统中可能会得到更好的支持。
总的来说，Linux 系统并没有默认采取 POSIX 还是 System V，而是提供了这两种 IPC 机制供开发者根据具体的需求和偏好进行选择。