LinuxC编程进程间的通信总结

本文参考《LinuxC编程实战》

前言

进程的空间地址是各自独立的，因此进程间进行数据交流就需要特定的通信机制，在大型应用中往往需要多个进程同时工作，这就需要进程间的数据交流和配合。
进程间的通信方式有：

• 管道（pipe）：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程间的亲缘关系一般指父子进程关系。
• 有名管道（named pipe）：有名管道也是半双工管道通信方式，但是它允许不具有亲缘关系的进程间的通信。
• 信号量（semophore）：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程在访问共享资源时，其他进程也在访问，因此主要作为进程间或同一进程间不同线程之间的同步机制。
• 消息队列（message queue）：消息队列是消息地列表。消息列表克服了信号传递信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。
• 信号（signal）：信号用于通知接收进程某个事件已经发生。在我的另一篇博客有总结：信号总结
• 共享内存（shared memory）：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建但多个进程可以访问。它往往与其他通信机制如信号量配合使用，用来实现进程间的同步和通信。
• 套接字（socket）：套接口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同机器间的进程通信。

管道

管道是一种两个进程间进行通信的机制，它有一些局限性：

• 管道只能单项通信，及只能由一个进程流向另一个进程，如果要实现双向通信就要创建两个管道。
• 管道只能用于父子进程或兄弟进程间的通信。
• 管道没有名字，管道的缓存区大小PIPE_BUF受限，管道传递的是无格式的字节流。
  管道就想是一个特殊的文件，在创建文件时系统为它设置了一个文件描述符，进程把管道当作文件进行操作。在创建管道是系统为管道分配了一个页面作为数据缓存区，进程通过对这个数据缓存区读写进行通信，一个进程写入数据，另一个进程读出数据。
  管道的创建和读写
  管道的创建使用的是pipe函数，该函数如果调用成功返回0,并且数组中包含两个新的文件描述符;如果失败，返回-1.函数原型为：

#include <unistd.h>
int pipe(int fd[2]);

管道两端分别用描述符fd[0],fd[1]来描述。需要注意的是管道两端的任务是固定的，一端只能用于读，由描述符fd[0]表示，为读端;另一端只能用于写，由描述符fd[1]表示，为写端;如果试图从读端写入会出错。管道是一种文件，所以可以使用文件的I/O函数，如read(),write()等;
管道的使用方法：
（1）.创建一个管道;
（2）.创建子进程;
（3）.父进程关闭管道读端，负责写入数据;
（4）.子进程关闭管道写端，负责读出数据;
例：pipe.c

/*************************************************
 * 用管道创建单向传递功能
 * **********************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

void read_from_pipe(int fd)       //读管道
{
    char message[100];
    read(fd, message, 100);
    printf("read from pipe:%s",message);
}

void write_to_pipe(int fd)       //写管道
{
    char *message = "Hello, pipe!\n";
    write(fd, message,strlen(message)+1);
}

int main()
{
    int fd[2];
    pid_t pid;
    int stat_val;

    if(pipe(fd))
    {
        printf("create pipe failed!\n");
        exit(1);
    }

    pid = fork();
    switch(pid)
    {
        case -1:
        {
            printf("fork error!\n");
            exit(1);
        }
        case 0:
        {
            close(fd[1]);      //子进程关闭fd1
            read_from_pipe(fd[0]);
            exit(0);
        }
        default:
        {
            close(fd[0]);             //父进程关闭fd2
            write_to_pipe(fd[1]); 
            wait(&stat_val);          //等待子进程
            exit(0);
        }
    }

    return 0;
}

dual_pipe.c

/*************************************************
 * 用两个管道创建双向传递功能
 * **********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

void child_rw_pipe(int readfd, int writefd)
{
    char *message1 = "from child process!\n";
    write(writefd, message1,strlen(message1)+1);                    //写入管道

    char message2[100];
    read(readfd, message2,100);                                     //读管道
    printf("child process read from pipe:%s",message2);
}

void parent_rw_pipe(int readfd, int writefd)
{
    char *message1 = "from parent process!\n";
    write(writefd, message1,strlen(message1)+1);                    //写管道

    char message2[100];
    read(readfd, message2,100);
    printf("parent process read from pipe:%s",message2);            //读管道
}

int main()
{
    int pipe1[2],pipe2[2];
    pid_t pid;
    int stat_val;

    printf("realize full-duplex communication:\n\n");
    if(pipe(pipe1))                                                 //创建管道pipe1 父写子读
    {
        printf("pipe1 failed!\n");
        exit(1);
    }
    if(pipe(pipe2))                                                 //创建管道pipe2 父读子写
    {
        printf("pipe2 failed!\n");
        exit(1);
    }

    pid = fork();
    switch(pid)
    {
        case -1:
        {
            printf("fork error!\n");
            exit(1);
        }
        case 0:
        {
            //子进程
            close(pipe1[1]);                       //关闭写
            close(pipe2[0]);                       //关闭读
            child_rw_pipe(pipe1[0],pipe2[1]);
            exit(0);
        }
        default :
        {
            close(pipe1[0]);                       //关闭读
            close(pipe2[1]);                       //关闭写
            parent_rw_pipe(pipe2[0],pipe1[1]);
            wait(&stat_val);
            exit(0);
        }
    }
}

有名管道

管道有一个局限性是没有名字，因此只能在具有亲缘关系的进程间才可以使用，有名管道（named pipe或FIFO）的出现客服了这一限制。FIFO与管道不同之处在于它提供了一个路径名与之关联，以FIFO的文件形式储存于文件系统中。有名管道是一个设备文件，因此可以不局限与具有亲缘关系才能访问。
有名管道的创建和读写
创建有名管道的方法有两种，一种是在shell下创建，另一种是在程序中用函数创建。shell中使用mknod或者mkfifo命令，例如：

mknod namedpipe

创建有名管道的函数有两个：mknod和mkfifo。函数原型为：

#include <sys/types.h>
#include <sys/sta.h>
int mknod(const char *path, mode_t mod, dev_t dev);
int mkfifo(const char *path, mode_t mode);

函数mknod中path参数为创建的有名管道的全路径名;mod为创建有名管道的模式，指名其权限;dev为设备值，该值文件创建的类型，它只在创建设备文件时才会用到。这两个函数调用成功返回0,失败返回-1。mkfifo的参数与mknod的前两个参数一样。
使用时如下：

//1.0
umask(0);
if(mknod("/tmp/fifo",S_IFIFO | 0666, 0) == -1)
{
	perror("mknod error!");
	exit(1);
}

//2.0
umask(0);
if(mkfifo("/tmp/fifo",S_IFIFO | 0666) == -1)
{
	perror("mknod error!");
	exit(1);
}

umask(0)用于在创建新文件时屏蔽掉不应该有的访问允许权限。S_IFIFO | 0666指创建一个有名管道且存取权限为0666。
下面我们用一个有名管道实现两个无亲缘关系的进程间的通信：
procread.c

/*************************************
 * 先运行procwrite.c文件，写入有名管道
 * 后运行procread.c文件，读出有名管道中的内容
 * 如果已经有了有名管道myfifo则先删除它
 * **********************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define FIFO_NAME       "myfifo"
#define BUF_SIZE        1024

int main()
{
    int fd;
    char buf[BUF_SIZE];

    umask(0);                           //给予最大权限
    fd = open(FIFO_NAME, O_RDONLY);      //以只读的方式打开文件myfifo
    read(fd, buf, BUF_SIZE);             //读取文件myfifo
    printf("Read content: %s\n", buf);
    close(fd);                           //关闭文件

    return 0;

procwrite.c

/*************************************
 * 先运行procwrite.c文件，写入有名管道
 * 后运行procread.c文件，读出有名管道中的内容
 * 如果已经有了有名管道myfifo则先删除它
 * **********************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#define FIFO_NAME       "myfifo"
#define BUF_SIZE        1024

int main()
{
    int fd;
    char buf[BUF_SIZE] = "有名管道";
    char A[100] = "ABC";

    umask(0);
    if(mkfifo(FIFO_NAME, S_IFIFO | 0666) == -1)          //创建一个有名管道
    {
        perror("mkfifo error!");
        exit(1);
    }
    if((fd = open(FIFO_NAME, O_WRONLY)) == -1)           //以写的方式打开一个有名管道
    {
        perror("open error!");
        exit(1);
    }
    write(fd, buf,strlen(buf)+1);                        //向管道内写入内容,并等待na_pipe进程读出myfifo中的内容
    write(fd,A,strlen(A)+1);                             //该内容没有被写入或者读出
    printf("na_pipe 读出完毕\n");
    
    close(fd);                                           //关闭
    
    return 0;
}

如果要实现双向通信需要使用两个有名管道。

消息队列

概念
消息队列是一个存放在内核中的消息链表，每个消息队列由消息队列标识符标识。与管道不同的是消息队列存放在内核中，只有在内核重启(即操作系统重启)或者显式地删除-一个消息队列时，该消息队列才会被真正删除。
操作消息队列时，需要用到- -些数据结构，熟悉这些数据结构是掌握消息队列的关键。下面介绍几个重要的数据结构。

1.消息缓冲结构

向消息队列发送消息时，必须组成合理的数据结构。Linux系统定义了-一个模板数据结构msgbuf:

#include <linux/msg.h>
struct msgbuf{
	long mtype;
	char mtext[1];
}

结构体中的mtype字段代表消息类型。给消息指定类型，可以使得消息在一一个队列中重复使用。nmtext字段指消息内容。
注意: mtext虽然定义为char类型，并不代表消息只能是一个字符，消息内容可以为任意类型，由用户根据需要定义。如下面就是用户定义的一个消息结构:

struct mymsgbuf{
	long mtype;
	struct stdudent stu;
};

消息队列的大小受到MSGMAX的限制，MSGMAX为最大值。
2.msqid_ds内核数据结构
每个消息队列都有一个msqid_ds结构体，此结构体保存着该消息队列当前的状态信息。

struct msqid_ds{
	struct ipc_perm msg_perm;       //保存了消息队列的存取权限和队列用户ID，组ID等信息
	struct msg *msg_first;          //指向队列中第一条消息
    struct msg *msg_last;           //指向队列中最后一条消息
    __kernel_time_t msg_stime;      //向消息队列发送最后一条信息的时间
    __kernel_time_t msg_rtime;      //从消息队列中读取最后一条消息的时间
    __kernel_time_t msg_ctime;      //最后一个变更消息队列时间
    unsigned long  msg_lcbytes;    
    unsigned long  msg_lqbytes;     
    unsigned short msg_cbytes;      //消息队列中所有消息所占的字节数
    unsigned short msg_qnum;        //消息队列中消息的数目
    unsigned short msg_qbytes;      //消息队列的最大字节数
    __kernel_ipc_pid_t msg_lspid;   //向消息队列发出最后一条消息的进程ID
    __kernel_ipc_pid_t msg_lrpid;   //从消息队列读出最后一条消息的进程ID
};

3. ipc_perm内核数据结构
   结构体ipc_perm保存着消息队列的一些重要信息，如保存了消息队列的存取权限和队列用户ID，组ID等信息：

#include <linux/ipc.h>
struct ipc_perm{
	__kernel_key_t     key;    //创建消息队列用到的健值key
	__kernel_uid_t     uid;    //消息队列的用户ID
	__kernel_gid_t     gid;    //消息队列的组ID
	__kernel_uid_t     cuid;   //创建消息队列的进程用户ID
	__kernel_gid_t     cgid;   //创建消息队列的进程组ID
	__kernel_ mode_t   mode;
	__unsigned_short   seq;
}

消息队列的创建
消息队列是随着内核的存在而存在的，每个消息队列在系统范围内对应唯一的键值。要获取一个消息队列的描述符，只需提供该消息队列的键值及可，该键值通常由函数ftok返回，该函数原型为：

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);

参数pathname为路径，且一定要有访问权限;参数proj_id的值为1～255。
例如：
ftok.c

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

int main()
{
    int i;
    for(i = 1; i <= 5; i++)
    {
        printf("key[%d] = %ul\n", i, ftok(".",i));
        //ftok函数根据键值生成唯一的键值
    }

    return 0;
}

有了键值我们就可以根据键值创建或打开一个消息队列，函数为msgget，该函数调用成功返回一个消息队列描述符，错误返回-1,函数原型为：

int msgget(key_t key, int msgflg);

key参数为键值，msgflg为一个标志参数，它的取值有：

• IPC_CREATE：如果内核中不存在键值与key相等的消息对列，则新建一-个消息队列:如果存在这样的消息队列，返回该消息队列的描述符。

• IPC_ EXCL: 和IPC _CREATE -起使用，如果对应键值的消息队列已经存在，则出错。
  注意：IPC_EXCL需要和IPC_CREATE一起使用否者无意义。
  写消息队列
  用函数msgsnd向消息队列发送（写）数据，该函数调用成功返回0,错误返回-1,该函数原型为：

#include <sys/msg.h>
int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int magflg);

各参数含义如下：

• msqid：函数向msgid标识的消息队列发送一个消息
• msgp：msgp指向发送的消息
• msgsz：要发送消息的大小，不包含消息类型占用的4个字节
• magflg：操作标志位，可以设置为0和IPC_NOWAIT。如果是0,则当消息队列已满的时候，msgsnd 将会阻塞，直到消息可以写进消息队列:如果magflg 为IPC_ NOWAIT,当消息队列已满的时候，msgsnd 函数将不等待立即返回。
  例：
  sendmsg.c

/***********************************
 * 创建一个消息队列，并写入消息
 * 编译运行该文件
 * 在shell下输入ipcs命令
 * 系统内部生成了一个消息队列Message Queues，其中含有一条消息
 * ********************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

#define BUF_SIZE             256
#define PROJ_ID              32
#define PATH_NAME            "."

int main()
{
    struct mymsgbuf{
        long msgtype;
        char ctrlstring[BUF_SIZE];
    }msgbuffer;
    int   qid;                          //消息队列标识符
    int   msglen;
    key_t msgkey;

    if((msgkey = ftok(PATH_NAME, PROJ_ID)) == -1)  //获取键值
    {
        perror("ftok error!\n");
        exit(1);
    }

    if((qid = msgget(msgkey, IPC_CREAT | 0660)) == -1)  //创建消息队列
    {
        perror("msgget error!\n");
        exit(1);
    }

    msgbuffer.msgtype = 3;
    strcpy(msgbuffer.ctrlstring, "Hello,message queue");
    msglen = sizeof(struct mymsgbuf) - 4;
    if(msgsnd(qid,&msgbuffer, msglen, 0) == -1)        //将msgbuffer结构中的信息写入消息中
    {
        perror("msgget error!\n");
        exit(1);
    }

    return 0;
}

读消息队列
将消息写入消息队列或就可以用函数msgecv将消息读出，该函数调用成功返回读出的实际字节数，错误返回-1,函数原型为：

#include <sys/msg.h>
int msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz, long int msgtyp, int msgflg);

参数含义为：

• msqid:消息队列描述符。
• 读取的消息存储到msgp指向的消息结构中。
• msgsz:消息缓冲区的大小。
• msgtyp:为请求读取的消息类型。
• msgflg:操作标志位。msgflg 可以为IPC_NOWAIT, IPC_ EXCEPT,IPC_NOERROR
  3个常量。这些值的意义分别为: IPC_NOWAIT,如果没有满足条件的消息，调用立即返回，此时错误码为ENOMSG; IPC_EXCEPT与msytp配合使用，返回队列中第一一个类型不为msgtyp的消息; IPC_NOERROR,如果队列中满足条件的消息内容大于所请求的msgsz 字节，则把该消息截断，截断部分将被丢弃。
  例：前一个程序想消息队列写入了信息，我们将它读出：
  msgrcv.c

/**************************************
 * 从消息队列中读取消息
 * ***********************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define BUF_SIZE       256
#define PROJ_ID        32
#define PATH_NAME      "."

int main()
{
    struct mymsgbuf{
        long msgtype;
        char ctrlstring[BUF_SIZE];
    }msgbuffer;
    int    qid;      //消息队列标识符
    int    msglen;   
    key_t  msgkey;

    if((msgkey = ftok(PATH_NAME, PROJ_ID)) == -1)   //获取键值
    {
        perror("ftok error!\n");
        exit(1);
    }

    if((qid = msgget(msgkey, IPC_CREAT | 0660)) == -1)   //获取消息队列标识符
    {
        perror("msgget error!\n");
        exit(1);
    }

    msglen = sizeof(struct mymsgbuf) - 4;
    if(msgrcv(qid, &msgbuffer, msglen, 3, 0) == -1)     //将消息读入到msgbuffer结构中
    {
        perror("msgrcv error!\n");
        exit(1);
    }
    printf("Get message %s\n",msgbuffer.ctrlstring);
    return 0;
}

获取和设置消息队列的属性
消息队列的属性在结构体msqid_ds中，用户可以通过函数msgctl来获取和设置消息队列的属。该函数原型为：

#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

该函数对msqid为标识符的消息队列执行cmd操作：

• IPC_STAT：获取msqid_ds结构体
• IPC_SET：将buf结构体中的属性设置d到msqid_ds中
• IPC_RMID：从内核中删除msqid标识的消息队列

信号量

概念
信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程在访问共享资源时，其他进程也在访问，因此主要作为进程间或同一进程间不同线程之间的同步机制。与消息队列一样，每个信号集都有一个semid_ds数据结构.

#include <linux/sen.h>
struct semid_ds{
	struct ipc_perm     sem_perm;   //对信号进行操作的许可权
	__kernel_time_t     sem_otime;  //对信号进行操作的最后时间
	__kernel_time_t     em_ctime;   //对信号进行修改的最后时间
	struct sem          *sembase;   //指向第一个信号
	struct sem_queue    sem_pending; //等待处理的挂起操作
	struct sem_queue    **sem_pending_last;  //最后一个正在挂起的操作
	struct sem_undo     *undo;       //撤销的请求
	ushort              sem_nsems;   //数组中的信号数
}

注意：这里的信号与之前学的信号不一样，该函数调用成功返回一个信号集的标识符，失败返回-1，上面semid_ds结构体不懂也无妨。
信号集的创建和打开
我们可以使用semget函数创建或打开信号集，函数原型为：

#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);

参数key为ftok获取的键值，nsems为要创建信号集所包含的个数，如果只打开一个信号集则为0，semflg为操作标志，可取以下值：

• IPC_CREATE：调用semget()时，它会将此值与与key比较，如果相同则打开已存在的信号集，否则创建一个新的信号集
• IPC_EXCL：与IPC_CREATE一起使用，当信号集已经存在则返回错误。
  信号量的操作
  当信号量大于0时表示可以使用的资源数量，小于0时表示等待使用资源的进程个数。信号量的值仅能通过PV操作来改变，PV操作通过函数semop实现，该函数原型为：

#include <sys/sem.h>
int semop(int semid, struct sembuf *sops, size_t nsops);

semid参数为信号集标识符; sops参数为指向进行操作的结构体数组首地址;参数nsops为要进行操作的信号的个数;该函数调用成功返回0,失败返回-1.

#include <linux/sem.h>
struct sembuf{
	ushort sem_num;      //信号在信号集中的索引
	short  sem_op;       //操作类型
	short  sem_flg;      //操作标志
}

P操作：将信号量-1,表示又有一个进程调用了资源;

//P操作函数   信号-1
int sem_P(int semid, int index)             //index = 0
{
    struct sembuf buf = {0, -1, IPC_CREAT};  //信号在信号集中的索引->0   
                                             //操作类型->-1   信号加上-1即-1
                                             //操作标志->IPC_CREAT

    if(index < 0)
    {
        perror("index of array cannot equals a minus value!");
        return -1;
    }

    buf.sem_num = index;                    //信号在信号集中的索引->0
    if(semop(semid , &buf, 1) == -1)        //信号-1
    {
        perror("a wrong operation to semaphore occurred!");
        return -1;
    }
    return 0;
}

V操作：将信号量+1,表示有一个进程使用完了资源;

//V操作函数   信号+1
int sem_V(int semid, int index)             //index = 0
{
    struct sembuf buf = {0, +1, IPC_CREAT};  //信号在信号集中的索引->0   
                                             //操作类型->+1   信号加上+1即+1
                                             //操作标志->IPC_CREAT

    if(index < 0)                            
    {
        perror("index of array cannot equals a minus value!\n");
        return -1;
    }

    buf.sem_num = index;                   //信号在信号集中的索引->0
    if(semop(semid,&buf, 1) == -1)         //信号+1
    {
        perror("a wrong operation to semaphore occurred!");
        return -1;
    }

    return 0;
}

信号集的控制
使用信号集时需要对信号集进行一些控制，例如：删除一个信号集，对semid_ds进行设置，获取信号集中信号量等;这些操作都需要函数semctl进行，该函数的原型为：

#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd,...);

semid为信号集标识符，semnum标识一个特定信号，cmd为操作类型，‘…'表示参数是可选的。他依赖于cmd，通过共用体来选取参数。

int                val;      
struct semid_ds    *buf;
ushort             *array;
struct seminfo     *buf;
void               *pad;

前面说过信号量一般和其他通信类型共同使用，所以我们吧它和共享内存结合使用来理解。

共享内存

共享内存是分配一块能被其他进程访问的内存。同时美国共享内存都有一个shmid_ds结构.

struct shmid_ds{
	struct ipc_perm shm_perm;/* 操作权限*/
    int shm_segsz;                    /*段的大小（以字节为单位）*/
	__kernel_time_t shm_atime;          /*最后一个进程附加到该段的时间*/
    __kernel_time_t shm_dtime;          /*最后一个进程离开该段的时间*/
    __kernel_time_t shm_ctime;          /*最后一个进程修改该段的时间*/
    unsigned short shm_cpid;   /*创建该段进程的pid*/
    unsigned short shm_lpid;   /*在该段上操作的最后1个进程的pid*/
    short shm_nattch;          /*当前附加到该段的进程的个数*/
/*下面是私有的*/
    unsigned short shm_npages;  /*段的大小（以页为单位）*/
    unsigned long *shm_pages;   /*指向frames->SHMMAX的指针数组*/
};

共享内存区的创建
使用shmget函数来创建一个共享内存区，或访问一个已经存在的共享内存区，该函数的函数原型为：

#include <linux/shm.h>
int shmget(key_t key, size_t size, int shmflg);

参数key为键值，size为以字节为单位指定内存的大小，shmflg为操作标志位，它的取值有：

• IPC_CREATE：如果已经有了相同键值的共享内存则打开已经存在的共享内存，否则创建一个新的共享内存区。
• IPC_EXCL：与 IPC_CREATE一起使用，否则无意义，如果该键值已创建共享内存区则出错返回-1.
  共享内存区的操作
  在使用共享内存区前，必须通过shmat函数将其附加到进程的地址空间。进程与共享内存就建立了联系。调用成功后就会返回一个指向共享内存区指针，使用该指针访问共享内存区。函数原型为：

#include <linux/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);

参数shmid为shmget的返回值，为贡献内存区的描述符;shmflg为存取权限;shmaddr为共享内存的附加点，取值可为：

在使用完共享内存区时需要通过函数shmdt断开与共享内存区的链接。该函数的原型为：

#include <sys/shm.h>
int shmdt(const void *shmadder);

参数shmadder为函数shmat的返回值，调用成功返回0,失败返回-1.
共享内存区的控制
对贡献内存区的控制是使用函数shmctl实现的，该函数的原型为：

#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

shmid为标识符;buf为指向shmid_ds结构体的指针，cmd为操作位：

例：
sharemem.h

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

#define SHM_SIZE 1024

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

//创建信号量函数
int createsem(const char *pathname, int proj_id, int members, int init_val)
{
    key_t       msgkey;            //键值
    int         index,sid;
    union semun semopts;

    if((msgkey = ftok(pathname,proj_id)) == -1)     //获取键值
    {
        perror("ftok error!\n");
        return -1;
    }

    if((sid = semget(msgkey, members, IPC_CREAT|0666)) == -1)    //创建或打开信号集
    {
        perror("semget call failed!\n");
        return -1;
    }

    semopts.val = init_val;
    for(index = 0; index < members; index++)
    {
        semctl(sid, index, SETVAL, semopts);
    }
    return (sid);
}

//P操作函数   信号-1
int sem_P(int semid, int index)             //index = 0
{
    struct sembuf buf = {0, -1, IPC_CREAT};  //信号在信号集中的索引->0   
                                             //操作类型->-1   信号加上-1即-1
                                             //操作标志->IPC_CREAT

    if(index < 0)
    {
        perror("index of array cannot equals a minus value!");
        return -1;
    }

    buf.sem_num = index;                    //信号在信号集中的索引->0
    if(semop(semid , &buf, 1) == -1)        //信号-1
    {
        perror("a wrong operation to semaphore occurred!");
        return -1;
    }
    return 0;
}

//V操作函数   信号+1
int sem_V(int semid, int index)             //index = 0
{
    struct sembuf buf = {0, +1, IPC_CREAT};  //信号在信号集中的索引->0   
                                             //操作类型->+1   信号加上+1即+1
                                             //操作标志->IPC_CREAT

    if(index < 0)                            
    {
        perror("index of array cannot equals a minus value!\n");
        return -1;
    }

    buf.sem_num = index;                   //信号在信号集中的索引->0
    if(semop(semid,&buf, 1) == -1)         //信号+1
    {
        perror("a wrong operation to semaphore occurred!");
        return -1;
    }

    return 0;
}

//等待信号为1
int wait_sem(int semid, int index)            //index = 0
{
    while(semctl(semid, index, GETVAL,0) == 0)
    {
        sleep(1);
    } 

    return 1;
}

//创建共享内存函数
int createshm(char *pathname, int proj_id, size_t size)
{
    key_t       msgkey;            //键值
    int         sid;

    if((msgkey = ftok(pathname, proj_id)) == -1)    //获取键值
    {
        perror("ftok error!\n");
        return -1;
    }

    if((sid = shmget(msgkey, size, IPC_CREAT|0666)) == -1)   //创建或访问共享内存区
    {
        perror("shmget call failed!\n");
        return -1;
    }

    return sid;
}

//删除信号集函数
int sem_deleta(int semid)
{
    return (semctl(semid,0,IPC_RMID));
}

//打开信号量函数
int opensem(const char *pathname, int proj_id)
{
    key_t       msgkey;
    int         sid;

    if((msgkey = ftok(pathname, proj_id)) == -1)      //获取键值
    {
        perror("ftok error!\n");
        return -1;
    }

    if((sid = semget(msgkey,0, IPC_CREAT|0666)) == -1)  //创建或打开信号集
    {
        perror("semget call failed!\n");
        return -1;
    }

    return (sid);
}

reader.c

/*************************************************
 * 先运行writer.c文件，在writer：后输入内容到共享内存区
 * 再运行reader.c文件，读出共享内存区数据
 * **********************************************/
#include "sharemem.h"

int main()
{
    int       semid,shmid;
    char      *shmaddr;

    if((shmid = createshm(".",'m',SHM_SIZE)) == -1)      //打开共享内存区
    {
        exit(1);
    }

    if((shmaddr = shmat(shmid,(char *)0,0)) == (char *)-1)   //返回指向共享内存区的指针
    {
        perror("attach shared memory error!\n");
        exit(1);
    }

    if((semid = opensem(".",'s')) == -1)    //打开信号集
    {
        exit(1);
    }

    while(1)
    {
        printf("reader: ");
        wait_sem(semid, 0);         //等待信号为1
        sem_P(semid, 0);            //信号-1

        printf("%s\n",shmaddr);
        sleep(10);

        sem_V(semid, 0);            //信号+1
        sleep(10);
    }
}

writer.c

/*************************************************
 * 先运行writer.c文件，在writer：后输入内容到共享内存区
 * 再运行reader.c文件，读出共享内存区数据
 * **********************************************/
#include "sharemem.h"

int main()
{
    int       semid,shmid;                      //semget和shmget的返回值
    char      *shmaddr;                         //shmat的返回值
    char      write_str[SHM_SIZE];

    if((shmid = createshm(".",'m', SHM_SIZE)) == -1)          //创建共享内存区
    {
        exit(1);
    }

    if((shmaddr = shmat(shmid, (char *)0, 0)) == (char *)-1)  //返回指向共享内存区的指针
    {
        perror("attach shared memory error!\n");
        exit(1);
    }

    if((semid = createsem(".",'s',1,1)) == -1)                //创建（打开）信号集
    {
        exit(1);
    }

    while(1)
    {
        wait_sem(semid, 0);         //等待信号为1
        sem_P(semid, 0);            //信号-1

        printf("writer: ");
        fgets(write_str,1024,stdin);        //输入内容
        int len = strlen(write_str)-1;
        write_str[len] = '\0';
        strcpy(shmaddr,write_str);          //写入共享内存区
        sleep(10);

        sem_V(semid, 0);                    //信号+1
        sleep(10);
    }
}