Linux进程间共享内存通信时如何同步？

嗨喽！大家好！我是 木荣 。

今天我们来讲讲进程间使用共享内存通信时为了确保数据的正确，如何进行同步?

在Linux中，进程间的共享内存通信需要通过同步机制来保证数据的正确性和一致性，常用的同步机制包括信号量、互斥锁、条件变量等。

其中，使用信号量来同步进程间的共享内存访问是一种常见的方法。每个共享内存区域可以关联一个或多个信号量，以保护共享内存区域的读写操作。在访问共享内存之前，进程需要获取信号量的使用权，当完成读写操作后，再释放信号量的使用权，以便其他进程可以访问共享内存区域。

1、信号量同步

下面是一个简单的示例程序，展示了如何使用信号量来同步共享内存区域的读写操作：

#include 
#include 
#include 
#include 
#include 
#include 

#define SHM_SIZE 1024
#define SEM_KEY 0x123456

// 定义联合体，用于信号量操作
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int main() {
    int shmid, semid;
    char *shmaddr;
    struct sembuf semops[2];
    union semun semarg;

    // 创建共享内存区域
    shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }

    // 将共享内存区域附加到进程地址空间中
    shmaddr = shmat(shmid, NULL, 0);
    if (shmaddr == (char *) -1) {
        perror("shmat");
        exit(1);
    }

    // 创建信号量
    semid = semget(SEM_KEY, 1, IPC_CREAT | 0666);
    if (semid == -1) {
        perror("semget");
        exit(1);
    }

    // 初始化信号量值为1
    semarg.val = 1;
    if (semctl(semid, 0, SETVAL, semarg) == -1) {
        perror("semctl");
        exit(1);
    }

    // 等待信号量
    semops[0].sem_num = 0;
    semops[0].sem_op = 0;
    semops[0].sem_flg = 0;
    if (semop(semid, semops, 1) == -1) {
        perror("semop");
        exit(1);
    }

    // 在共享内存中写入数据
    strncpy(shmaddr, "Hello, world!", SHM_SIZE);

    // 释放信号量
    semops[0].sem_num = 0;
    semops[0].sem_op = 1;
    semops[0].sem_flg = 0;
    if (semop(semid, semops, 1) == -1) {
        perror("semop");
        exit(1);
    }

    // 等待信号量
    semops[0].sem_num = 0;
    semops[0].sem_op = 0;
    semops[0].sem_flg = 0;
    if (semop(semid, semops, 1) == -1) {
        perror("semop");
        exit(1);
    }

    // 从共享内存中读取数据
    printf("Received message: %s\\n", shmaddr);

    // 释放共享内存区域
    if (shmdt(shmaddr) == -1) {
        perror("shmdt");
        exit(1);
    }

    // 删除共享内存区域
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl");
        exit(1);
    }

    // 删除信号量
    if (semctl(semid, 0, IPC_RMID, semarg) == -1) {
        perror("semctl");
        exit(1);
    }

    return 0;

在这个示例程序中，使用了System V信号量来同步共享内存的读写操作。程序首先创建一个共享内存区域，并将其附加到进程地址空间中。然后，使用semget()函数创建一个信号量，并将其初始化为1。在写入共享内存数据之前，程序使用semop()函数等待信号量。一旦获取了信号量的使用权，程序就可以在共享内存区域中写入数据。写入数据完成后，程序再次使用semop()函数释放信号量的使用权。在读取共享内存数据时，程序同样需要等待信号量的使用权，读取数据完成后，再次释放信号量的使用权。

需要注意的是，使用信号量来同步共享内存访问时，需要确保每个进程都按照一定的顺序进行读写操作。否则，就可能出现死锁等问题。因此，在设计进程间共享内存通信时，需要仔细考虑数据的读写顺序，并采取合适的同步机制来确保数据的正确性和一致性。

2、互斥锁同步

互斥量也是一种常用的同步机制，可以用来实现多个进程之间的共享内存访问。在Linux中，可以使用pthread库中的互斥量来实现进程间共享内存的同步。

下面是一个使用互斥量实现共享内存同步的示例程序：

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define SHM_SIZE 1024

// 共享内存结构体
typedef struct {
    pthread_mutex_t mutex;
    char data[SHM_SIZE];
} shm_data_t;

int main() {
    int fd;
    shm_data_t *shm_data;
    pthread_mutexattr_t mutex_attr;
    pthread_mutex_t *mutex;
    
    // 打开共享内存文件
    if ((fd = shm_open("/my_shm", O_CREAT | O_RDWR, 0666)) == -1) {
        perror("shm_open");
        exit(1);
    }

    // 调整共享内存文件大小
    if (ftruncate(fd, sizeof(shm_data_t)) == -1) {
        perror("ftruncate");
        exit(1);
    }

    // 将共享内存映射到进程地址空间中
    if ((shm_data = mmap(NULL, sizeof(shm_data_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }

    // 初始化互斥量属性
    pthread_mutexattr_init(&mutex_attr);
    pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED);

    // 创建互斥量
    mutex = &(shm_data->mutex);
    pthread_mutex_init(mutex, &mutex_attr);

    // 在共享内存中写入数据
    pthread_mutex_lock(mutex);
    sprintf(shm_data->data, "Hello, world!");
    pthread_mutex_unlock(mutex);

    // 在共享内存中读取数据
    pthread_mutex_lock(mutex);
    printf("Received message: %s\\n", shm_data->data);
    pthread_mutex_unlock(mutex);

    // 解除共享内存映射
    if (munmap(shm_data, sizeof(shm_data_t)) == -1) {
        perror("munmap");
        exit(1);
    }

    // 删除共享内存文件
    if (shm_unlink("/my_shm") == -1) {
        perror("shm_unlink");
        exit(1);
    }

    return 0;
}

在这个示例程序中，使用了pthread库中的互斥量来同步共享内存的读写操作。程序首先创建一个共享内存文件，并将其映射到进程地址空间中。然后，使用pthread_mutex_init()函数创建一个互斥量，并将其初始化为共享内存中的一部分。在写入共享内存数据之前，程序使用pthread_mutex_lock()函数等待互斥量。一旦获取了互斥量的使用权，程序就可以在共享内存区域中写入数据。写入数据完成后，程序再次使用pthread_mutex_unlock()函数释放互斥量的使用权。在读取共享内存数据之前，程序再次使用pthread_mutex_lock()函数等待互斥量。一旦获取了互斥量的使用权，程序就可以在共享内存区域中读取数据。读取数据完成后，程序再次使用pthread_mutex_unlock()函数释放互斥量的使用权。最后，程序解除共享内存映射，并删除共享内存文件。

使用互斥量来同步共享内存访问有以下几点注意事项：

1、互斥量需要初始化。在创建互斥量之前，需要使用pthread_mutexattr_init()函数初始化互斥量属性，并使用pthread_mutexattr_setpshared()函数将互斥量属性设置为PTHREAD_PROCESS_SHARED，以便多个进程可以共享互斥量。

2、在访问共享内存之前，需要使用pthread_mutex_lock()函数获取互斥量的使用权。一旦获取了互斥量的使用权，程序才能访问共享内存。在完成共享内存的访问之后，需要使用pthread_mutex_unlock()函数释放互斥量的使用权，以便其他进程可以访问共享内存。

3、互斥量必须存储在共享内存区域中。在创建互斥量时，需要将其初始化为共享内存区域中的一部分，以便多个进程可以访问同一个互斥量。

4、程序必须保证互斥量的一致性。多个进程共享同一个互斥量时，必须保证互斥量的一致性。否则，可能会导致多个进程同时访问共享内存区域，导致数据错误或者系统崩溃。

总之，使用互斥量来同步共享内存访问可以有效地避免多个进程同时访问共享内存区域的问题，从而保证数据的一致性和程序的稳定性。在实际编程中，需要根据具体的需求选择不同的同步机制，以保证程序的正确性和效率。

3、条件变量同步

在Linux下，可以使用条件变量（Condition Variable）来实现多进程之间的同步。条件变量通常与互斥量（Mutex）结合使用，以便在共享内存区域中对数据进行同步访问。

条件变量是一种线程同步机制，用于等待或者通知某个事件的发生。当某个进程需要等待某个事件发生时，它可以通过调用pthread_cond_wait()函数来阻塞自己，并将互斥量释放。一旦事件发生，其他进程就可以通过调用pthread_cond_signal()或pthread_cond_broadcast()函数来通知等待线程。等待线程接收到通知后，会重新获取互斥量，并继续执行。

在共享内存通信中，可以使用条件变量来实现进程之间的同步。具体操作步骤如下：

初始化互斥量和条件变量。在创建共享内存之前，需要使用pthread_mutexattr_init()和pthread_condattr_init()函数分别初始化互斥量属性和条件变量属性。然后，需要使用pthread_mutexattr_setpshared()和pthread_condattr_setpshared()函数将互斥量属性和条件变量属性设置为PTHREAD_PROCESS_SHARED，以便多个进程可以共享它们。

等待条件变量。在读取共享内存之前，程序可以使用pthread_cond_wait()函数等待条件变量。调用pthread_cond_wait()函数会自动释放互斥量，并阻塞当前进程。一旦其他进程发送信号通知条件变量发生变化，等待线程就会重新获得互斥量，并继续执行。

发送信号通知条件变量变化。 在向共享内存中写入数据之后，程序可以使用pthread_cond_signal()或pthread_cond_broadcast()函数发送信号通知条件变量发生变化。 调用pthread_cond_signal()函数会发送一个信号通知等待线程条件变量发生变化，而调用pthread_cond_broadcast()函数会向所有等待线程发送信号通知条件变量发生变化。

使用条件变量来同步共享内存访问有以下几点注意事项：

1、程序必须使用互斥量来保护共享内存。 在使用条件变量之前，程序必须先获取互斥量的使用权，以便保护共享内存区域中的数据不被多个进程同时访问。

2、程序必须保证条件变量的一致性。 多个进程共享同一个条件变量时，必须保证条件变量的一致性。 否则，可能会导致多个进程同时访问共享内存区域，导致数据错误或者系统崩溃。

3、程序必须正确使用条件变量。 在使用条件变量时，需要正确地使用pthread_cond_wait()、pthread_cond_signal()和pthread_cond_broadcast()函数，否则可能会导致死锁或者其他问题。

4、程序必须正确处理信号。 当调用pthread_cond_wait()函数时，程序可能会因为接收到信号而提前返回，此时程序需要正确地处理信号。

下面是一个使用条件变量实现进程间共享内存同步的示例代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define SHM_SIZE 4096
#define SHM_NAME "/myshm"
#define SEM_NAME "/mysem"

typedef struct {
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    char buffer[SHM_SIZE];
} shm_t;

int main(int argc, char *argv[]) {
    int fd, pid;
    shm_t *shm;
    pthread_mutexattr_t mutex_attr;
    pthread_condattr_t cond_attr;

    // 创建共享内存区域
    fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
    if (fd < 0) {
        perror("shm_open");
        exit(1);
    }

    // 设置共享内存大小
    if (ftruncate(fd, sizeof(shm_t)) < 0) {
        perror("ftruncate");
        exit(1);
    }

    // 将共享内存映射到进程地址空间
    shm = mmap(NULL, sizeof(shm_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (shm == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }

    // 初始化互斥量属性和条件变量属性
    pthread_mutexattr_init(&mutex_attr);
    pthread_condattr_init(&cond_attr);
    pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED);
    pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED);

    // 初始化互斥量和条件变量
    pthread_mutex_init(&shm->mutex, &mutex_attr);
    pthread_cond_init(&shm->cond, &cond_attr);

    // 创建子进程
    pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(1);
    }

    if (pid == 0) {
        // 子进程写入共享内存
        sleep(1);
        pthread_mutex_lock(&shm->mutex);
        sprintf(shm->buffer, "Hello, world!");
        pthread_cond_signal(&shm->cond);
        pthread_mutex_unlock(&shm->mutex);
        exit(0);
    } else {
        // 父进程读取共享内存
        pthread_mutex_lock(&shm->mutex);
        pthread_cond_wait(&shm->cond, &shm->mutex);
        printf("Received message: %s\\n", shm->buffer);
        pthread_mutex_unlock(&shm->mutex);
    }

    // 删除共享内存
    if (shm_unlink(SHM_NAME) < 0) {
        perror("shm_unlink");
        exit(1);
    }

    return 0;
}

在这个示例中，程序创建了一个名为"/myshm"的共享内存区域，并将其映射到进程地址空间中。 然后，程序使用互斥量和条件变量来同步进程之间的访问共享内存区域。 具体来说，父进程首先锁定互斥量，然后等待条件变量的信号。 子进程等待一秒钟后，锁定互斥量，将"Hello, world!"字符串写入共享内存区域，然后发送条件变量信号，并释放互斥量。 此时，父进程将收到条件变量信号并锁定互斥量，读取共享内存区域中的内容，并释放互斥量。

需要注意的是，在使用条件变量时，我们需要遵循一些规则来保证程序的正确性，如在等待条件变量时必须锁定互斥量，并使用while循环来检查条件变量的值是否满足要求，等待条件变量信号的线程必须在等待之前锁定互斥量，在等待之后解锁互斥量，等待条件变量信号的线程可能会因为接收到信号而提前返回等等。

总之，使用互斥量和条件变量来实现进程间共享内存通信的同步，需要我们仔细考虑程序中所有可能出现的情况，并正确地使用互斥量和条件变量函数来同步进程之间的访问。

小结

好了，这次我们通过Linux下进程间共享内存通信方式讲解了常用的同步机制：信号量、互斥锁、条件变量。 希望对小伙伴们在日常的编程当中有所帮助。