信号量学习 & 共享内存同步

刚刚这篇文章学习了共享内存：http://www.cnblogs.com/charlesblc/p/6142139.html

里面也提到了共享内存，自己不进行同步，需要其他手段比如信号量来进行。那么现在就学习信号量咯。

共享内存实际编程中，

应该使用信号量，

或通过传递消息(使用管道或IPC消息)，

或生成信号

的方法来提供读写之间的更有效的同步机制。

 

方法一、利用POSIX有名信号灯实现共享内存的同步

方法二、利用POSIX无名信号灯实现共享内存的同步

 

方法三、利用System V的信号灯实现共享内存的同步

方法四、利用信号实现共享内存的同步

 

信号灯(semaphore)，也叫信号量。它是不同进程间或一个给定进程内部不同线程间同步的机制。信号灯包括posix有名信号灯、 posix基于内存的信号灯(无名信号灯)和System V信号灯(IPC对象)

方法一、利用POSIX有名信号灯实现共享内存的同步

有名信号量既可用于线程间的同步，又可用于进程间的同步。

两个进程，对同一个共享内存读写，可利用有名信号量来进行同步。一个进程写，另一个进程读，利用两个有名信号量semr, semw。semr信号量控制能否读，初始化为0。 semw信号量控制能否写，初始为1。

读共享内存的程序示例代码如下

semr = sem_open("mysem_r", O_CREAT | O_RDWR , , 0);
        if (semr == SEM_FAILED)
        {
                printf("errno=%d\n", errno);
                return -;
        }

        semw = sem_open("mysem_w", O_CREAT | O_RDWR, , 1);
        if (semw == SEM_FAILED)
        {
                printf("errno=%d\n", errno);
                return -;
        }

        if ((shmid = shmget(key, MAXSIZE,  | IPC_CREAT)) == -)
        {
                perror("semget");
                exit(-);
        }

        if ((shmadd = (char *)shmat(shmid, NULL, )) == (char *)(-))
        {
                perror("shmat");
                exit(-);
        }

        while ()
        {
                sem_wait(semr);
                printf("%s\n", shmadd);
                sem_post(semw);
        }

写共享内存的程序示例代码如下

。。。。。。
        //同读的程序
        while ()
        {
                sem_wait(semw);
                printf(">");
                fgets(shmadd, MAXSIZE, stdin);
                sem_post(semr);
        }

方法二、利用POSIX无名信号灯实现共享内存的同步

POSIX无名信号量是基于内存的信号量，可以用于线程间同步也可以用于进程间同步。若实现进程间同步，需要在共享内存中来创建无名信号量。

因此，共享内存需要定义以下的结构体。

typedef struct
        {
                sem_t semr;
                sem_t semw;
                char buf[MAXSIZE];
        }SHM;

无名信号量的数据类型是：sem_t;

(1)初始化函数：

int sem_init(sem_t *sem, int pshared, unsigned value);

该函数将sem引用的无名信号量初始化为value，该参数表示拥有资源的个数，不能为负数。pshared指定为0，表示信号量只能由初始化这个信号量的进程使用，不能在进程间使用。一个无名信号量在被使用前必须先初始化。

该函数如果不成功将返回-1并设置errno。

(2)销毁函数：

int sem_destroy(sem_t *sem);

该函数用来销毁一个已经被初始化过的无名信号量。

如果不成功返回-1并设置errno。

(3)信号量操作函数：

intsem_wait(sem_t *sem);

该函数用来获取资源，如果信号量为0，表示这时没有相应资源空闲，那么调用线程就将挂起，直到有空闲资源可以获取。如果信号量不为0，那么表示这时有相应资源可用，那么将信号量减1，并返回，表示获取一个资源。

如果成功返回0，如果不成功，函数返回-1，并设置errno。值得注意的是，该函数是信号可中断的，当正在等待资源的线程收到信号(可捕捉信号)时，该函数返回-1并把errno设置为EINTR。所以，必须在被信号中断后重新启动该函数，简单代码如下：

while((-==sem_wait(&sem))&&(EINTR==errno));

sem_trywait(sem_t *sem);

该函数试图获取资源，当信号量为0时，它不阻塞，直接返回-1并将errno置为EAGAIN。

sem_post(sem_t *sem);

该函数实现了信号量的signal操作，如果没有线程阻塞在该sem上，表示没有线程等待该资源，这时该函数就对信号量的值进行增1操作，表示同类资源多增加了一个。如果至少有一个线程阻塞在该sem上，表示有线程等待资源，信号量为0，这时该函数保持信号量为0不变，并使某个阻塞在该sem上的线程从sem_wait函数中返回，表示有一个可用资源到达，并被某个线程占有，所以信号量还是为0。

读、写程序流程如下图所示。

方法三、利用System V的信号灯实现共享内存的同步

System V的信号灯是一个或者多个信号灯的一个集合。其中的每一个都是单独的计数信号灯。而Posix信号灯指的是单个计数信号灯

System V 信号灯由内核维护，主要函数semget，semop，semctl 。

一个进程写，另一个进程读，信号灯集中有两个信号灯，下标0代表能否读，初始化为0。 下标1代表能否写，初始为1。

程序流程如下：

写的流程和前边的类似。

方法四、利用信号实现共享内存的同步

信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式。利用信号也可以实现共享内存的同步。

思路：

reader和writer通过信号通信必须获取对方的进程号，可利用共享内存保存双方的进程号。

reader和writer运行的顺序不确定，可约定先运行的进程创建共享内存并初始化。

利用pause, kill, signal等函数可以实现该程序（流程和前边类似）。

还有这篇：

http://blog.csdn.net/ljianhui/article/details/10243617

信号量的工作原理

由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：

P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行

V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1.

 

它们声明在头文件sys/sem.h中。

 

1、semget函数

它的作用是创建一个新信号量或取得一个已有信号量，原型为：

int semget(key_t key, int num_sems, int sem_flags);  

第一个参数key是整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget函数并提供一个键，再由系统生成一个相应的信号标识符（semget函数的返回值），只有semget函数才直接使用信号量键，所有其他的信号量函数使用由semget函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。

 

第二个参数num_sems指定需要的信号量数目，它的值几乎总是1。

 

第三个参数sem_flags是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。

 

semget函数成功返回一个相应信号标识符（非零），失败返回-1.

2、semop函数

它的作用是改变信号量的值，原型为：

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

sem_id是由semget返回的信号量标识符，sembuf结构的定义如下：

struct sembuf{
    short sem_num;//除非使用一组信号量，否则它为0
    short sem_op;//信号量在一次操作中需要改变的数据，通常是两个数，一个是-1，即P（等待）操作，
                    //一个是+1，即V（发送信号）操作。
    short sem_flg;//通常为SEM_UNDO,使操作系统跟踪信号量，
                    //并在进程没有释放该信号量而终止时，操作系统释放信号量
};  

3、semctl函数

该函数用来直接控制信号量信息，它的原型为：

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

如果有第四个参数，它通常是一个union semum结构，定义如下：

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

前两个参数与前面一个函数中的一样，command通常是下面两个值中的其中一个

SETVAL：用来把信号量初始化为一个已知的值。p 这个值通过union semun中的val成员设置，其作用是在信号量第一次使用前对它进行设置。

IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。

 

 

四、进程使用信号量通信

下面使用一个例子来说明进程间如何使用信号量来进行通信，这个例子是两个相同的程序同时向屏幕输出数据，我们可以看到如何使用信号量来使两个进程协调工作，使同一时间只有一个进程可以向屏幕输出数据。

注意，如果程序是第一次被调用（为了区分，第一次调用程序时带一个要输出到屏幕中的字符作为一个参数），则需要调用set_semvalue函数初始化信号并将message字符设置为传递给程序的参数的第一个字符，同时第一个启动的进程还负责信号量的删除工作。

如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

代码如下：

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/sem.h>

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

static int sem_id = ;

static int set_semvalue();
static void del_semvalue();
static int semaphore_p();
static int semaphore_v();

int main(int argc, char *argv[])
{
    char message = 'X';
    int i = ;

    //创建信号量
    sem_id = semget((key_t), ,  | IPC_CREAT);

    if(argc > )
    {
        //程序第一次被调用，初始化信号量
        if(!set_semvalue())
        {
            fprintf(stderr, "Failed to initialize semaphore\n");
            exit(EXIT_FAILURE);
        }
        //设置要输出到屏幕中的信息，即其参数的第一个字符
        message = argv[][];
        sleep();
    }
    for(i = ; i < ; ++i)
    {
        //进入临界区
        if(!semaphore_p())
            exit(EXIT_FAILURE);
        //向屏幕中输出数据
        printf("%c", message);
        //清理缓冲区，然后休眠随机时间
        fflush(stdout);
        sleep(rand() % );
        //离开临界区前再一次向屏幕输出数据
        printf("%c", message);
        fflush(stdout);
        //离开临界区，休眠随机时间后继续循环
        if(!semaphore_v())
            exit(EXIT_FAILURE);
        sleep(rand() % );
    }

    sleep();
    printf("\n%d - finished\n", getpid());

    if(argc > )
    {
        //如果程序是第一次被调用，则在退出前删除信号量
        sleep();
        del_semvalue();
    }
    exit(EXIT_SUCCESS);
}

static int set_semvalue()
{
    //用于初始化信号量，在使用信号量前必须这样做
    union semun sem_union;

    sem_union.val = ;
    if(semctl(sem_id, , SETVAL, sem_union) == -)
        return ;
    return ;
}

static void del_semvalue()
{
    //删除信号量
    union semun sem_union;

    if(semctl(sem_id, , IPC_RMID, sem_union) == -)
        fprintf(stderr, "Failed to delete semaphore\n");
}

static int semaphore_p()
{
    //对信号量做减1操作，即等待P（sv）
    struct sembuf sem_b;
    sem_b.sem_num = ;
    sem_b.sem_op = -;//P()
    sem_b.sem_flg = SEM_UNDO;
    if(semop(sem_id, &sem_b, ) == -)
    {
        fprintf(stderr, "semaphore_p failed\n");
        return ;
    }
    return ;
}

static int semaphore_v()
{
    //这是一个释放操作，它使信号量变为可用，即发送信号V（sv）
    struct sembuf sem_b;
    sem_b.sem_num = ;
    sem_b.sem_op = ;//V()
    sem_b.sem_flg = SEM_UNDO;
    if(semop(sem_id, &sem_b, ) == -)
    {
        fprintf(stderr, "semaphore_v failed\n");
        return ;
    }
    return ;
}

上面程序，起两个进程，X和O总是成对出现的，也就是说sleep的时候没有被打断。

六、信号量的总结

信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。