管道

匿名管道

概述

• 半双工通信，只能在有亲缘关系的进程间使用

• 适用场景: 父子进程间通信

xxxxxxxxxx
2
1
#include <unistd.h>
2
int pipe(int pipefd[2]);

参数说明：

• pipefd[2]: 文件描述符数组

  • pipefd[0]: 读端

  • pipefd[1]: 写端

返回值：

• 成功返回0

• 失败返回-1，并设置errno

相关函数

xxxxxxxxxx
4
1
#include <unistd.h>
2
ssize_t read(int fd, void *buf, size_t count);
3
ssize_t write(int fd, const void *buf, size_t count);
4
int close(int fd);

示例

​x
1
#include <iostream>
2
#include <unistd.h>
3
#include <sys/wait.h>
4
#include <string.h>
5

6
using namespace std;
7

8
int main() {
9
    int pipefd[2];
10
    pid_t pid;
11
    char buffer[1024];
12
    
13
    // 创建管道
14
    if (pipe(pipefd) == -1) {
15
        perror("pipe创建失败");
16
        return -1;
17
    }
18
    
19
    cout << "管道创建成功" << endl;
20
    cout << "读端文件描述符: " << pipefd[0] << endl;
21
    cout << "写端文件描述符: " << pipefd[1] << endl;
22
    
23
    // 创建子进程
24
    pid = fork();
25
    
26
    if (pid == -1) {
27
        perror("fork失败");
28
        return -1;
29
    }
30
    
31
    if (pid == 0) {
32
        // 子进程：读取数据
33
        cout << "子进程启动，PID: " << getpid() << endl;
34
        
35
        // 关闭写端
36
        close(pipefd[1]);
37
        
38
        // 从管道读取数据
39
        while (true) {
40
            memset(buffer, 0, sizeof(buffer));
41
            ssize_t bytes_read = read(pipefd[0], buffer, sizeof(buffer) - 1);
42
            
43
            if (bytes_read > 0) {
44
                buffer[bytes_read] = '\0';
45
                cout << "子进程收到: " << buffer << endl;
46
                
47
                // 如果收到"quit"则退出
48
                if (strcmp(buffer, "quit") == 0) {
49
                    break;
50
                }
51
            } else if (bytes_read == 0) {
52
                cout << "管道写端已关闭" << endl;
53
                break;
54
            } else {
55
                perror("读取失败");
56
                break;
57
            }
58
        }
59
        
60
        close(pipefd[0]);
61
        cout << "子进程结束" << endl;
62
        
63
    } else {
64
        // 父进程：发送数据
65
        cout << "父进程启动，PID: " << getpid() << endl;
66
        cout << "子进程PID: " << pid << endl;
67
        
68
        // 关闭读端
69
        close(pipefd[0]);
70
        
71
        // 向管道写入数据
72
        string messages[] = {
73
            "Hello from parent!",
74
            "This is message 1",
75
            "This is message 2",
76
            "quit"
77
        };
78
        
79
        for (const string& msg : messages) {
80
            cout << "父进程发送: " << msg << endl;
81
            write(pipefd[1], msg.c_str(), msg.length());
82
            sleep(1); // 延时1秒
83
        }
84
        
85
        close(pipefd[1]);
86
        
87
        // 等待子进程结束
88
        int status;
89
        wait(&status);
90
        cout << "父进程结束" << endl;
91
    }
92
    
93
    return 0;
94
}

命名管道

概述

• 可以在无亲缘关系的进程间使用

• 适用场景: 不相关进程间的单向通信

xxxxxxxxxx
2
1
#include <sys/stat.h>
2
int mkfifo(const char *pathname, mode_t mode);

参数说明：

• pathname: FIFO文件路径

• mode: 文件权限（如0666）

返回值：

• 成功返回0

• 失败返回-1，并设置errno

相关函数

xxxxxxxxxx
3
1
#include <fcntl.h>
2
int open(const char *pathname, int flags);
3
int open(const char *pathname, int flags, mode_t mode);

常用flags：

• O_RDONLY: 只读模式

• O_WRONLY: 只写模式

• O_RDWR: 读写模式

• O_NONBLOCK: 非阻塞模式

示例

xxxxxxxxxx
60
1
#include <iostream>
2
#include <fcntl.h>
3
#include <sys/stat.h>
4
#include <unistd.h>
5
#include <string.h>
6

7
using namespace std;
8

9
const char* FIFO_PATH = "/tmp/my_fifo";
10

11
int main() {
12
    int fd;
13
    
14
    // 创建命名管道
15
    if (mkfifo(FIFO_PATH, 0666) == -1) {
16
        perror("mkfifo失败");
17
        // 如果文件已存在，继续执行
18
        if (errno != EEXIST) {
19
            return -1;
20
        }
21
    }
22
    
23
    cout << "命名管道创建成功: " << FIFO_PATH << endl;
24
    
25
    // 以写模式打开FIFO
26
    cout << "等待读进程连接..." << endl;
27
    fd = open(FIFO_PATH, O_WRONLY);
28
    if (fd == -1) {
29
        perror("打开FIFO失败");
30
        return -1;
31
    }
32
    
33
    cout << "读进程已连接，开始发送数据" << endl;
34
    
35
    // 发送消息
36
    string messages[] = {
37
        "Hello from writer process!",
38
        "Message 1: FIFO communication",
39
        "Message 2: Inter-process communication",
40
        "Message 3: Named pipe example",
41
        "quit"
42
    };
43
    
44
    for (const string& msg : messages) {
45
        cout << "发送: " << msg << endl;
46
        
47
        ssize_t bytes_written = write(fd, msg.c_str(), msg.length());
48
        if (bytes_written == -1) {
49
            perror("写入失败");
50
            break;
51
        }
52
        
53
        sleep(2); // 延时2秒
54
    }
55
    
56
    close(fd);
57
    cout << "写进程结束" << endl;
58
    
59
    return 0;
60
}

示例代码：读进程

xxxxxxxxxx
68
1
#include <iostream>
2
#include <fcntl.h>
3
#include <sys/stat.h>
4
#include <unistd.h>
5
#include <string.h>
6

7
using namespace std;
8

9
const char* FIFO_PATH = "/tmp/my_fifo";
10

11
int main() {
12
    int fd;
13
    char buffer[1024];
14
    
15
    cout << "读进程启动，PID: " << getpid() << endl;
16
    
17
    // 检查FIFO是否存在
18
    struct stat st;
19
    if (stat(FIFO_PATH, &st) != 0) {
20
        cout << "FIFO不存在，请先运行写进程" << endl;
21
        return -1;
22
    }
23
    
24
    // 以读模式打开FIFO
25
    cout << "打开FIFO: " << FIFO_PATH << endl;
26
    fd = open(FIFO_PATH, O_RDONLY);
27
    if (fd == -1) {
28
        perror("打开FIFO失败");
29
        return -1;
30
    }
31
    
32
    cout << "FIFO打开成功，等待数据..." << endl;
33
    
34
    // 读取数据
35
    while (true) {
36
        memset(buffer, 0, sizeof(buffer));
37
        ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
38
        
39
        if (bytes_read > 0) {
40
            buffer[bytes_read] = '\0';
41
            cout << "收到: " << buffer << endl;
42
            
43
            // 如果收到"quit"则退出
44
            if (strcmp(buffer, "quit") == 0) {
45
                break;
46
            }
47
        } else if (bytes_read == 0) {
48
            cout << "写进程已关闭连接" << endl;
49
            break;
50
        } else {
51
            perror("读取失败");
52
            break;
53
        }
54
    }
55
    
56
    close(fd);
57
    
58
    // 删除FIFO文件
59
    if (unlink(FIFO_PATH) == -1) {
60
        perror("删除FIFO失败");
61
    } else {
62
        cout << "FIFO文件已删除" << endl;
63
    }
64
    
65
    cout << "读进程结束" << endl;
66
    
67
    return 0;
68
}

信号

概述

• 异步通信机制，用于通知进程发生了某个事件，信号是软件中断，可以在任何时候发送给进程，进程必须告诉内核如何处理每一种信号

• 适用场景: 简单的事件通知，如进程终止、用户中断等

• 限制: 只能传递信号类型，无法传递复杂数据

常用信号类型

常用函数

1.signal() 函数

xxxxxxxxxx
3
1
#include <signal.h>
2
typedef void (*sighandler_t)(int);
3
sighandler_t signal(int signum, sighandler_t handler);

参数说明：

• signum: 信号编号

• handler: 信号处理函数指针，可以是：

  • 自定义函数指针

  • SIG_DFL: 默认处理

  • SIG_IGN: 忽略信号

返回值：

• 成功：返回之前的信号处理函数

• 失败：返回SIG_ERR

2. sigaction() 函数

xxxxxxxxxx
10
1
#include <signal.h>
2
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
3

4
struct sigaction {
5
    void (*sa_handler)(int);           // 信号处理函数
6
    void (*sa_sigaction)(int, siginfo_t *, void *); // 扩展处理函数
7
    sigset_t sa_mask;                  // 信号屏蔽集
8
    int sa_flags;                      // 标志位
9
    void (*sa_restorer)(void);         // 已废弃
10
};

参数说明：

• signum: 信号编号

• act: 新的信号处理方式

• oldact: 保存原来的信号处理方式

3. kill() 函数

xxxxxxxxxx
2
1
#include <signal.h>
2
int kill(pid_t pid, int sig);

参数说明：

• pid: 目标进程ID

  • > 0: 发送给指定进程

  • = 0: 发送给同组所有进程

  • = -1: 发送给所有有权限的进程

  • < -1: 发送给进程组|-pid|

• sig: 信号编号

4. raise() 函数

xxxxxxxxxx
2
1
#include <signal.h>
2
int raise(int sig);

功能： 向当前进程发送信号，等价于kill(getpid(), sig)

示例

xxxxxxxxxx
118
1
#include <iostream>
2
#include <signal.h>
3
#include <unistd.h>
4
#include <sys/wait.h>
5
#include <string.h>
6

7
using namespace std;
8

9
// 全局变量用于进程间通信
10
volatile sig_atomic_t message_count = 0;
11
volatile sig_atomic_t should_exit = 0;
12

13
// 父进程信号处理函数
14
void parent_handler(int sig) {
15
    switch(sig) {
16
        case SIGUSR1:
17
            message_count++;
18
            cout << "父进程收到子进程消息 #" << message_count << endl;
19
            break;
20
        case SIGUSR2:
21
            cout << "父进程收到子进程完成信号" << endl;
22
            should_exit = 1;
23
            break;
24
        case SIGCHLD:
25
            cout << "子进程状态改变" << endl;
26
            break;
27
    }
28
}
29

30
// 子进程信号处理函数
31
void child_handler(int sig) {
32
    switch(sig) {
33
        case SIGUSR1:
34
            cout << "子进程收到父进程指令" << endl;
35
            break;
36
        case SIGTERM:
37
            cout << "子进程收到终止信号" << endl;
38
            exit(0);
39
            break;
40
    }
41
}
42

43
int main() {
44
    pid_t pid;
45
    
46
    cout << "进程间信号通信示例" << endl;
47
    
48
    // 创建子进程
49
    pid = fork();
50
    
51
    if (pid == -1) {
52
        perror("fork失败");
53
        return -1;
54
    }
55
    
56
    if (pid == 0) {
57
        // 子进程
58
        cout << "子进程启动，PID: " << getpid() << endl;
59
        cout << "父进程PID: " << getppid() << endl;
60
        
61
        // 注册信号处理函数
62
        signal(SIGUSR1, child_handler);
63
        signal(SIGTERM, child_handler);
64
        
65
        // 子进程工作循环
66
        for(int i = 1; i <= 5; i++) {
67
            sleep(2);
68
            cout << "子进程工作步骤 " << i << "/5" << endl;
69
            
70
            // 向父进程发送进度信号
71
            kill(getppid(), SIGUSR1);
72
        }
73
        
74
        // 工作完成，通知父进程
75
        cout << "子进程工作完成" << endl;
76
        kill(getppid(), SIGUSR2);
77
        
78
        // 等待父进程指令
79
        while(true) {
80
            sleep(1);
81
        }
82
        
83
    } else {
84
        // 父进程
85
        cout << "父进程启动，PID: " << getpid() << endl;
86
        cout << "子进程PID: " << pid << endl;
87
        
88
        // 注册信号处理函数
89
        signal(SIGUSR1, parent_handler);
90
        signal(SIGUSR2, parent_handler);
91
        signal(SIGCHLD, parent_handler);
92
        
93
        // 等待子进程完成工作
94
        cout << "等待子进程完成工作..." << endl;
95
        
96
        while(!should_exit) {
97
            sleep(1);
98
        }
99
        
100
        cout << "总共收到 " << message_count << " 个进度消息" << endl;
101
        
102
        // 向子进程发送指令
103
        cout << "向子进程发送指令" << endl;
104
        kill(pid, SIGUSR1);
105
        sleep(1);
106
        
107
        // 终止子进程
108
        cout << "终止子进程" << endl;
109
        kill(pid, SIGTERM);
110
        
111
        // 等待子进程结束
112
        int status;
113
        wait(&status);
114
        cout << "子进程已结束，状态: " << status << endl;
115
    }
116
    
117
    return 0;
118
}

消息队列

消息队列是一种重要的进程间通信机制，允许进程通过消息进行异步通信。Linux提供了两种消息队列实现：System V消息队列和POSIX消息队列。

消息队列提供了可靠的异步通信机制，特别适合生产者-消费者模式的应用场景。

System V消息队列

• 特点: 消息有类型，支持优先级

常用函数

1. msgget() - 创建或获取消息队列

   xxxxxxxxxx
   1
   1
   int msgget(key_t key, int msgflg);
   

   • key: 消息队列的键值（通常使用ftok()生成）

   • msgflg: 权限标志和创建标志

   • 返回值: 消息队列标识符

2. msgsnd() - 发送消息

   xxxxxxxxxx
   1
   1
   int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
   

   • msqid: 消息队列标识符

   • msgp: 指向消息结构的指针

   • msgsz: 消息数据的大小

   • msgflg: 控制标志

3. msgrcv() - 接收消息

   xxxxxxxxxx
   1
   1
   ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
   

   • msgtyp: 消息类型（0表示接收任意类型）

4. msgctl() - 控制消息队列

   xxxxxxxxxx
   1
   1
   int msgctl(int msqid, int cmd, struct msqid_ds *buf);
   

   • cmd: 控制命令（如IPC_RMID删除队列）

示例

发送端:

xxxxxxxxxx
48
1
#include <iostream>
2
#include <sys/msg.h>
3
#include <sys/ipc.h>
4
#include <cstring>
5
#include <unistd.h>
6

7
// 消息结构体
8
struct Message {
9
    long msg_type;      // 消息类型，必须大于0
10
    char msg_text[256]; // 消息内容
11
};
12

13
int main() {
14
    // 生成唯一键值
15
    key_t key = ftok("/tmp", 'A');
16
    if (key == -1) {
17
        perror("ftok failed");
18
        return 1;
19
    }
20

21
    // 创建或获取消息队列
22
    int msgid = msgget(key, IPC_CREAT | 0666);
23
    if (msgid == -1) {
24
        perror("msgget failed");
25
        return 1;
26
    }
27

28
    std::cout << "System V消息队列创建成功，ID: " << msgid << std::endl;
29

30
    Message msg;
31
    for (int i = 1; i <= 5; ++i) {
32
        msg.msg_type = i % 3 + 1;  // 消息类型1-3
33
        snprintf(msg.msg_text, sizeof(msg.msg_text), 
34
                "消息 %d，类型 %ld，PID: %d", i, msg.msg_type, getpid());
35

36
        // 发送消息
37
        if (msgsnd(msgid, &msg, strlen(msg.msg_text) + 1, 0) == -1) {
38
            perror("msgsnd failed");
39
            continue;
40
        }
41

42
        std::cout << "发送: " << msg.msg_text << std::endl;
43
        sleep(1);
44
    }
45

46
    std::cout << "所有消息发送完成" << std::endl;
47
    return 0;
48
}

接收端:

xxxxxxxxxx
66
1
#include <iostream>
2
#include <sys/msg.h>
3
#include <sys/ipc.h>
4
#include <cstring>
5
#include <signal.h>
6

7
struct Message {
8
    long msg_type;
9
    char msg_text[256];
10
};
11

12
int msgid;
13
bool running = true;
14

15
void cleanup(int sig) {
16
    std::cout << "\n正在清理资源..." << std::endl;
17
    
18
    // 删除消息队列
19
    if (msgctl(msgid, IPC_RMID, nullptr) == -1) {
20
        perror("msgctl IPC_RMID failed");
21
    } else {
22
        std::cout << "消息队列已删除" << std::endl;
23
    }
24
    
25
    running = false;
26
}
27

28
int main() {
29
    // 设置信号处理
30
    signal(SIGINT, cleanup);
31
    signal(SIGTERM, cleanup);
32

33
    // 获取消息队列
34
    key_t key = ftok("/tmp", 'A');
35
    if (key == -1) {
36
        perror("ftok failed");
37
        return 1;
38
    }
39

40
    msgid = msgget(key, 0666);
41
    if (msgid == -1) {
42
        perror("msgget failed");
43
        return 1;
44
    }
45

46
    std::cout << "连接到消息队列，ID: " << msgid << std::endl;
47
    std::cout << "等待消息... (Ctrl+C退出)" << std::endl;
48

49
    Message msg;
50
    while (running) {
51
        // 接收任意类型的消息
52
        ssize_t bytes = msgrcv(msgid, &msg, sizeof(msg.msg_text), 0, IPC_NOWAIT);
53
        
54
        if (bytes > 0) {
55
            std::cout << "接收到消息 [类型 " << msg.msg_type << "]: " 
56
                      << msg.msg_text << std::endl;
57
        } else if (bytes == -1 && errno != ENOMSG) {
58
            perror("msgrcv failed");
59
            break;
60
        }
61
        
62
        usleep(100000);  // 100ms
63
    }
64

65
    return 0;
66
}

POSIX消息队列

特点: 更现代的接口，支持异步通知

常用函数

1. mq_open() - 打开或创建消息队列

   xxxxxxxxxx
   1
   1
   mqd_t mq_open(const char *name, int oflag, mode_t mode, struct mq_attr *attr);
   

   • name: 消息队列名称（以"/"开头）

   • oflag: 打开标志（O_RDONLY, O_WRONLY, O_RDWR等）

2. mq_send() - 发送消息

   xxxxxxxxxx
   1
   1
   int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio);
   

   • msg_prio: 消息优先级（0-31，数值越大优先级越高）

3. mq_receive() - 接收消息

   xxxxxxxxxx
   1
   1
   ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio);
   

4. mq_close() - 关闭消息队列

   xxxxxxxxxx
   1
   1
   int mq_close(mqd_t mqdes);
   

5. mq_unlink() - 删除消息队列

   xxxxxxxxxx
   1
   1
   int mq_unlink(const char *name);
   

示例

发送端:

xxxxxxxxxx
49
1
#include <iostream>
2
#include <mqueue.h>
3
#include <fcntl.h>
4
#include <sys/stat.h>
5
#include <cstring>
6
#include <unistd.h>
7

8
int main() {
9
    const char* queue_name = "/test_queue";
10
    
11
    // 设置消息队列属性
12
    struct mq_attr attr;
13
    attr.mq_flags = 0;
14
    attr.mq_maxmsg = 10;    // 最大消息数
15
    attr.mq_msgsize = 256;  // 最大消息大小
16
    attr.mq_curmsgs = 0;
17

18
    // 创建或打开消息队列
19
    mqd_t mq = mq_open(queue_name, O_CREAT | O_WRONLY, 0644, &attr);
20
    if (mq == (mqd_t)-1) {
21
        perror("mq_open failed");
22
        return 1;
23
    }
24

25
    std::cout << "POSIX消息队列创建成功" << std::endl;
26

27
    // 发送不同优先级的消息
28
    for (int i = 1; i <= 5; ++i) {
29
        char message[256];
30
        unsigned int priority = i % 3;  // 优先级0-2
31
        
32
        snprintf(message, sizeof(message), 
33
                "POSIX消息 %d，优先级 %u，PID: %d", i, priority, getpid());
34

35
        if (mq_send(mq, message, strlen(message) + 1, priority) == -1) {
36
            perror("mq_send failed");
37
            continue;
38
        }
39

40
        std::cout << "发送: " << message << " [优先级: " << priority << "]" << std::endl;
41
        sleep(1);
42
    }
43

44
    // 关闭消息队列
45
    mq_close(mq);
46
    std::cout << "所有消息发送完成" << std::endl;
47
    
48
    return 0;
49
}

接收端:

xxxxxxxxxx
71
1
#include <iostream>
2
#include <mqueue.h>
3
#include <fcntl.h>
4
#include <signal.h>
5
#include <cstring>
6

7
const char* queue_name = "/test_queue";
8
mqd_t mq;
9
bool running = true;
10

11
void cleanup(int sig) {
12
    std::cout << "\n正在清理资源..." << std::endl;
13
    
14
    // 关闭并删除消息队列
15
    mq_close(mq);
16
    if (mq_unlink(queue_name) == -1) {
17
        perror("mq_unlink failed");
18
    } else {
19
        std::cout << "消息队列已删除" << std::endl;
20
    }
21
    
22
    running = false;
23
}
24

25
int main() {
26
    // 设置信号处理
27
    signal(SIGINT, cleanup);
28
    signal(SIGTERM, cleanup);
29

30
    // 打开消息队列
31
    mq = mq_open(queue_name, O_RDONLY);
32
    if (mq == (mqd_t)-1) {
33
        perror("mq_open failed");
34
        return 1;
35
    }
36

37
    // 获取队列属性
38
    struct mq_attr attr;
39
    if (mq_getattr(mq, &attr) == -1) {
40
        perror("mq_getattr failed");
41
        return 1;
42
    }
43

44
    std::cout << "连接到POSIX消息队列" << std::endl;
45
    std::cout << "最大消息数: " << attr.mq_maxmsg << std::endl;
46
    std::cout << "最大消息大小: " << attr.mq_msgsize << std::endl;
47
    std::cout << "等待消息... (Ctrl+C退出)" << std::endl;
48

49
    char buffer[attr.mq_msgsize];
50
    unsigned int priority;
51
    
52
    while (running) {
53
        // 设置超时时间
54
        struct timespec timeout;
55
        clock_gettime(CLOCK_REALTIME, &timeout);
56
        timeout.tv_sec += 1;  // 1秒超时
57

58
        ssize_t bytes = mq_timedreceive(mq, buffer, attr.mq_msgsize, &priority, &timeout);
59
        
60
        if (bytes > 0) {
61
            buffer[bytes] = '\0';
62
            std::cout << "接收到消息 [优先级 " << priority << "]: " 
63
                      << buffer << std::endl;
64
        } else if (bytes == -1 && errno != ETIMEDOUT) {
65
            perror("mq_timedreceive failed");
66
            break;
67
        }
68
    }
69

70
    return 0;
71
}

共享内存

共享内存是最快的进程间通信方式，允许多个进程直接访问同一块物理内存区域。

System V共享内存

常用函数

1. shmget() - 创建或获取共享内存段

   xxxxxxxxxx
   1
   1
   int shmget(key_t key, size_t size, int shmflg);
   

   • key: 共享内存的键值（通常使用ftok()生成）

   • size: 共享内存段的大小（字节）

   • shmflg: 权限标志和创建标志

   • 返回值: 共享内存标识符

2. shmat() - 连接共享内存段到进程地址空间

   xxxxxxxxxx
   1
   1
   void *shmat(int shmid, const void *shmaddr, int shmflg);
   

   • shmid: 共享内存标识符

   • shmaddr: 指定连接地址（通常为NULL，让系统选择）

   • shmflg: 连接标志（如SHM_RDONLY只读）

   • 返回值: 共享内存段的起始地址

3. shmdt() - 断开共享内存段连接

   xxxxxxxxxx
   1
   1
   int shmdt(const void *shmaddr);
   

   • shmaddr: 要断开的共享内存地址

4. shmctl() - 控制共享内存段

   xxxxxxxxxx
   1
   1
   int shmctl(int shmid, int cmd, struct shmid_ds *buf);
   

   • cmd: 控制命令（如IPC_RMID删除共享内存）

示例

写进程:

xxxxxxxxxx
104
1
#include <iostream>
2
#include <sys/shm.h>
3
#include <sys/ipc.h>
4
#include <cstring>
5
#include <unistd.h>
6
#include <signal.h>
7

8
// 共享数据结构
9
struct SharedData {
10
    int counter;
11
    char message[256];
12
    bool ready;
13
    bool finished;
14
};
15

16
int shmid;
17
SharedData* shared_data;
18

19
void cleanup(int sig) {
20
    std::cout << "\n正在清理资源..." << std::endl;
21
    
22
    if (shared_data) {
23
        shared_data->finished = true;
24
        shmdt(shared_data);
25
    }
26
    
27
    // 删除共享内存
28
    if (shmctl(shmid, IPC_RMID, nullptr) == -1) {
29
        perror("shmctl IPC_RMID failed");
30
    } else {
31
        std::cout << "共享内存已删除" << std::endl;
32
    }
33
    
34
    exit(0);
35
}
36

37
int main() {
38
    // 设置信号处理
39
    signal(SIGINT, cleanup);
40
    signal(SIGTERM, cleanup);
41

42
    // 生成唯一键值
43
    key_t key = ftok("/tmp", 'S');
44
    if (key == -1) {
45
        perror("ftok failed");
46
        return 1;
47
    }
48

49
    // 创建共享内存段
50
    shmid = shmget(key, sizeof(SharedData), IPC_CREAT | 0666);
51
    if (shmid == -1) {
52
        perror("shmget failed");
53
        return 1;
54
    }
55

56
    // 连接共享内存
57
    shared_data = (SharedData*)shmat(shmid, nullptr, 0);
58
    if (shared_data == (SharedData*)-1) {
59
        perror("shmat failed");
60
        return 1;
61
    }
62

63
    std::cout << "System V共享内存创建成功，ID: " << shmid << std::endl;
64
    std::cout << "共享内存地址: " << shared_data << std::endl;
65

66
    // 初始化共享数据
67
    shared_data->counter = 0;
68
    shared_data->ready = false;
69
    shared_data->finished = false;
70
    strcpy(shared_data->message, "初始化消息");
71

72
    // 写入数据
73
    for (int i = 1; i <= 10; ++i) {
74
        shared_data->counter = i;
75
        snprintf(shared_data->message, sizeof(shared_data->message),
76
                "写进程消息 %d，PID: %d", i, getpid());
77
        shared_data->ready = true;
78

79
        std::cout << "写入: counter=" << shared_data->counter 
80
                  << ", message=" << shared_data->message << std::endl;
81
        
82
        sleep(2);
83
        
84
        // 等待读进程处理
85
        while (shared_data->ready && !shared_data->finished) {
86
            usleep(100000);  // 100ms
87
        }
88
        
89
        if (shared_data->finished) {
90
            break;
91
        }
92
    }
93

94
    shared_data->finished = true;
95
    std::cout << "写进程完成" << std::endl;
96
    
97
    // 保持程序运行，等待手动清理
98
    std::cout << "按Ctrl+C退出并清理资源" << std::endl;
99
    while (true) {
100
        sleep(1);
101
    }
102

103
    return 0;
104
}

读进程:

xxxxxxxxxx
70
1
#include <iostream>
2
#include <sys/shm.h>
3
#include <sys/ipc.h>
4
#include <unistd.h>
5
#include <signal.h>
6

7
struct SharedData {
8
    int counter;
9
    char message[256];
10
    bool ready;
11
    bool finished;
12
};
13

14
SharedData* shared_data;
15
bool running = true;
16

17
void cleanup(int sig) {
18
    std::cout << "\n读进程退出" << std::endl;
19
    if (shared_data) {
20
        shmdt(shared_data);
21
    }
22
    running = false;
23
}
24

25
int main() {
26
    signal(SIGINT, cleanup);
27
    signal(SIGTERM, cleanup);
28

29
    // 获取共享内存
30
    key_t key = ftok("/tmp", 'S');
31
    if (key == -1) {
32
        perror("ftok failed");
33
        return 1;
34
    }
35

36
    int shmid = shmget(key, sizeof(SharedData), 0666);
37
    if (shmid == -1) {
38
        perror("shmget failed - 请先运行写进程");
39
        return 1;
40
    }
41

42
    // 连接共享内存
43
    shared_data = (SharedData*)shmat(shmid, nullptr, 0);
44
    if (shared_data == (SharedData*)-1) {
45
        perror("shmat failed");
46
        return 1;
47
    }
48

49
    std::cout << "连接到共享内存，ID: " << shmid << std::endl;
50
    std::cout << "共享内存地址: " << shared_data << std::endl;
51
    std::cout << "等待数据... (Ctrl+C退出)" << std::endl;
52

53
    int last_counter = -1;
54
    
55
    while (running && !shared_data->finished) {
56
        if (shared_data->ready && shared_data->counter != last_counter) {
57
            std::cout << "读取: counter=" << shared_data->counter 
58
                      << ", message=" << shared_data->message << std::endl;
59
            
60
            last_counter = shared_data->counter;
61
            shared_data->ready = false;  // 标记已处理
62
        }
63
        
64
        usleep(100000);  // 100ms
65
    }
66

67
    std::cout << "读进程完成" << std::endl;
68
    shmdt(shared_data);
69
    return 0;
70
}

POSIX共享内存

• 特点: 基于文件系统，更易使用

常用函数

1. shm_open() - 创建或打开共享内存对象

   xxxxxxxxxx
   1
   1
   int shm_open(const char *name, int oflag, mode_t mode);
   

   • name: 共享内存对象名称（以"/"开头）

   • oflag: 打开标志（O_CREAT, O_RDWR等）

   • mode: 权限模式

   • 返回值: 文件描述符

2. ftruncate() - 设置共享内存对象大小

   xxxxxxxxxx
   1
   1
   int ftruncate(int fd, off_t length);
   

3. mmap() - 将共享内存映射到进程地址空间

   xxxxxxxxxx
   1
   1
   void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
   

   • prot: 内存保护标志（PROT_READ, PROT_WRITE等）

   • flags: 映射标志（MAP_SHARED等）

4. munmap() - 取消内存映射

   xxxxxxxxxx
   1
   1
   int munmap(void *addr, size_t length);
   

5. shm_unlink() - 删除共享内存对象

   xxxxxxxxxx
   1
   1
   int shm_unlink(const char *name);
   

示例

写进程:

xxxxxxxxxx
114
1
#include <iostream>
2
#include <sys/mman.h>
3
#include <sys/stat.h>
4
#include <fcntl.h>
5
#include <unistd.h>
6
#include <cstring>
7
#include <signal.h>
8
#include <semaphore.h>
9

10
struct SharedData {
11
    int counter;
12
    char message[256];
13
    bool finished;
14
};
15

16
const char* shm_name = "/posix_shared_memory";
17
const char* sem_name = "/posix_semaphore";
18
int shm_fd;
19
SharedData* shared_data;
20
sem_t* semaphore;
21

22
void cleanup(int sig) {
23
    std::cout << "\n正在清理资源..." << std::endl;
24
    
25
    if (shared_data) {
26
        shared_data->finished = true;
27
        munmap(shared_data, sizeof(SharedData));
28
    }
29
    
30
    if (shm_fd != -1) {
31
        close(shm_fd);
32
    }
33
    
34
    // 删除共享内存和信号量
35
    shm_unlink(shm_name);
36
    sem_close(semaphore);
37
    sem_unlink(sem_name);
38
    
39
    std::cout << "POSIX共享内存和信号量已删除" << std::endl;
40
    exit(0);
41
}
42

43
int main() {
44
    signal(SIGINT, cleanup);
45
    signal(SIGTERM, cleanup);
46

47
    // 创建信号量用于同步
48
    semaphore = sem_open(sem_name, O_CREAT, 0644, 1);
49
    if (semaphore == SEM_FAILED) {
50
        perror("sem_open failed");
51
        return 1;
52
    }
53

54
    // 创建共享内存对象
55
    shm_fd = shm_open(shm_name, O_CREAT | O_RDWR, 0644);
56
    if (shm_fd == -1) {
57
        perror("shm_open failed");
58
        return 1;
59
    }
60

61
    // 设置共享内存大小
62
    if (ftruncate(shm_fd, sizeof(SharedData)) == -1) {
63
        perror("ftruncate failed");
64
        return 1;
65
    }
66

67
    // 映射共享内存
68
    shared_data = (SharedData*)mmap(nullptr, sizeof(SharedData),
69
                                   PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
70
    if (shared_data == MAP_FAILED) {
71
        perror("mmap failed");
72
        return 1;
73
    }
74

75
    std::cout << "POSIX共享内存创建成功" << std::endl;
76
    std::cout << "共享内存地址: " << shared_data << std::endl;
77

78
    // 初始化共享数据
79
    shared_data->counter = 0;
80
    shared_data->finished = false;
81
    strcpy(shared_data->message, "POSIX初始化消息");
82

83
    // 写入数据
84
    for (int i = 1; i <= 10; ++i) {
85
        // 获取信号量
86
        sem_wait(semaphore);
87
        
88
        shared_data->counter = i;
89
        snprintf(shared_data->message, sizeof(shared_data->message),
90
                "POSIX写进程消息 %d，PID: %d", i, getpid());
91

92
        std::cout << "写入: counter=" << shared_data->counter 
93
                  << ", message=" << shared_data->message << std::endl;
94
        
95
        // 释放信号量
96
        sem_post(semaphore);
97
        
98
        sleep(2);
99
        
100
        if (shared_data->finished) {
101
            break;
102
        }
103
    }
104

105
    shared_data->finished = true;
106
    std::cout << "写进程完成，按Ctrl+C退出并清理资源" << std::endl;
107
    
108
    // 保持程序运行
109
    while (true) {
110
        sleep(1);
111
    }
112

113
    return 0;
114
}