// 主进程
static void process_A(int shared_memory_id, int message_queue_id, int semaphore_id)
{
shm_data *shared_memory = (shm_data *)shmat(shared_memory_id, NULL, 0);
msg_form message;
size_t total_data_sent = 0;
int send_count = 0; // 发送轮次
time_t start_time = time(NULL);
if ((void *)-1 == shared_memory)
{
perror("shmat failed");
exit(EXIT_FAILURE);
}
printf("A: 启动成功\n");
fflush(stdout);
while (send_count < 2)
{
char message_data[MAX_DATA_SIZE]; // 存放发送的数据内容
size_t data_size = snprintf(message_data, MAX_DATA_SIZE,
"i will send some message to B： count: %d", send_count);
shm_data send_data = {
.length = data_size,
.crc32 = crc32(message_data, data_size),
};
memcpy(send_data.data, message_data, data_size);
// 进入临界区获取信号量
P_semaphore(semaphore_id);
memcpy(shared_memory, &send_data, sizeof(shm_data));
V_semaphore(semaphore_id);
// 构造发送给B的消息
message.msg_type = MSG_SENT_A_TO_B;
message.msg_text[0] = '1';
message.msg_text[1] = '\0';
msgsnd(message_queue_id, &message, strlen(message.msg_text) + 1, 0);
// 接收 B 的响应消息
msgrcv(message_queue_id, &message, MAX_MSG_SIZE, MSG_ANSWER_B_TO_A, 0);
int b_response = atoi(message.msg_text);
time_t now = time(NULL);
printf("[%ld] A: 发送了 %zu 字节数据给 B, 校验 %s\n",
now - start_time, data_size, b_response ? "正确" : "错误");
total_data_sent += data_size;
send_count++;
sleep(1); // 等待一秒
}
printf("A: 总共发送数据大小为: %zu 字节\n", total_data_sent);
shmdt(shared_memory);
}
// 子进程
static void process_B(int shared_memory_id, int message_queue_id, int semaphore_id)
{
shm_data *shared_memory = (shm_data *)shmat(shared_memory_id, NULL, 0);
msg_form message;
size_t total_data_received = 0;
time_t start_time = time(NULL);
if ((void *)-1 == shared_memory)
{
perror("shmat");
exit(EXIT_FAILURE);
}
printf("B: 启动成功\n");
fflush(stdout);
while (1)
{
msgrcv(message_queue_id, &message, MAX_MSG_SIZE, MSG_SENT_A_TO_B, 0);
shm_data received_data;
// 进入临界区获取信号量
P_semaphore(semaphore_id);
memcpy(&received_data, shared_memory, sizeof(shm_data));
V_semaphore(semaphore_id);
uint32_t actual_crc = crc32(received_data.data, received_data.length);
int result = (actual_crc == received_data.crc32);
time_t current_time = time(NULL);
printf("[%ld] B: 接收了 %zu 字节数据，校验 %s\n",
current_time - start_time, received_data.length, result ? "正确" : "错误");
total_data_received += received_data.length;
message.msg_type = MSG_ANSWER_B_TO_A;
snprintf(message.msg_text, MAX_MSG_SIZE, "%d", result);
msgsnd(message_queue_id, &message, strlen(message.msg_text) + 1, 0);
}
printf("B: 总共接收数据大小为: %zu 字节\n", total_data_received);
shmdt(shared_memory);
}
int main()
{
int shared_memory_id, message_queue_id, semaphore_id;
init_ipc(&shared_memory_id, &message_queue_id, &semaphore_id);
pid_t child_pid = fork();
if (child_pid < 0)
{
perror("fork");
exit(EXIT_FAILURE);
}
else if (0 == child_pid)
{
// 子进程运行 B
process_B(shared_memory_id, message_queue_id, semaphore_id);
}
else
{
// 父进程运行 A
process_A(shared_memory_id, message_queue_id, semaphore_id);
wait(NULL); // 等待子进程结束
// 父进程使用 shmctl、msgctl 和 semctl 删除共享内存段、消息队列和信号量
shmctl(shared_memory_id, IPC_RMID, NULL);
msgctl(message_queue_id, IPC_RMID, NULL);
semctl(semaphore_id, 0, IPC_RMID);
}
return 0;
}帮我根据这个写一个设计文档
最新发布
本文介绍了信号量(semaphore)的内部实现原理，包括用户级和内核级的区别，以及如何通过SEM_UNDO标志实现进程异常终止时信号量的回滚。此外，还探讨了POSIX消息队列和IPC消息的实现机制，以及共享内存(shmid_kernel)的管理方式。
扫一扫
245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
