共享内存通过信号量控制读写

信号量函数定义如下：

#include
int semctl(int sem_id, int sem_num, int command, ...);
int semget(key_t key, int num_sems, int sem_flags);
int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);
semop

函数semop用来改变信号量的值：

int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);

第一个参数，sem_id，是由semget函数所返回的信号量标识符。第二个参数，sem_ops，是一个指向结构数组的指针，其中的每一个结构至少包含下列成员：

struct sembuf {
    short sem_num;
    short sem_op;
    short sem_flg;
}

第一个成员，sem_num，是信号量数目，通常为0，除非我们正在使用一个信号量数组。sem_op成员是信号量的变化量值。（我们可以以任何量改变信 号量值，而不只是1）通常情况下中使用两个值，-1是我们的P操作，用来等待一个信号量变得可用，而+1是我们的V操作，用来通知一个信号量可用。

最后一个成员，sem_flg，通常设置为SEM_UNDO。这会使得操作系统跟踪当前进程对信号量所做的改变，而且如果进程终止而没有释放这个信号量， 如果信号量为这个进程所占有，这个标记可以使得操作系统自动释放这个信号量。将sem_flg设置为SEM_UNDO是一个好习惯，除非我们需要不同的行 为。如果我们确实变我们需要一个不同的值而不是SEM_UNDO，一致性是十分重要的，否则我们就会变得十分迷惑，当我们的进程退出时，内核是否会尝试清 理我们的信号量。

semop的所用动作会同时作用，从而避免多个信号量的使用所引起的竞争条件。我们可以在手册页中了解关于semop处理更为详细的信息。

semctl

semctl函数允许信号量信息的直接控制：

int semctl(int sem_id, int sem_num, int command, ...);

第一个参数，sem_id，是由semget所获得的信号量标识符。sem_num参数是信号量数目。当我们使用信号量数组时会用到这个参数。通常，如果 这是第一个且是唯一的一个信号量，这个值为0。command参数是要执行的动作，而如果提供了额外的参数，则是unionsemun，根据X/OPEN 规范，这个参数至少包括下列参数：

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

许多版本的Linux在头文件(通常为sem.h)中定义了semun联合，尽管X/Open确认说我们必须定义我们自己的联合。如果我们发现我们确实需 要定义我们自己的联合，我们可以查看semctl手册页了解定义。如果有这样的情况，建议使用手册页中提供的定义，尽管这个定义与上面的有区别。

有多个不同的command值可以用于semctl。在这里我们描述两个会经常用到的值。要了解semctl功能的详细信息，我们应该查看手册页。

这两个通常的command值为：

SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
IPC_RMID：当信号量不再需要时用于删除一个信号量标识。

semctl函数依据command参数会返回不同的值。对于SETVAL与IPC_RMID，如果成功则会返回0，否则会返回-1。

信号量与共享内存的共同使用例子：

write 端：

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

typedef struct
{
    char buf[1024];
}memory;

int main(int argc, const char *argv[])
{
    key_t key;
    memory *p = NULL;
    int shmid;
    int create_flag = 0;
    int sem_id;

    if ((key = ftok(".", 'a')) < 0)
    {
        perror("failed to get key");
        exit(-1);
    }

    if ((sem_id = semget(key, 1, 0666 | IPC_CREAT | IPC_EXCL)) < 0)
    {
        if (errno == EEXIST)
        {
            if ((sem_id = semget(key, 1, 0666)) < 0)
            {
                perror("failed to semget");
                exit(-1);
            }
        }
    }

    init_sem(sem_id, 0);

    if ((shmid = shmget(key, sizeof(memory), 0666 | IPC_CREAT | IPC_EXCL)) < 0)
    {
        if (errno == EEXIST)
        {
            if ((shmid = shmget(key, sizeof(memory), 0666)) < 0)
            {
                perror("failed to shmget memory");
                exit(-1);
            }
        }
        else
        {
            perror("failed to shmget");
            exit(-1);
        }
    }
    else
        create_flag = 1;

    if ((p = shmat(shmid, NULL, 0)) == (void *)(-1))
    {
        perror("failed to shmat memory");
        exit(-1);
    }

    while(1)
    {
        printf(">");
        fgets(p->buf, sizeof(p->buf), stdin);
        p->buf[strlen(p->buf) - 1] = 0;

        sem_v(sem_id);

        if (strncmp(p->buf, "quit", 4) == 0)
            break;
    }

    if (create_flag == 1)
    {
        if (shmdt(p) < 0)
        {
            perror("failed to shmdt memory");
            exit(-1);
        }

        if (shmctl(shmid, IPC_RMID, NULL) == -1)
        {
            perror("failed to delete share memory");
            exit(-1);
        }

        delete_sem(sem_id);
    }

    return 0;
}

read 端：

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

    typedef struct
    {
        char buf[1024];
    }memory;

    int main(int argc, const char *argv[])
    {
        key_t key;
        int shmid;
        memory *p = NULL;
        int create_flag = 0;
        int sem_id;

        if ((key = ftok(".", 'a')) < 0)
        {
            perror("failed to get key");
            exit(-1);
        }

        if ((sem_id = semget(key, 1, 0666 | IPC_CREAT | IPC_EXCL)) < 0)
        {
            if (errno == EEXIST)
            {
                if ((sem_id = semget(key, 1, 0666)) < 0)
                {
                    perror("failed to semget");
                    exit(-1);
                }
            }
        }

        init_sem(sem_id, 0);

        if ((shmid = shmget(key, sizeof(memory), 0666 | IPC_CREAT | IPC_EXCL)) < 0)
        {
            if (errno == EEXIST)
            {
                if ((shmid = shmget(key, sizeof(memory), 0666)) < 0)
                {
                    perror("failed to create share memory");
                    exit(-1);
                }
            }
            else
            {
                perror("failed to shmget");
                exit(-1);
            }
        }
        else
            create_flag = 1;

        if ((p = shmat(shmid, NULL, 0)) == (void *)(-1))
        {
            perror("failed to shmat");
            exit(-1);
        }

        while(1)
        {
            sem_p(sem_id);

            if (strncmp(p->buf, "quit", 4) == 0)
                break;

            printf("recv: %s\n", p->buf);

        }

        if (create_flag == 1)
        {
            if (shmdt(p) < 0)
            {
                perror("failed to shmdt");
                exit(-1);
            }

            if (shmctl(shmid, IPC_RMID, NULL) == -1)
            {
                perror("failed to delete share memory");
                exit(-1);
            }

            delete_sem(sem_id);
        }

        return 0;
    }

信号量的封装：

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

    void init_sem(int , int );
    void delete_sem(int );
    void sem_p(int );
    void sem_v(int );

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

    void init_sem(int sem_id, int init_value)
    {
        union semun sem_union;

        sem_union.val = init_value;

        if (semctl(sem_id, 0, SETVAL, sem_union) < 0)
        {
            perror("failed to init_sem");
            exit(-1);
        }

        return ;
    }

    void delete_sem(int sem_id)
    {
        union semun sem_union;

        if (semctl(sem_id, 0, IPC_RMID, sem_union) < 0)
        {
            perror("failed to delete_sem");
            exit(-1);
        }

        return ;
    }

    void sem_p(int sem_id)
    {
        struct sembuf sem_b;

        sem_b.sem_num = 0;
        sem_b.sem_op = -1;
        sem_b.sem_flg = SEM_UNDO;

        if (semop(sem_id, &sem_b, 1) < 0)
        {
            perror("failed to sem_p");
            exit(-1);
        }

        return;
    }

    void sem_v(int sem_id)
    {
        struct sembuf sem_b;

        sem_b.sem_num = 0;
        sem_b.sem_op = 1;
        sem_b.sem_flg = SEM_UNDO;

        if (semop(sem_id, &sem_b, 1) < 0)
        {
            perror("failed to sem_v");
            exit(-1);
        }

        return ;
    }