文章详细描述了如何在C语言中使用SystemV信号量和POSIX共享内存进行进程间通信，通过信号量控制第一篇进程处理大文件暂停，第二篇进程等待信号后继续执行。强调了在独立shell环境中的编译和运行要求，以及对共享内存状态的管理。
实验步骤：
-
第一篇进程的编译与运行：
- 首先，编译并运行第一篇代码。该进程在运行时会创建一个共享内存段，并初始化一个信号量，将其值减少至2。随后，进程会调用
pause()函数，模拟正在处理一个大文件的情景，进入暂停状态。
- 首先，编译并运行第一篇代码。该进程在运行时会创建一个共享内存段，并初始化一个信号量，将其值减少至2。随后，进程会调用
-
第二篇进程的编译与运行：
- 接着，在一个新的独立命令窗口中，编译并运行第二篇代码。该进程尝试访问第一篇进程创建的共享内存。然而，由于信号量的值已被第一篇进程减少至0，第二篇进程会因无法获取信号量而被阻塞，无法继续执行。
-
唤醒第一篇进程：
- 在另一个命令窗口中，使用
kill -ALRM pid命令发送信号唤醒第一篇进程。这个信号模拟了大文件处理完成的情况，唤醒后第一篇进程会释放信号量。
- 在另一个命令窗口中，使用
-
继续运行第二篇进程：
- 在信号量被释放后，第二篇进程将能够正常获取信号量并访问共享内存，继续其执行过程。最后，第二篇进程会完成对共享内存的处理并退出，同时清理删除共享内存段和信号量集。
-
验证实验结果：
- 运行
ipcs命令检查系统中是否还存在共享内存段和信号量集。如果列表为空，说明实验顺利完成，资源已被正常清理。
- 运行
实验原理：
第一篇进程创建了一个共享内存段和一个信号量，并进入暂停状态，模拟长时间的文件处理。第二篇进程试图访问该共享内存，但由于信号量已被减少至0，它会被阻塞。通过在独立的命令窗口中发送信号来唤醒第一篇进程，第一篇进程将释放信号量，使第二篇进程能够继续执行。整个实验展示了进程间通过信号量和共享内存进行同步与通信的机制，并通过适当的资源管理来确保系统资源不会泄露。
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h> //System V信号量
#include <semaphore.h> //POSIX信号量
#include <sys/shm.h> //System V共享内存
#include <sys/mman.h> //POSIX共享内存
#include <sys/msg.h> //System V消息队列
#include <mqueue.h> //POSIX消息队列
// 信号处理逻辑
void signal_handler(int signum)
{
printf("$$$%s$$$\n", strsignal(signum));
}
// 查看共享内存状态
void ipc_stat(int shmid)
{
struct shmid_ds shm_desc;
// 函数正常退出后信息被储存在shm_desc
if (shmctl(shmid, IPC_STAT, &shm_desc) == -1)
{
perror("shmctl");
}
printf("shm creator: %d\n", shm_desc.shm_cpid);
printf("shm size: %zu\n", shm_desc.shm_segsz);
printf("shm attaches: %ld\n", shm_desc.shm_nattch);
}
void sem_op(int semid, int sem_op)
{
// 信号量pv操作 -1 +1
struct sembuf sem_buffer = {0};
sem_buffer.sem_num = 0;
sem_buffer.sem_op = sem_op;
sem_buffer.sem_flg = SEM_UNDO;
if (sem_op == -1)
{
printf("%d p start\n", getpid());
}
else
{
printf("%d v start\n", getpid());
}
if (semop(semid, &sem_buffer, 1) == -1)
{
perror("semop");
}
if (sem_op == -1)
{
printf("%d p end\n", getpid());
}
else
{
printf("%d v end\n", getpid());
}
}
void todo(void *p_shm)
{
// 说了一句你好吗?加换行 然后暂停
sprintf((char *)p_shm, "%d say how are you ?\n", getpid());
pause();
}
int main()
{
// 接收SIGALRM 防止进程终止
if (signal(SIGALRM, signal_handler) == SIG_ERR)
{
perror("signal");
}
// 创建共享内存 key:666 大小1024字节 权限0777
int shmid = shmget(666, 1024, IPC_CREAT | 0777);
if (shmid == -1)
{
perror("shmget");
}
printf("%d shared memory segment created\n", getpid());
// 挂载 地址null表示由系统选址 0表示由读写权限
// 因为进程有独立的内存空间,共享内存需要挂载到进程上才能访问
void *p_shm = shmat(shmid, NULL, 0);
if (p_shm == (void *)-1)
{
perror("shmat");
}
printf("%d shared memory segment Attached\n", getpid());
// 查看共享内存状态
ipc_stat(shmid);
// 创建信号量集,key:666 这个信号量集包含1个信号量 存在就获取不存在就创建
int semid = semget(666, 1, IPC_CREAT | 0777);
if (semid == -1)
{
perror("semid");
}
printf("%d semaphore created\n", getpid());
// 将这个信号量的值设为1
if (semctl(semid, 0, SETVAL, 1) == -1)
{
perror("semctl");
}
printf("%d set semaphore completed\n", getpid());
// p操作 上锁了
sem_op(semid, -1);
// 操作共享内存
todo(p_shm);
// v操作 解锁
sem_op(semid, +1);
// 卸载分离 共享内存
if (shmdt(p_shm) == -1)
{
perror("shmdt");
}
printf("%d Detach shared memory segment\n", getpid());
/*第一篇结束 编译后在独立shell中启动 不能在IDE中运行*/
return 0;
}
这段代码展示了如何使用 System V IPC（进程间通信）机制，包括信号处理、共享内存和信号量来实现进程间的同步与通信。以下是代码的功能总结和关键点解析：
代码功能概述
-
信号处理：
- 代码注册了一个信号处理函数
signal_handler，用来捕获SIGALRM信号并打印该信号的描述。这样可以防止进程因收到此信号而终止。
- 代码注册了一个信号处理函数
-
共享内存创建与挂载：
- 使用
shmget创建或获取一个共享内存段，大小为 1024 字节，权限为 0777。共享内存是用于在多个进程之间共享数据的。 - 使用
shmat挂载共享内存段到当前进程的地址空间，使得进程能够访问这块共享内存。 ipc_stat函数用于打印共享内存的状态信息，包括创建进程的 PID、内存大小和当前的连接数。
- 使用
-
信号量的创建与操作：
- 使用
semget创建或获取一个信号量集，其中包含一个信号量。信号量用于控制对共享资源的访问，以避免竞态条件。 sem_op函数封装了对信号量的P操作（减1，上锁）和V操作（加1，解锁），确保对共享资源的访问是互斥的。
- 使用
-
共享内存的操作：
todo函数用于向共享内存中写入数据（当前进程的 PID 以及一条消息），然后暂停等待信号处理。
-
资源释放：
- 操作完成后，代码使用
shmdt解除当前进程对共享内存段的挂载，从而释放资源。
- 操作完成后，代码使用
代码的关键点解析
-
信号处理机制：
- 通过
signal(SIGALRM, signal_handler)注册了一个信号处理函数，确保进程在收到SIGALRM信号时不会直接终止，而是调用signal_handler函数进行处理。这对于进程的长期运行和稳定性非常重要。
- 通过
-
共享内存的使用：
- 共享内存是进程间通信的一种高效方式，多个进程可以直接读写同一块内存，而无需通过内核进行额外的数据拷贝。
- 代码中的共享内存段在创建后立即挂载到当前进程，并通过指针
p_shm进行操作。
-
信号量同步：
- 信号量在这里用于实现对共享内存的互斥访问，确保只有一个进程能够在某个时刻访问共享内存。
sem_op函数通过封装信号量的P操作和V操作，使得代码更清晰易读，并便于调试和维护。
-
进程间通信：
- 该代码展示了典型的进程间通信模式：一个进程通过信号量上锁后操作共享内存，操作完成后解锁，允许其他进程访问。这种模式常用于需要协调多个进程对共享资源进行有序访问的场景。
总结
这段代码展示了如何在 Linux 环境下使用 System V IPC 机制进行进程间通信和同步，包括信号处理、共享内存和信号量的使用。代码逻辑清晰，结构完整，能够有效地演示进程间如何通过共享内存共享数据，并通过信号量实现对资源的互斥访问。对于学习和掌握进程间通信的基本原理和方法具有很好的参考价值。
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <time.h>
#include <sys/sem.h> //System V信号量
#include <semaphore.h> //POSIX信号量
#include <sys/shm.h> //System V共享内存
#include <sys/mman.h> //POSIX共享内存
#include <sys/msg.h> //System V消息队列
#include <mqueue.h> //POSIX消息队列
void ipc_stat(int shmid)
{
struct shmid_ds shm_desc;
if (shmctl(shmid, IPC_STAT, &shm_desc) == -1)
{
perror("shmctl");
}
printf("shm creator: %d\n", shm_desc.shm_cpid);
printf("shm size: %zu\n", shm_desc.shm_segsz);
printf("shm attaches: %ld\n", shm_desc.shm_nattch);
}
void sem_op(int semid, int sem_op)
{
struct sembuf sem_buffer = {0};
sem_buffer.sem_num = 0;
sem_buffer.sem_op = sem_op;
sem_buffer.sem_flg = SEM_UNDO;
if (sem_op == -1)
{
printf("%d p start\n", getpid());
}
else
{
printf("%d v start\n", getpid());
}
if (semop(semid, &sem_buffer, 1) == -1)
{
perror("semop");
}
if (sem_op == -1)
{
printf("%d p end\n", getpid());
}
else
{
printf("%d v end\n", getpid());
}
}
void todo(void *p_shm)
{
// 在how are u \n 后面加了fine \n 并打印查看效果
sprintf((char *)p_shm, "%s%d say fine,thank you\n", (char *)p_shm, getpid());
printf("%s", (char *)p_shm);
}
int main()
{
// 获取或创建共享内存id
int shmid = shmget(666, 1024, IPC_CREAT | 0777);
if (shmid == -1)
{
perror("shmget");
}
printf("%d get shared memory segment\n", getpid());
// 挂载共享内存并获取指向共享内存首地址指针
void *p_shm = shmat(shmid, NULL, 0);
if (p_shm == (void *)-1)
{
perror("shmat");
}
printf("%d shared memory segment Attached\n", getpid());
// 查看共享内存状态
ipc_stat(shmid);
// 获取或创建信号量集id
int semid = semget(666, 1, IPC_CREAT | 0777);
if (semid == -1)
{
perror("semget");
}
printf("%d get semaphore\n", getpid());
// p操作
sem_op(semid, -1);
// 操作已经由信号量同步的共享内存
todo(p_shm);
// v操作
sem_op(semid, +1);
// 分离共享内存
if (shmdt(p_shm) == -1)
{
perror("shmdt");
}
printf("%d Detach shared memory segment\n", getpid());
// 删除共享内存
if (shmctl(shmid, IPC_RMID, NULL) == -1)
{
perror("shmctl");
}
printf("%d delete shared memory id\n", getpid());
// 删除信号量集
if (semctl(semid, 0, IPC_RMID) == -1)
{
perror("semctl");
}
printf("%d delete Semaphore id\n", getpid());
return 0;
}
这段代码展示了一个典型的使用 System V 共享内存和信号量进行进程间同步和通信的完整流程，包括创建、操作、同步、分离以及删除共享内存和信号量的过程。以下是对代码功能的总结和关键点解析：
代码功能概述
-
共享内存的创建和挂载：
- 程序首先使用
shmget创建或获取一个共享内存段，并使用shmat将该共享内存段挂载到当前进程的地址空间，以便进程可以直接访问这块内存。
- 程序首先使用
-
共享内存状态查看：
- 使用
shmctl函数来获取共享内存的状态信息，并打印出创建进程的 PID、内存大小和当前连接的进程数。
- 使用
-
信号量的创建和同步操作：
- 使用
semget创建或获取一个信号量集，以实现对共享资源（共享内存）的访问控制。通过P操作（减1，上锁）和V操作（加1，解锁）来控制对共享内存的访问，确保只有一个进程在某个时刻可以操作共享内存。
- 使用
-
共享内存的操作：
- 在信号量上锁后，程序通过
todo函数向共享内存中追加数据，并打印出更新后的内容。
- 在信号量上锁后，程序通过
-
共享内存的分离和删除：
- 操作完成后，程序使用
shmdt将共享内存从当前进程的地址空间中分离，并使用shmctl删除共享内存段。
- 操作完成后，程序使用
-
信号量的删除：
- 在释放共享内存之后，程序使用
semctl删除信号量集，清理所有资源。
- 在释放共享内存之后，程序使用
关键点解析
-
共享内存的使用：
- 共享内存是进程间通信的一种高效方式，允许多个进程直接访问相同的内存段。通过
shmget、shmat、shmdt等系统调用，可以实现共享内存的创建、挂载、操作和删除。 - 共享内存操作具有很高的效率，但需要通过同步机制（如信号量）来避免多个进程同时访问共享内存时发生数据竞争。
- 共享内存是进程间通信的一种高效方式，允许多个进程直接访问相同的内存段。通过
-
信号量的同步：
- 信号量是用于控制进程间对共享资源的访问。
P操作（减1，上锁）确保某个进程对共享资源的独占访问，而V操作（加1，解锁）则允许其他进程访问共享资源。 - 通过
semget、semop、semctl等系统调用，可以创建、操作和删除信号量。
- 信号量是用于控制进程间对共享资源的访问。
-
资源管理和清理：
- 程序在操作完成后，通过
shmdt和shmctl分离和删除共享内存，并通过semctl删除信号量集。这样可以防止资源泄漏，确保系统资源得到有效管理和释放。 - 删除共享内存和信号量不仅仅是为了清理资源，也是为了防止其他进程意外地再次使用这些资源，从而引发潜在的错误或冲突。
- 程序在操作完成后，通过
-
进程间通信和同步的综合应用：
- 该代码展示了进程间通信和同步的典型应用模式：多个进程通过共享内存交换数据，通过信号量控制访问顺序。这样的模式广泛应用于需要进程间高效通信和严格同步的场景中，如多进程服务器、并行计算、实时控制系统等。
总结
这段代码完整地展示了使用 System V 共享内存和信号量进行进程间通信和同步的步骤。通过创建共享内存和信号量，进程可以共享数据并控制对共享资源的访问；通过适当的资源管理，程序确保了所有系统资源都得到正确的释放。该代码是学习和掌握进程间通信与同步机制的一个优秀范例，尤其适合理解多进程编程中的共享资源管理和同步控制。
扫一扫
2310
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
