Linux共享内存实现进程同步

Linux共享内存可以用来实现进程同步的一个经典的方法就是通过信号量（semaphore）来控制共享内存的访问。

在Linux中，可以使用System V IPC机制中的信号量来实现进程同步。具体步骤如下：

1. 创建共享内存区域，并将其附加到进程地址空间中。

2. 创建信号量，并初始化为1，表示可以访问共享内存。

3. 当一个进程需要访问共享内存时，首先要通过信号量获取访问权限。如果信号量的值为1，表示可以访问，就将其减1，表示已经有一个进程在访问，然后就可以访问共享内存。

4. 当该进程访问完毕后，就通过信号量释放访问权限。将信号量加1，表示已经没有进程在访问共享内存了。

5. 如果有多个进程同时需要访问共享内存，那么它们会按照先后顺序排队等待信号量的值变为1，表示可以访问。

这种方法的优点是实现简单，效率高，适用于多个进程共享同一块内存区域的场景。但是需要注意的是，由于共享内存没有提供同步机制，因此需要使用信号量来确保共享内存的正确访问。同时，需要考虑进程之间的竞争条件和死锁问题。

相关问题

linux 共享内存 进程间同步 例子

下面是一个基于 Linux 共享内存机制的进程间同步的例子：

首先，我们需要创建一个共享内存区域，可以使用 `shmget()` 函数来创建：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define SHM_SIZE 1024

int shmid;
char *shmaddr;

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

接下来，我们需要将共享内存区域映射到进程的地址空间中，可以使用 `shmat()` 函数来实现：

/* 映射共享内存 */
shmaddr = (char *)shmat(shmid, NULL, 0);
if (shmaddr == (char *) -1) {
    perror("shmat");
    exit(1);
}

现在，我们就可以在进程间共享数据了，例如：

/* 写入数据 */
strcpy(shmaddr, "Hello, world!");

/* 读取数据 */
printf("%s\n", shmaddr);

接下来，我们需要在多个进程间同步对共享内存的访问，这可以通过信号量机制来实现。我们可以使用 `semget()` 函数来创建一个信号量集合：

#include <sys/sem.h>

int semid;

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

然后，我们可以使用 `semctl()` 函数来初始化信号量的值：

#include <sys/sem.h>

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

union semun semarg;

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

现在，我们就可以在进程访问共享内存之前，先通过 `semop()` 函数来获取信号量：

#include <sys/sem.h>

struct sembuf sembuf;

/* 获取信号量 */
sembuf.sem_num = 0;
sembuf.sem_op = -1;
sembuf.sem_flg = SEM_UNDO;
if (semop(semid, &sembuf, 1) == -1) {
    perror("semop");
    exit(1);
}

然后，对共享内存进行读写操作。

最后，访问完共享内存后，我们需要释放信号量：

#include <sys/sem.h>

/* 释放信号量 */
sembuf.sem_num = 0;
sembuf.sem_op = 1;
sembuf.sem_flg = SEM_UNDO;
if (semop(semid, &sembuf, 1) == -1) {
    perror("semop");
    exit(1);
}

完整的代码可以参考下面的例子：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>

#define SHM_SIZE 1024

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

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

    /* 映射共享内存 */
    shmaddr = (char *)shmat(shmid, NULL, 0);
    if (shmaddr == (char *) -1) {
        perror("shmat");
        exit(1);
    }

    /* 创建信号量集合 */
    semid = semget(IPC_PRIVATE, 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);
    }

    /* 获取信号量 */
    sembuf.sem_num = 0;
    sembuf.sem_op = -1;
    sembuf.sem_flg = SEM_UNDO;
    if (semop(semid, &sembuf, 1) == -1) {
        perror("semop");
        exit(1);
    }

    /* 写入数据 */
    strcpy(shmaddr, "Hello, world!");

    /* 读取数据 */
    printf("%s\n", shmaddr);

    /* 释放信号量 */
    sembuf.sem_num = 0;
    sembuf.sem_op = 1;
    sembuf.sem_flg = SEM_UNDO;
    if (semop(semid, &sembuf, 1) == -1) {
        perror("semop");
        exit(1);
    }

    /* 解除共享内存映射 */
    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;
}

Linux共享内存和信号灯实现进程同步

在Linux中，共享内存和信号量都是用来实现进程间通信和同步的机制。

共享内存是指多个进程可以访问同一块物理内存，这就允许多个进程可以共享数据，从而实现数据的共享和同步。共享内存的使用需要注意进程间的互斥和同步问题，否则会出现数据竞争等问题。

信号量是一种计数器，用于同步不同进程之间的访问。每个进程需要在访问共享资源之前获取信号量，如果信号量的计数器为0，则进程会被阻塞，直到其他进程释放了资源并增加了信号量计数器的值。当进程完成对资源的访问后，它需要释放信号量，这样其他进程才能获取资源并继续执行。

下面是一个简单的使用共享内存和信号量实现进程同步的示例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <string.h>

#define SHM_SIZE 1024
#define SEM_KEY 1234

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int main(int argc, char *argv[]) {
    int shmid, semid;
    char *shmaddr;
    union semun semarg;
    struct sembuf sembuf = {0, -1, SEM_UNDO}; //wait操作
    struct sembuf sembuf2 = {0, 1, SEM_UNDO}; //signal操作

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

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

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

    //设置信号量初始计数为1
    semarg.val = 1;
    if (semctl(semid, 0, SETVAL, semarg) == -1) {
        perror("semctl");
        exit(EXIT_FAILURE);
    }

    pid_t pid = fork();

    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (pid == 0) { //子进程写入共享内存
        strncpy(shmaddr, "hello", SHM_SIZE);

        //等待信号量
        semop(semid, &sembuf, 1);

        printf("child process read from shared memory: %s\n", shmaddr);

        //释放信号量
        semop(semid, &sembuf2, 1);

        //解除共享内存的附加
        if (shmdt(shmaddr) == -1) {
            perror("shmdt");
            exit(EXIT_FAILURE);
        }

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

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

        exit(EXIT_SUCCESS);
    } else { //父进程读取共享内存
        sleep(2);

        //等待信号量
        semop(semid, &sembuf, 1);

        printf("parent process read from shared memory: %s\n", shmaddr);

        //释放信号量
        semop(semid, &sembuf2, 1);

        //解除共享内存的附加
        if (shmdt(shmaddr) == -1) {
            perror("shmdt");
            exit(EXIT_FAILURE);
        }

        exit(EXIT_SUCCESS);
    }

    return 0;
}

在上述代码中，我们首先创建了一个大小为1024字节的共享内存和一个计数器初始值为1的信号量。子进程向共享内存写入数据，等待父进程读取数据完成后才能释放信号量；父进程则等待子进程写入数据，获取到信号量后读取数据并释放信号量。最后，我们删除共享内存和信号量。