/**
* 描述 : 通过共享内存进行进程间通信 , 使用信号量来同步 .
* 直接运行程序会启动服务端 , 会打印出 shmid
* 然后再启动并添加 shmid 这个参数即可启动客户端 , 然后即可进行通信
*/
#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); // 创建共享内存
// shmat 返回指向共享存储的指针
shmdata = safeshmat(shmid, 0, 0); // 将该共享内存映射进进程的虚存空间
safeshmctl(shmid, IPC_RMID, NULL); // ????将该共享内存标志为已销毁的，这样在使用完毕后，将被自动销毁
printf("after IPC_RMID shmat return value is: %d \n", shmat(shmid, 0, 0)); //上面共享内存销毁后，shmat仍可用，与apue描述不符，说明这个版本linux内核实现不同20190709
*( int *) shmdata = semid; // 将信号量的标识符写入共享内存，以通知其它的进程
buffer = shmdata + sizeof ( int ); //buf 数据的起始地址 , 因为第一个地址装载了 semid
printf ( "server is running with SHM id ** %d **\n" , shmid);
while (TRUE)
{
int semncnt = semctl(semid, SN_FULL, GETNCNT, NULL);
printf("server SN_FULL semcnt is:%d\n", semncnt);
printf ( "waiting until full... " );
fflush (stdout);
locksem(semid, SN_FULL); // 获得共享资源
// 此时进程进入休眠，因为前面有semctl(semid, SN_FULL, SETVAL, sunion)其value值为0，
// 故执行locksem(semid, SN_FULL)使其休眠
/**
* 锁定共享内存
* @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);
//}
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); // 将该共享内存映射进进程的虚存空间 , 这时共享内存的第一个数据是之前 server 写入的
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)
{
int semncnt = semctl(semid, SN_FULL, GETNCNT, NULL);
printf("client SN_FULL semcnt is:%d\n", semncnt);
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" );
}
IPC 信号量 共享内存示例：等您坐沙发呢！