code---Linux（3）
1、进程间通信主要有四种形式：管道（pipe）、消息队列、信号量、共享内存。
2、首先说一下最基本的管道，管道分：命名管道和匿名管道；
3、匿名管道主要用在具有亲缘关系的进程之间通信，调用pipe函数创建匿名管道，一端用于写另一端用于读，当进程之间在进行读写的时候会发生阻塞，即当写端没有再向管道里写数据时，读端读完最后一个数据后就会阻塞，而且匿名管道是半双工的，意思是在同一时刻只能进行单项通信，
4、由于匿名管道缺点所以就提出命名管道，命名管道的实现是创建一个实实在在存在的文件，然后不同的进程可以往里写数据也可以从里读数据，进程之间可以不具有亲缘关系，创建命名管道的函数有两个：mknode和mkfifo，但用得比较多的是mkfifo。
5、刚才说的是最基本的进程间通信的管道，现在说一下system V 标准的消息队列，消息队列也打开了一个文件，一端用于写一端用于读，但是它和命名管道不同之处是命名管道是基于字节流，而消息队列是基于数据报的传输，它们都有一个共同的缺点是传输的数据都有最大值的限制，消息队列的实现主要有msgget(创建线性队列)、msgsend(发送消息队列)、msgrecv(接受消息队列)、msgctl(设置消息队列属性)这四个函数来完成的。
6、第二个进程间通信是信号量：信号量其实本质就是一把数据锁，它并没事实实在在的传输数据，只是给传输的数据上锁，然后让它们安全可靠的输出而已，它是实现主要靠：semget(创建信号量)、semop(主要为了加锁和解锁)、semctl(设置信号量属性)，里面主要有一个P、V操作，P操作:如果有资源，那么资源数减一，给操作这块资源的操作上锁，V操作：如果有资源，资源数加一，等待被访问。当请求不到资源是时候会阻塞式的等待。
7、第三个要说的进程间通信是共享内存：它是通过打开一个文件，让所有的进程都共享这个文件，从而时间进程间通信。它其实会出现一个安全性问题，就是没有同步机制，如果在多线程访问的话就很可能出安全性问题，所以一般共享内存通常会和信号量搭配使用，它主要实现靠shmget(创建共享内存)、shmat(刚创建的共享内存还不能被所有进程访问，必须调用shmat才可以被进程访问)、shmdt(让访问共享内存的进程分离)、shmctl(对共享内存的属性进行设置)，
&既然共享内存有安全性问题为什么还有用它呢？？？因为共享内存的通信很快，而且它的接口函数很简单，只要加上同步机制在安全方面就没问题了。
8、说到安全性问题，这里说一下为什么不加锁的话就不安全了，因为当程序需要改变一个数的时候，它的操作是这样的：先去内存里读数据到寄存器里，然后从寄存器里把数据取出来，修改后在先写会寄存器，然后在写会内存。试想一下，当对一个数进行加一的时候，因为加一的操作不是原子性的，所以当把数据加一了后写会寄存器时刚好进程或者线程被切换出去了，而切换出去的进程或线程刚好要用到以为被加后的数据，其实没加，所以最后得到是值不是预期的值。
9、以上这些就是我所掌握的进程间通信。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：42853次
积分：1284
积分：1284
排名：千里之外
原创：87篇
评论：14条
阅读：6262
文章：11篇
阅读：4586
文章：19篇
阅读：15083
(4)(4)(1)(17)(4)(5)(9)(2)(2)(2)(3)(11)(5)(12)(5)(4)8106人阅读
Qt 是一个跨平台的应用框架，其进程间通信机制当然可以使用所在平台的进程间通信机制，如在Windows平台上的Message机制、共享内存、文件映射、管道、Socket等。其中，Qt对一些许多平台共有的IPC机制进行了封装。
Qt官方文档中对Qt的IPC机制是这样介绍的：
其实就是通过网络模块实现的IPC。不过Qt对其进行了封装，并提供了两个层次的API，包括应用程序级的QNetworkAccessManager, QFtp等和底层的QTcpSocket, QTcpServer, QSslSocket等。
Shared Memory（共享内存）
Qt提供了一种安全的共享内存的实现（见QSharedMemory），以便在多线程和多进程编程中安全的使用。另外&QSystemSemaphore可以作为系统共享资源或进程间通信的访问控制。
D_BUS是一种低开销、低延迟的IPC。Qt提供了QtDBus模块，该模块使用D-Bus协议，把信号与槽机制（Signal &and Slot）扩展到进程级别，使得开发者可以在一个进程中发出信号，可以再其他进程定义槽来响应这些信号。
Qt COmmunications Protocol (QCOP)
QCOP 是 Qt 内部的一种通信协议，这种协议用于不同的客户之间在同一地址空间内部或者不同的进程之间的通信。目前，这种机制还只在 Qt 的嵌入式版本中提供。
为实现这种通信机制，Qt 中包括了由 QObject 类继承而来的 QCopChannel 类，该类提供了诸如 send()、isRegistered() 等静态函数，它们可以在脱离对象的情况下使用。为了在 channel 中接收通信数据，用户需要构造一个 QCopChannel 的子类并提供 receive()
函数的重载函数，或者利用 connect() 函数与接收到的信号相联系。值得一提的是，在 Qt 系统中，只提供了 QCOP 协议机制和用于接收消息的类，而如何发送消息则没有提供相应的类供用户使用。
在基于 Qt 的桌面系统 Qtopia（QPE）中，则提供了相应的发送类：QCopEnvelope。用户可以通过该类利用 channel 向其他进程发送消息。该类将通过 QCopChannel 发送 QCop 消息的过程进行了封装，用户只需要调用该类中的相关函数就可以方便地实现进程之间的通信。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：97430次
积分：1480
积分：1480
排名：千里之外
原创：49篇
评论：15条
(3)(4)(5)(4)(4)(8)(21)(2)(1)(4)(3)进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。
IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。
以Linux中的C语言编程为例。
管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。
它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。
它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
1 #include &unistd.h&
2 int pipe(int fd[2]);
// 返回值：若成功返回0，失败返回-1
当一个管道建立时，它会创建两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。如下图：
要关闭管道只需将这两个文件描述符关闭即可。
单个进程中的管道几乎没有任何用处。所以，通常调用 pipe 的进程接着调用 fork，这样就创建了父进程与子进程之间的 IPC 通道。如下图所示：
若要数据流从父进程流向子进程，则关闭父进程的读端（fd[0]）与子进程的写端（fd[1]）；反之，则可以使数据流从子进程流向父进程。
1 #include&stdio.h&
2 #include&unistd.h&
4 int main()
int fd[2];
// 两个文件描述符
char buff[20];
if(pipe(fd) & 0)
// 创建管道
printf("Create Pipe Error!\n");
if((pid = fork()) & 0)
// 创建子进程
printf("Fork Error!\n");
else if(pid & 0)
close(fd[0]); // 关闭读端
write(fd[1], "hello world\n", 12);
close(fd[1]); // 关闭写端
read(fd[0], buff, 20);
printf("%s", buff);
FIFO，也称为命名管道，它是一种文件类型。
FIFO可以在无关的进程之间交换数据，与无名管道不同。
FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
1 #include &sys/stat.h&
2 // 返回值：成功返回0，出错返回-1
3 int mkfifo(const char *pathname, mode_t mode);
其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。
当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：
若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。
FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且&先进先出&。下面的例子演示了使用 FIFO 进行 IPC 的过程：
write_fifo.c
1 #include&stdio.h&
2 #include&stdlib.h&
3 #include&fcntl.h&
// O_WRONLY
4 #include&sys/stat.h&
5 #include&time.h&
7 int main()
char buf[1024];
printf("I am %d process.\n", getpid()); // 说明进程ID
if((fd = open("fifo1", O_WRONLY)) & 0) // 以写打开一个FIFO
perror("Open FIFO Failed");
for(i=0; i&10; ++i)
time(&tp);
// 取系统当前时间
n=sprintf(buf,"Process %d's time is %s",getpid(),ctime(&tp));
printf("Send message: %s", buf); // 打印
if(write(fd, buf, n+1) & 0)
// 写入到FIFO中
perror("Write FIFO Failed");
close(fd);
// 休眠1秒
close(fd);
// 关闭FIFO文件
read_fifo.c
1 #include&stdio.h&
2 #include&stdlib.h&
3 #include&errno.h&
4 #include&fcntl.h&
5 #include&sys/stat.h&
7 int main()
char buf[1024];
if(mkfifo("fifo1", 0666) & 0 && errno!=EEXIST) // 创建FIFO管道
perror("Create FIFO Failed");
if((fd = open("fifo1", O_RDONLY)) & 0)
// 以读打开FIFO
perror("Open FIFO Failed");
while((len = read(fd, buf, 1024)) & 0) // 读取FIFO管道
printf("Read message: %s", buf);
close(fd);
// 关闭FIFO文件
在两个终端里用 gcc 分别编译运行上面两个文件，可以看到输出结果如下：
1 [cheesezh@localhost]$ ./write_fifo
2 I am 5954 process.
3 Send message: Process 5954's time is Mon Apr 20 12:37:28 2015
4 Send message: Process 5954's time is Mon Apr 20 12:37:29 2015
5 Send message: Process 5954's time is Mon Apr 20 12:37:30 2015
6 Send message: Process 5954's time is Mon Apr 20 12:37:31 2015
7 Send message: Process 5954's time is Mon Apr 20 12:37:32 2015
8 Send message: Process 5954's time is Mon Apr 20 12:37:33 2015
9 Send message: Process 5954's time is Mon Apr 20 12:37:34 2015
10 Send message: Process 5954's time is Mon Apr 20 12:37:35 2015
11 Send message: Process 5954's time is Mon Apr 20 12:37:36 2015
12 Send message: Process 5954's time is Mon Apr 20 12:37:37 2015
1 [cheesezh@localhost]$ ./read_fifo
2 Read message: Process 5954's time is Mon Apr 20 12:37:28 2015
3 Read message: Process 5954's time is Mon Apr 20 12:37:29 2015
4 Read message: Process 5954's time is Mon Apr 20 12:37:30 2015
5 Read message: Process 5954's time is Mon Apr 20 12:37:31 2015
6 Read message: Process 5954's time is Mon Apr 20 12:37:32 2015
7 Read message: Process 5954's time is Mon Apr 20 12:37:33 2015
8 Read message: Process 5954's time is Mon Apr 20 12:37:34 2015
9 Read message: Process 5954's time is Mon Apr 20 12:37:35 2015
10 Read message: Process 5954's time is Mon Apr 20 12:37:36 2015
11 Read message: Process 5954's time is Mon Apr 20 12:37:37 2015
上述例子可以扩展成 客户进程&服务器进程 通信的实例，write_fifo的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，read_fifo类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：
三、消息队列
消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。
消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
1 #include &sys/msg.h&
2 // 创建或打开消息队列：成功返回队列ID，失败返回-1
3 int msgget(key_t key, int flag);
4 // 添加消息：成功返回0，失败返回-1
5 int msgsnd(int msqid, const void *ptr, size_t size, int flag);
6 // 读取消息：成功返回消息数据的长度，失败返回-1
7 int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
8 // 控制消息队列：成功返回0，失败返回-1
9 int msgctl(int msqid, int cmd, struct msqid_ds *buf);
在以下两种情况下，msgget将创建一个新的消息队列：
如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志位。
key参数为IPC_PRIVATE。
函数msgrcv在读取消息队列时，type参数有下面几种情况：
type == 0，返回队列中的第一个消息；
type & 0，返回队列中消息类型为 type 的第一个消息；
type & 0，返回队列中消息类型值小于或等于 type 绝对值的消息，如果有多个，则取类型值最小的消息。
可以看出，type值非 0 时用于以非先进先出次序读消息。也可以把 type 看做优先级的权值。（其他的参数解释，请自行Google之）
下面写了一个简单的使用消息队列进行IPC的例子，服务端程序一直在等待特定类型的消息，当收到该类型的消息以后，发送另一种特定类型的消息作为反馈，客户端读取该反馈并打印出来。
msg_server.c
1 #include &stdio.h&
2 #include &stdlib.h&
3 #include &sys/msg.h&
5 // 用于创建一个唯一的key
6 #define MSG_FILE "/etc/passwd"
8 // 消息结构
9 struct msg_form {
char mtext[256];
14 int main()
struct msg_
// 获取key值
if((key = ftok(MSG_FILE,'z')) & 0)
perror("ftok error");
// 打印key值
printf("Message Queue - Server key is: %d.\n", key);
// 创建消息队列
if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
perror("msgget error");
// 打印消息队列ID及进程ID
printf("My msqid is: %d.\n", msqid);
printf("My pid is: %d.\n", getpid());
// 循环读取消息
msgrcv(msqid, &msg, 256, 888, 0);// 返回类型为888的第一个消息
printf("Server: receive msg.mtext is: %s.\n", msg.mtext);
printf("Server: receive msg.mtype is: %d.\n", msg.mtype);
msg.mtype = 999; // 客户端接收的消息类型
sprintf(msg.mtext, "hello, I'm server %d", getpid());
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
msg_client.c
1 #include &stdio.h&
2 #include &stdlib.h&
3 #include &sys/msg.h&
5 // 用于创建一个唯一的key
6 #define MSG_FILE "/etc/passwd"
8 // 消息结构
9 struct msg_form {
char mtext[256];
14 int main()
struct msg_
// 获取key值
if ((key = ftok(MSG_FILE, 'z')) & 0)
perror("ftok error");
// 打印key值
printf("Message Queue - Client key is: %d.\n", key);
// 打开消息队列
if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
perror("msgget error");
// 打印消息队列ID及进程ID
printf("My msqid is: %d.\n", msqid);
printf("My pid is: %d.\n", getpid());
// 添加消息，类型为888
msg.mtype = 888;
sprintf(msg.mtext, "hello, I'm client %d", getpid());
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
// 读取类型为777的消息
msgrcv(msqid, &msg, 256, 999, 0);
printf("Client: receive msg.mtext is: %s.\n", msg.mtext);
printf("Client: receive msg.mtype is: %d.\n", msg.mtype);
四、信号量
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
支持信号量组。
最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。
Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。
1 #include &sys/sem.h&
2 // 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
3 int semget(key_t key, int num_sems, int sem_flags);
4 // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
5 int semop(int semid, struct sembuf semoparray[], size_t numops);
6 // 控制信号量的相关信息
7 int semctl(int semid, int sem_num, int cmd, ...);
当semget创建新的信号量集合时，必须指定集合中信号量的个数（即num_sems），通常为1； 如果是引用一个现有的集合，则将num_sems指定为 0 。
在semop函数中，sembuf结构的定义如下：
1 struct sembuf
short sem_ // 信号量组中对应的序号，0～sem_nums-1
short sem_
// 信号量值在一次操作中的改变量
short sem_ // IPC_NOWAIT, SEM_UNDO
其中 sem_op 是一次操作中的信号量的改变量：
若sem_op & 0，表示进程释放相应的资源数，将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则换行它们。
若sem_op & 0，请求 sem_op 的绝对值的资源。
如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。
当相应的资源数不能满足请求时，这个操作与sem_flg有关。
sem_flg 指定IPC_NOWAIT，则semop函数出错返回EAGAIN。
sem_flg 没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
当相应的资源数可以满足请求，此信号量的semncnt值减1，该信号量的值减去sem_op的绝对值。成功返回；
此信号量被删除，函数smeop出错返回EIDRM；
进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR
若sem_op == 0，进程阻塞直到信号量的相应值为0：
当信号量已经为0，函数立即返回。
如果信号量的值不为0，则依据sem_flg决定函数动作：
sem_flg指定IPC_NOWAIT，则出错返回EAGAIN。
sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；
此信号量被删除，函数smeop出错返回EIDRM；
进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR
在semctl函数中的命令有多种，这里就说两个常用的：
SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。
1 #include&stdio.h&
2 #include&stdlib.h&
3 #include&sys/sem.h&
5 // 联合体，用于semctl初始化
6 union semun
int /*for SETVAL*/
struct semid_ds *
unsigned short
13 // 初始化信号量
14 int init_sem(int sem_id, int value)
if(semctl(sem_id, 0, SETVAL, tmp) == -1)
perror("Init Semaphore Error");
return -1;
26 // P操作:
若信号量值为1，获取资源并将信号量值-1
若信号量值为0，进程挂起等待
29 int sem_p(int sem_id)
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = -1; /*P操作*/
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
perror("P operation Error");
return -1;
44 // V操作：
释放资源并将信号量值+1
如果有进程正在挂起等待，则唤醒它们
47 int sem_v(int sem_id)
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = 1;
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
perror("V operation Error");
return -1;
62 // 删除信号量集
63 int del_sem(int sem_id)
if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
perror("Delete Semaphore Error");
return -1;
75 int main()
// 信号量集ID
// 获取key值
if((key = ftok(".", 'z')) & 0)
perror("ftok error");
// 创建信号量集，其中只有一个信号量
if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
perror("semget error");
// 初始化：初值设为0资源被占用
init_sem(sem_id, 0);
if((pid = fork()) == -1)
perror("Fork Error");
else if(pid == 0) /*子进程*/
printf("Process child: pid=%d\n", getpid());
sem_v(sem_id);
/*释放资源*/
/*父进程*/
sem_p(sem_id);
/*等待资源*/
printf("Process father: pid=%d\n", getpid());
sem_v(sem_id);
/*释放资源*/
del_sem(sem_id); /*删除信号量集*/
上面的例子如果不加信号量，则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行。
五、共享内存
共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。
共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
因为多个进程可以同时操作，所以需要进行同步。
信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
1 #include &sys/shm.h&
2 // 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
3 int shmget(key_t key, size_t size, int flag);
4 // 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
5 void *shmat(int shm_id, const void *addr, int flag);
6 // 断开与共享内存的连接：成功返回0，失败返回-1
7 int shmdt(void *addr);
8 // 控制共享内存的相关信息：成功返回0，失败返回-1
9 int shmctl(int shm_id, int cmd, struct shmid_ds *buf);
当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。
当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。
shmdt函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。
shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）。
下面这个例子，使用了【共享内存+信号量+消息队列】的组合来实现服务器进程与客户进程间的通信。
共享内存用来传递数据；
信号量用来同步；
消息队列用来 在客户端修改了共享内存后 通知服务器读取。
1 #include&stdio.h&
2 #include&stdlib.h&
3 #include&sys/shm.h&
// shared memory
4 #include&sys/sem.h&
// semaphore
5 #include&sys/msg.h&
// message queue
6 #include&string.h&
8 // 消息队列结构
9 struct msg_form {
14 // 联合体，用于semctl初始化
15 union semun
int /*for SETVAL*/
struct semid_ds *
unsigned short
22 // 初始化信号量
23 int init_sem(int sem_id, int value)
if(semctl(sem_id, 0, SETVAL, tmp) == -1)
perror("Init Semaphore Error");
return -1;
35 // P操作:
若信号量值为1，获取资源并将信号量值-1
若信号量值为0，进程挂起等待
38 int sem_p(int sem_id)
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = -1; /*P操作*/
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
perror("P operation Error");
return -1;
53 // V操作：
释放资源并将信号量值+1
如果有进程正在挂起等待，则唤醒它们
56 int sem_v(int sem_id)
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = 1;
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
perror("V operation Error");
return -1;
71 // 删除信号量集
72 int del_sem(int sem_id)
if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
perror("Delete Semaphore Error");
return -1;
83 // 创建一个信号量集
84 int creat_sem(key_t key)
if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
perror("semget error");
init_sem(sem_id, 1);
/*初值设为1资源未占用*/
return sem_
97 int main()
int shmid, semid,
char data[] = "this is server";
struct shmid_ds buf1;
/*用于删除共享内存*/
struct msqid_ds buf2;
/*用于删除消息队列*/
struct msg_
/*消息队列用于通知对方更新了共享内存*/
// 获取key值
if((key = ftok(".", 'z')) & 0)
perror("ftok error");
// 创建共享内存
if((shmid = shmget(key, 1024, IPC_CREAT|0666)) == -1)
perror("Create Shared Memory Error");
// 连接共享内存
shm = (char*)shmat(shmid, 0, 0);
if((int)shm == -1)
perror("Attach Shared Memory Error");
// 创建消息队列
if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
perror("msgget error");
// 创建信号量
semid = creat_sem(key);
msgrcv(msqid, &msg, 1, 888, 0); /*读取类型为888的消息*/
if(msg.mtext == 'q')
/*quit - 跳出循环*/
if(msg.mtext == 'r')
/*read - 读共享内存*/
sem_p(semid);
printf("%s\n",shm);
sem_v(semid);
// 断开连接
shmdt(shm);
/*删除共享内存、消息队列、信号量*/
shmctl(shmid, IPC_RMID, &buf1);
msgctl(msqid, IPC_RMID, &buf2);
del_sem(semid);
1 #include&stdio.h&
2 #include&stdlib.h&
3 #include&sys/shm.h&
// shared memory
4 #include&sys/sem.h&
// semaphore
5 #include&sys/msg.h&
// message queue
6 #include&string.h&
8 // 消息队列结构
9 struct msg_form {
14 // 联合体，用于semctl初始化
15 union semun
int /*for SETVAL*/
struct semid_ds *
unsigned short
22 // P操作:
若信号量值为1，获取资源并将信号量值-1
若信号量值为0，进程挂起等待
25 int sem_p(int sem_id)
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = -1; /*P操作*/
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
perror("P operation Error");
return -1;
40 // V操作：
释放资源并将信号量值+1
如果有进程正在挂起等待，则唤醒它们
43 int sem_v(int sem_id)
sbuf.sem_num = 0; /*序号*/
sbuf.sem_op = 1;
sbuf.sem_flg = SEM_UNDO;
if(semop(sem_id, &sbuf, 1) == -1)
perror("V operation Error");
return -1;
59 int main()
int shmid, semid,
struct msg_
int flag = 1; /*while循环条件*/
// 获取key值
if((key = ftok(".", 'z')) & 0)
perror("ftok error");
// 获取共享内存
if((shmid = shmget(key, 1024, 0)) == -1)
perror("shmget error");
// 连接共享内存
shm = (char*)shmat(shmid, 0, 0);
if((int)shm == -1)
perror("Attach Shared Memory Error");
// 创建消息队列
if ((msqid = msgget(key, 0)) == -1)
perror("msgget error");
// 获取信号量
if((semid = semget(key, 0, 0)) == -1)
perror("semget error");
printf("***************************************\n");
Input r to send data to server.
Input q to quit.
printf("***************************************\n");
while(flag)
printf("Please input command: ");
scanf("%c", &c);
printf("Data to send: ");
sem_p(semid);
/*访问资源*/
scanf("%s", shm);
sem_v(semid);
/*释放资源*/
/*清空标准输入缓冲区*/
while((c=getchar())!='\n' && c!=EOF);
msg.mtype = 888;
msg.mtext = 'r';
/*发送消息通知服务器读数据*/
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
msg.mtype = 888;
msg.mtext = 'q';
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
printf("Wrong input!\n");
/*清空标准输入缓冲区*/
while((c=getchar())!='\n' && c!=EOF);
// 断开连接
shmdt(shm);
注意：当scanf()输入字符或字符串时，缓冲区中遗留下了\n，所以每次输入操作后都需要清空标准输入的缓冲区。但是由于 gcc 编译器不支持fflush(stdin)（它只是标准C的扩展），所以我们使用了替代方案：
1 while((c=getchar())!='\n' && c!=EOF);
参考资料：http://songlee24.github.io//linux-IPC/
阅读(...) 评论()