互相独立进程间共享内存互斥访问的解决办法

//processA.c文件
#include <stdlib.h>
#include <stdio.h>
#include <sys/shm.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <errno.h>
#include <pthread.h>
 
#define BUF_SIZE 4096
 
int main()
{
    void *shm_addr = NULL;
    char buffer[BUF_SIZE];
	pthread_mutex_t * sharedLock;
	pthread_mutexattr_t ma;
 
    int shmid;
    // 使用约定的键值创建共享内存
    shmid = shmget((key_t) 1234,  BUF_SIZE, 0666 | IPC_CREAT);
    printf("shmid : %u\n", shmid);
    if (shmid < 0)
    {
        perror("shmget error!");
        exit(1);
    }
 
    // 将共享内存附加到本进程
    shm_addr = shmat(shmid, NULL, 0);
    if (shm_addr == (void *) -1)
    {
        perror("shmat error!");
        exit(1);
    }
 
	sharedLock = (pthread_mutex_t *)shm_addr;
 
	pthread_mutexattr_init(&ma);
	pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED);
	pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
	pthread_mutex_init(sharedLock,&ma);
 
    // 写入数据
    while(1){
    	pthread_mutex_lock(sharedLock);
    	bzero(buffer, BUF_SIZE);
    	sprintf(buffer, "Hello, My PID is %u\n", (unsigned int) getpid());
    	printf("send data: %s\n", buffer);
    	memcpy(((pthread_mutex_t *)shm_addr)+1, buffer, strlen(buffer));
		pthread_mutex_unlock(sharedLock);
    }
 
    sleep(5);
 
    // 分离
    if (shmdt(shm_addr) == -1)
    {
        printf("shmdt error!\n");
        exit(1);
    }
}

//processB.c文件
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
 
#define BUF_SIZE 4096
 
int main()
{
    void *shm_addr = NULL;
	pthread_mutex_t * sharedLock;
	char tmp[BUF_SIZE];
 
    int shmid;
    // 使用约定的键值打开共享内存
    shmid = shmget((key_t) 1234, BUF_SIZE, IPC_CREAT);
    printf("shmid : %u\n", shmid);
    if (shmid == -1)
    {
        perror("shmget error!");
        exit(1);
    }
 
    // 将共享内存附加到本进程
    shm_addr = shmat(shmid, NULL, 0);
    if (shm_addr == (void *) -1)
    {
        perror("shmat error!");
        exit(1);
    }
 
	sharedLock = (pthread_mutex_t *)shm_addr;
 
    // 读取数据
    while(1){
		pthread_mutex_lock(sharedLock);
    	bzero(tmp, BUF_SIZE);
    	memcpy(tmp, ((pthread_mutex_t *)shm_addr)+1, 50);
    	printf("read from shared memory: %s\n", tmp);
		pthread_mutex_unlock(sharedLock);
    }
 
    sleep(5);
 
    // 分离
    if (shmdt(shm_addr) == -1)
    {
        printf("shmdt error!\n");
        exit(1);
    }
 
    // 删除共享内存
    if (shmctl(shmid, IPC_RMID, 0) == -1)
    {
        printf("shmctl error!\n");
        exit(1);
    }
}

前提：两个进程互相独立，访问同一片共享内存

存在问题：

1、如何避免两个进程同时访问共享内存（一旦两个进程同时访问一个临界区，后果是程序崩溃）

2、如果使用互斥锁，如何让两个进程拿到同一个互斥锁

解决办法：

针对问题1，可以使用信号，信号量，互斥锁来进行同步，但是信号和信号量需要两个进程都实现一套自己的逻辑（访问临界区前，先检查冲突标志，如果没有冲突则访问，并向其它的所有进程依次发送信号，告诉它们我要开始访问了；如果有冲突则阻塞等待。同时进程收到信号后要设置冲突标志，标识现在有其它进程在访问），比较麻烦，两个进程的话还比较简单，多个进程的话在访问共享内存前要通知所有的其它进程。所以最终决定使用互斥锁来完成同步访问。那么就出现了第二个问题，如何让两个进程拿到同一个互斥锁。

针对问题2，可以使用下面的解决方案：互斥量保存在共享内存中，在初始化该锁的时候，设置为进程间共享，这样两个进程连接到共享内存后，都可以获得这个互斥锁，因为已经设置了进程间共享，所以对锁的访问的冲突问题，系统已经解决了。
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/woyimibayi/article/details/80096275