Linux共享内存+信号量编程示例


写在前面：最近被一本超级垃圾的书折磨够呛，书中的例子全是错的，不过幸好我不是初学者的水平。有几个例子还不错，但是书上的代码编译都不过，我折腾了很长时间才修改正确，发上来留着以后复习用。

 

/**

 *  描述:通过共享内存进行进程间通信,使用信号量来同步.

 *  直接运行程序会启动服务端,会打印出shmid

 *  然后再启动并添加shmid这个参数即可启动客户端,然后即可进行通信

 *  Created on: 2010-4-29

 *      Author: QQwen

 *      开发环境: fc9 + eclipse c/c++

 */

#include <sys/types.h>

#include <sys/shm.h>

#include <sys/sem.h>

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <signal.h>

 

#define SHMDATASIZE 1000

#define BUFFERSIZE (SHMDATASIZE - sizeof(int))

#define SN_EMPTY 0

#define SN_FULL 1

#define TRUE 1

int deleteSemid = 0;

//必须自己定义一个union,否则编译不过

union semun

{

    int val;

    struct semid_ds *buf;

    unsigned short int *array;

    struct seminfo *__buf;

};

void server();

void client(int shmid);

void delete();

void sigdelete(int signum);

void locksem(int semid, int semnum);

void unlocksem(int semid, int semnum);

//void waitzero(int semid, int semnum);

void clientwrite(int shmid, int semid, char *buffer);

 

int safesemget(key_t key, int nsems, int semflg);

int safesemctl(int semid, int semnum, int cmd, union semun arg);

int safesemop(int semid, struct sembuf *sops, unsigned nsops);

int safeshmget(key_t key, int size, int shmflg);

void* safeshmat(int shmid, const void *shmaddr, int shmflg);

int safeshmctl(int shmid, int cmd, struct shmid_ds *buf);

 

int main(int argc, char *argv[])

{

    if (argc < 2)

    {//一个参数启动server

       server();

    }

    else

    {//多个参数启动client

       client(atoi(argv[1])); //atoi 把字符串转为整形数

    }

    return 0;

}

 

/**

 * 服务器端

 */

void server()

{

    union semun sunion; //与semctl中的cmd参数有关

    int semid, shmid;

    void *shmdata;

    char *buffer;

    semid = safesemget(IPC_PRIVATE, 2, SHM_R | SHM_W); //创建一个信号集

    deleteSemid = semid;

    atexit(&delete); //注册终止函数

    signal(SIGINT, &sigdelete); //设置某一信号的对应动作,程序终止(interrupt)信号, 在用户键入INTR字符(通常是Ctrl-C)时发出

    sunion.val = 1; //将一个二元信号量初始化为 1

    safesemctl(semid, SN_EMPTY, SETVAL, sunion); //SETVAL设置信号量集中的一个单独的信号量的值

    sunion.val = 0; //将一个二元信号量赋值为0

    safesemctl(semid, SN_FULL, SETVAL, sunion);

    shmid = safeshmget(IPC_PRIVATE, SHMDATASIZE, IPC_CREAT | SHM_R | SHM_W); //创建共享内存

    shmdata = safeshmat(shmid, 0, 0); //将该共享内存映射进进程的虚存空间

    safeshmctl(shmid, IPC_RMID, NULL); //将该共享内存标志为已销毁的，这样在使用完毕后，将被自动销毁

    *(int*) shmdata = semid; //将信号量的标识符写入共享内存，以通知其它的进程

    buffer = shmdata + sizeof(int); //buf数据的起始地址,因为第一个地址装载了semid

    printf("server is running with SHM id ** %d **\n", shmid);

    while (TRUE)

    {

       printf("waiting until full... ");

       fflush(stdout);

       locksem(semid, SN_FULL); //获得共享资源

       printf("done. \n");

       printf("message received: %s.\n", buffer);

       unlocksem(semid, SN_EMPTY);

    }

}

 

void client(int shmid)

{

    int semid;

    void *shmdata;

    char *buffer;

    shmdata = safeshmat(shmid, 0, 0); //将该共享内存映射进进程的虚存空间,这时共享内存的第一个数据是之前sercer写入的

    semid = *(int *) shmdata; //获得server创建的共享内存

    buffer = shmdata + sizeof(int); //buf数据的起始地址,因为第一个地址装载了semid

    printf("client operational: shm id is %d,sem id is %d\n", shmid, semid);

    while (TRUE)

    {

       char input[3];

       printf("\n menu \n 1.Send a message\n");

       printf("2.Exit\n");

       fgets(input, sizeof(input), stdin);

       switch (input[0])

       {

       case '1':

           clientwrite(shmid, semid, buffer);

           break;

       case '2':

           exit(0);

           break;

       }

    }

}

 

/**

 * 信号量集得创建与打开

 * @para key_t key   表示所创建或打开信号量集的键。

 * @para int nsems   表示创建的信号量集中的信号量的个数，该参数只在创建信号量集时有效。

 * @para int semflg  表示调用函数的操作类型，也可用于设置信号量集的访问权限，两者通过or表示

 * @return 如果成功，则返回信号量集的IPC标识符。如果失败，则返回-1

 */

int safesemget(key_t key, int nsems, int semflg)

{

    int retval;

    if ((retval = semget(key, nsems, semflg)) == -1)

    {

       printf("semget error: %s. \n", sys_errlist[errno]);

       exit(254);

    }

    return retval;

}

 

/**

 * 程序终止(interrupt)信号对应的函数

 */

void sigdelete(int signum)

{

    exit(0);

}

 

/**

 *  @para int semid      信号集的标识符，即是信号表的索引。

 *  @para int semnum  信号集的索引，用来存取信号集内的某个信号

 *  @para int cmd     需要执行的命令

 *  @para union semun arg

 *  @return    返回值：如果成功，则为一个正数。如果失败，则为-1

 */

int safesemctl(int semid, int semnum, int cmd, union semun arg)

{

    int retval;

    if ((retval = semctl(semid, semnum, cmd, arg)) == -1)

    {

       printf("semctl error: %s. \n", sys_errlist[errno]);

       exit(254);

    }

    return retval;

}

 

/**

 * 创建一块新的共享内存

 * @para key_t key       标识共享内存的键值

 * @para int size    建立共享内存的长度(byte)

 * @para int shmflg      标志

 * @retval 成功返回共享内存的标识符；不成功返回-1

 */

int safeshmget(key_t key, int size, int shmflg)

{

    int retval;

    if ((retval = shmget(key, size, shmflg)) == -1)

    {

       printf("shmget error: %s. \n", sys_errlist[errno]);

       exit(254);

    }

    return retval;

}

 

/**

 * 共享内存区对象映射到调用进程的地址空间

 * @para int shmid              共享内存id

 * @para const void *shmaddr 共享内存的起始地址(附加到进程的地址空间)

 * @para int shmflg             标志

 */

void* safeshmat(int shmid, const void *shmaddr, int shmflg)

{

    void* retval;

    if ((retval = shmat(shmid, shmaddr, shmflg)) == (void*) -1)

    {

       printf("shmat error: %s. \n", sys_errlist[errno]);

       exit(254);

    }

    return retval;

}

 

/**

 * 对共享内存的具体控制操作

 * @para int shmid       共享内存的引用标示符

 */

int safeshmctl(int shmid, int cmd, struct shmid_ds *buf)

{

    int retval;

    if ((retval = shmctl(shmid, cmd, buf)) == -1)

    {

       printf("shmctl error: %s. \n", sys_errlist[errno]);

       exit(254);

    }

    return retval;

}

 

/**

 * 锁定共享内存

 * @para int semid   信号量集的引用id

 * @para int semnum  要操作的信号量

 */

void locksem(int semid, int semnum)

{

    struct sembuf sb; //指定调用semop函数所做操作

    sb.sem_num = semnum; //指定要操作的信号量

    sb.sem_op = -1; //要执行的操作,<0 表示进程希望使用资源

    sb.sem_flg = SEM_UNDO; //标志

    safesemop(semid, &sb, 1);

}

 

void unlocksem(int semid, int semnum)

{

    struct sembuf sb; //指定调用semop函数所做操作

    sb.sem_num = semnum; //指定要操作的信号量

    sb.sem_op = 1; //要执行的操作,>0 表示對進程的资源使用完畢,交回该资源

    sb.sem_flg = SEM_UNDO; //标志

    safesemop(semid, &sb, 1);

}

 

/*

 void waitzero(int semid,int semnum)

 {

 struct sembuf sb;   //指定调用semop函数所做操作

 sb.sem_num=semnum;  //指定要操作的信号量

 sb.sem_op=0;     //需要等待 直至sem_base.semval变为0

 sb.sem_flg=0; //标志

 safesemop(semid,&sb,1);

 }

 */

/**

 * 对信号量的操作

 * @para int semid       信号量集的引用id

 * @para struct sembuf *sops 用于指定调用semop函数所做的操作

 * @para unsigned nsops     指定操作函数的个数

 */

int safesemop(int semid, struct sembuf *sops, unsigned nsops)

{

    int retval;

    if ((retval = semop(semid, sops, nsops)) == -1)

    {

       printf("semop error: %s. \n", sys_errlist[errno]);

       exit(254);

    }

    return retval;

}

 

void clientwrite(int shmid, int semid, char *buffer)

{

    printf("waiting until empty...");

    fflush(stdout);

    locksem(semid, SN_EMPTY); //这个过程是在等待共享内存资源

    printf("done.\n");

    printf("enter message: ");

    fgets(buffer, BUFFERSIZE, stdin);

    unlocksem(semid, SN_FULL);

}

 

void delete()

{

    printf("\n master exiting; deleting semaphore %d. \n", deleteSemid);

    if ((semctl(deleteSemid, 0, IPC_RMID, 0)) == -1) //IPC_RMID删除该信号量

       printf("error releasing semaphore. \n");

}

相关内容