建筑工程分包平台_龙岩做网站开发找哪家_营销公司排行_自媒体人专用网站

一、简介

每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信机制。

二、主要方式

2.1 匿名管道

管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。

2.1.1 特点

它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

2.1.2 原型

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

在 Linux 的实际编码中，是通过 pipe 函数来创建匿名管道的，若创建成功则返回 0，创建失败就返回 -1：

int pipe (int fd[2]);

该函数拥有一个存储空间为 2 的文件描述符数组：

fd[0] 指向管道的读端，fd[1] 指向管道的写端
fd[1] 的输出是 fd[0] 的输入

通过匿名管道实现进程间通信的步骤：

1）父进程创建两个匿名管道，管道 1（fd1[0]和 fd1[1]）和管道 2（fd2[0] 和 fd2[1]）；

因为管道的数据是单向流动的，所以要想实现数据双向通信，就需要两个管道，每个方向一个。

2）父进程 fork 出子进程，于是对于这两个匿名管道，子进程也分别有两个文件描述符指向匿名管道的读写两端；

3）父进程关闭管道 1 的读端 fd1[0] 和 管道 2 的写端 fd2[1]，子进程关闭管道 1 的写端 fd1[1] 和 管道 2 的读端 fd2[0]，这样，管道 1 只能用于父进程写、子进程读；管道 2 只能用于父进程读、子进程写。管道是用环形队列实现的，数据从写端流入从读端流出，这就实现了父子进程之间的双向通信。

简单来说，管道的本质就是内核在内存中开辟了一个缓冲区，这个缓冲区与管道文件相关联，对管道文件的操作，被内核转换成对这块缓冲区的操作。

2.1.3 代码示例

#include<stdio.h>
#include<unistd.h>int main()
{int fd[2];  // 两个文件描述符pid_t pid;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);}else{close(fd[1]); // 关闭写端read(fd[0], buff, 20);printf("%s", buff);}return 0;
}

2.2 有名管道

FIFO，也称为命名管道，它是一种文件类型。

2.2.1 特点

FIFO可以在无关的进程之间交换数据，与无名管道不同。
FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

2.2.2 原型

#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
// 返回值：成功返回0，出错返回-1
//其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。

当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：

若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

匿名管道由于没有名字，只能用于父子进程间的通信。为了克服这个缺点，提出了有名管道，也称做 FIFO，因为数据是先进先出的传输方式。

所谓有名管道也就是提供一个路径名与之关联，这样，即使与创建有名管道的进程不存在亲缘关系的进程，只要可以访问该路径，就能够通过这个有名管道进行相互通信。

使用 Linux 命令 mkfifo 来创建有名管道：

$ mkfifo myPipe

myPipe 就是这个管道的名称，接下来，我们往 myPipe 这个有名管道中写入数据：

$ echo "hello" > myPipe

执行这行命令后，你会发现它就停在这了，这是因为管道里的内容没有被读取，只有当管道里的数据被读完后，命令才可以正常退出。于是，我们执行另外一个命令来读取这个有名管道里的数据：

$ cat < myPipe
hello

2.2.3 代码示例

//write_fifo.c#include<stdio.h>
#include<stdlib.h>   // exit
#include<fcntl.h>    // O_WRONLY
#include<sys/stat.h>
#include<time.h>     // timeint main()
{int fd;int n, i;char buf[1024];time_t tp;printf("I am %d process.\n", getpid()); // 说明进程IDif((fd = open("fifo1", O_WRONLY)) < 0) // 以写打开一个FIFO {perror("Open FIFO Failed");exit(1);}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);exit(1);}sleep(1);  // 休眠1秒}close(fd);  // 关闭FIFO文件return 0;
}

//read_fifo.c#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<fcntl.h>
#include<sys/stat.h>int main()
{int fd;int len;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");exit(1);}while((len = read(fd, buf, 1024)) > 0) // 读取FIFO管道printf("Read message: %s", buf);close(fd);  // 关闭FIFO文件return 0;
}

上述例子可以扩展成 客户进程—服务器进程 通信的实例，write_fifo的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，read_fifo类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：

2.3 消息队列

消息队列的本质就是存放在内存中的消息的链表，而消息本质上是用户自定义的数据结构。如果进程从消息队列中读取了某个消息，这个消息就会被从消息队列中删除。对比一下管道机制：

消息队列允许一个或多个进程向它写入或读取消息。
消息队列可以实现消息的随机查询，不一定非要以先进先出的次序读取消息，也可以按消息的类型读取。比有名管道的先进先出原则更有优势。
对于消息队列来说，在某个进程往一个队列写入消息之前，并不需要另一个进程在该消息队列上等待消息的到达。而对于管道来说，除非读进程已存在，否则先有写进程进行写入操作是没有意义的。
消息队列的生命周期随内核，如果没有释放消息队列或者没有关闭操作系统，消息队列就会一直存在。而匿名管道随进程的创建而建立，随进程的结束而销毁#

消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。

2.3.1 特点

消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

2.3.2 原型

#include <sys/msg.h>
// 创建或打开消息队列：成功返回队列ID，失败返回-1
int msgget(key_t key, int flag);
// 添加消息：成功返回0，失败返回-1
int msgsnd(int msqid, const void *ptr, size_t size, int flag);
// 读取消息：成功返回消息数据的长度，失败返回-1
int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
// 控制消息队列：成功返回0，失败返回-1
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 看做优先级的权值

2.3.3 代码示例

//msg_server.c#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>// 用于创建一个唯一的key
#define MSG_FILE "/etc/passwd"// 消息结构
struct msg_form {long mtype;char mtext[256];
};int main()
{int msqid;key_t key;struct msg_form msg;// 获取key值if((key = ftok(MSG_FILE,'z')) < 0){perror("ftok error");exit(1);}// 打印key值printf("Message Queue - Server key is: %d.\n", key);// 创建消息队列if ((msqid = msgget(key, IPC_CREAT|0777)) == -1){perror("msgget error");exit(1);}// 打印消息队列ID及进程IDprintf("My msqid is: %d.\n", msqid);printf("My pid is: %d.\n", getpid());// 循环读取消息for(;;) {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);}return 0;
}

//msg_client.c#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>// 用于创建一个唯一的key
#define MSG_FILE "/etc/passwd"// 消息结构
struct msg_form {long mtype;char mtext[256];
};int main()
{int msqid;key_t key;struct msg_form msg;// 获取key值if ((key = ftok(MSG_FILE, 'z')) < 0) {perror("ftok error");exit(1);}// 打印key值printf("Message Queue - Client key is: %d.\n", key);// 打开消息队列if ((msqid = msgget(key, IPC_CREAT|0777)) == -1) {perror("msgget error");exit(1);}// 打印消息队列ID及进程IDprintf("My msqid is: %d.\n", msqid);printf("My pid is: %d.\n", getpid());// 添加消息，类型为888msg.mtype = 888;sprintf(msg.mtext, "hello, I'm client %d", getpid());msgsnd(msqid, &msg, sizeof(msg.mtext), 0);// 读取类型为999的消息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);return 0;
}

2.4 信号量

实际上，对具有多 CPU 系统的最新研究表明，在这类系统上，消息传递的性能其实是要优于共享内存的，因为消息队列无需避免冲突，而共享内存机制可能会发生冲突。也就是说如果多个进程同时修改同一个共享内存，先来的那个进程写的内容就会被后来的覆盖。
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。

如果有 A、B 两个进程分别负责读和写数据的操作，这两个线程是相互合作、相互依赖的。那么写数据应该发生在读数据之前。而实际上，由于异步性的存在，可能会发生先读后写的情况，而此时由于缓冲区还没有被写入数据，读进程 A 没有数据可读，因此读进程 A 被阻塞。

为了解决上述这两个问题，保证共享内存在任何时刻只有一个进程在访问（互斥），并且使得进程们能够按照某个特定顺序访问共享内存（同步），我们就可以使用进程的同步与互斥机制，常见的比如信号量与 PV 操作。

进程的同步与互斥其实是一种对进程通信的保护机制，并不是用来传输进程之间真正通信的内容的，但是由于它们会传输信号量，所以也被纳入进程通信的范畴，称为低级通信。

下面的内容和上篇文章【看完了进程同步与互斥机制，我终于彻底理解了 PV 操作】中所讲的差不多，看过的小伙伴可直接跳到下一标题。

信号量其实就是一个变量 ，我们可以用一个信号量来表示系统中某种资源的数量，比如：系统中只有一台打印机，就可以设置一个初值为 1 的信号量。

用户进程可以通过使用操作系统提供的一对原语来对信号量进行操作，从而很方便的实现进程互斥或同步。这一对原语就是 PV 操作：

1）P 操作：将信号量值减 1，表示申请占用一个资源。如果结果小于 0，表示已经没有可用资源，则执行 P 操作的进程被阻塞。如果结果大于等于 0，表示现有的资源足够你使用，则执行 P 操作的进程继续执行。

可以这么理解，当信号量的值为 2 的时候，表示有 2 个资源可以使用，当信号量的值为 -2 的时候，表示有两个进程正在等待使用这个资源。不看这句话真的无法理解 V 操作，看完顿时如梦初醒。

2）V 操作：将信号量值加 1，表示释放一个资源，即使用完资源后归还资源。若加完后信号量的值小于等于 0，表示有某些进程正在等待该资源，由于我们已经释放出一个资源了，因此需要唤醒一个等待使用该资源（就绪态）的进程，使之运行下去。

我觉得已经讲的足够通俗了，不过对于 V 操作大家可能仍然有困惑，下面再来看两个关于 V 操作的问答：

问：信号量的值 大于 0 表示有共享资源可供使用，这个时候为什么不需要唤醒进程？

答：所谓唤醒进程是从就绪队列（阻塞队列）中唤醒进程，而信号量的值大于 0 表示有共享资源可供使用，也就是说这个时候没有进程被阻塞在这个资源上，所以不需要唤醒，正常运行即可。

问：信号量的值 等于 0 的时候表示没有共享资源可供使用，为什么还要唤醒进程？

答：V 操作是先执行信号量值加 1 的，也就是说，把信号量的值加 1 后才变成了 0，在此之前，信号量的值是 -1，即有一个进程正在等待这个共享资源，我们需要唤醒它。

2.4.1 特点

信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
支持信号量组。

2.4.2原型

最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。
Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。

#include <sys/sem.h>
// 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
int semget(key_t key, int num_sems, int sem_flags);
// 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
int semop(int semid, struct sembuf semoparray[], size_t numops);  
// 控制信号量的相关信息
int semctl(int semid, int sem_num, int cmd, ...);

当semget创建新的信号量集合时，必须指定集合中信号量的个数（即num_sems），通常为1； 如果是引用一个现有的集合，则将num_sems指定为 0 。
在semop函数中，sembuf结构的定义如下：

struct sembuf 
{short sem_num; // 信号量组中对应的序号，0～sem_nums-1short sem_op;  // 信号量值在一次操作中的改变量short sem_flg; // 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：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源

2.4.3 代码示例

#include<stdio.h>
#include<stdlib.h>
#include<sys/sem.h>// 联合体，用于semctl初始化
union semun
{int              val; /*for SETVAL*/struct semid_ds *buf;unsigned short  *array;
};// 初始化信号量
int init_sem(int sem_id, int value)
{union semun tmp;tmp.val = value;if(semctl(sem_id, 0, SETVAL, tmp) == -1){perror("Init Semaphore Error");return -1;}return 0;
}// P操作:
//    若信号量值为1，获取资源并将信号量值-1 
//    若信号量值为0，进程挂起等待
int sem_p(int sem_id)
{struct sembuf sbuf;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;}return 0;
}// V操作：
//    释放资源并将信号量值+1
//    如果有进程正在挂起等待，则唤醒它们
int sem_v(int sem_id)
{struct sembuf sbuf;sbuf.sem_num = 0; /*序号*/sbuf.sem_op = 1;  /*V操作*/sbuf.sem_flg = SEM_UNDO;if(semop(sem_id, &sbuf, 1) == -1){perror("V operation Error");return -1;}return 0;
}// 删除信号量集
int del_sem(int sem_id)
{union semun tmp;if(semctl(sem_id, 0, IPC_RMID, tmp) == -1){perror("Delete Semaphore Error");return -1;}return 0;
}int main()
{int sem_id;  // 信号量集IDkey_t key;  pid_t pid;// 获取key值if((key = ftok(".", 'z')) < 0){perror("ftok error");exit(1);}// 创建信号量集，其中只有一个信号量if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1){perror("semget error");exit(1);}// 初始化：初值设为0资源被占用init_sem(sem_id, 0);if((pid = fork()) == -1)perror("Fork Error");else if(pid == 0) /*子进程*/ {sleep(2);printf("Process child: pid=%d\n", getpid());sem_v(sem_id);  /*释放资源*/}else  /*父进程*/{sem_p(sem_id);   /*等待资源*/printf("Process father: pid=%d\n", getpid());sem_v(sem_id);   /*释放资源*/del_sem(sem_id); /*删除信号量集*/}return 0;
}

上面的例子如果不加信号量，则父进程会先执行完毕。这里加了信号量让父进程等待子进程执行完以后再执行

2.5 共享内存

为了避免像消息队列那样频繁的拷贝消息、进行系统调用，共享内存机制出现了。

顾名思义，共享内存就是允许不相干的进程将同一段物理内存连接到它们各自的地址空间中，使得这些进程可以访问同一个物理内存，这个物理内存就成为共享内存。如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。

集合内存管理的内容，我们来深入理解下共享内存的原理。首先，每个进程都有属于自己的进程控制块（PCB）和逻辑地址空间（Addr Space），并且都有一个与之对应的页表，负责将进程的逻辑地址（虚拟地址）与物理地址进行映射，通过内存管理单元（MMU）进行管理。两个不同进程的逻辑地址通过页表映射到物理空间的同一区域，它们所共同指向的这块区域就是共享内存。

2.5.1 特点

共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
因为多个进程可以同时操作，所以需要进行同步。
信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。

2.5.2 原型

当用shmget函数创建一段共享内存时，必须指定其 size；而如果引用一个已存在的共享内存，则将 size 指定为0 。

当一段共享内存被创建以后，它并不能被任何进程访问。必须使用shmat函数连接该共享内存到当前进程的地址空间，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问。

shmdt函数是用来断开shmat建立的连接的。注意，这并不是从系统中删除该共享内存，只是当前进程不能再访问该共享内存而已。

shmctl函数可以对共享内存执行多种操作，根据参数 cmd 执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）

#include <sys/shm.h>
// 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
int shmget(key_t key, size_t size, int flag);
// 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
void *shmat(int shm_id, const void *addr, int flag);
// 断开与共享内存的连接：成功返回0，失败返回-1
int shmdt(void *addr); 
// 控制共享内存的相关信息：成功返回0，失败返回-1
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

下面这个例子，使用了【共享内存+信号量+消息队列】的组合来实现服务器进程与客户进程间的通信。
共享内存用来传递数据；
信号量用来同步；
消息队列用来在客户端修改了共享内存后通知服务器读取。

2.5.3 代码示例

//server.c#include<stdio.h>
#include<stdlib.h>
#include<sys/shm.h>  // shared memory
#include<sys/sem.h>  // semaphore
#include<sys/msg.h>  // message queue
#include<string.h>   // memcpy// 消息队列结构
struct msg_form {long mtype;char mtext;
};// 联合体，用于semctl初始化
union semun
{int              val; /*for SETVAL*/struct semid_ds *buf;unsigned short  *array;
};// 初始化信号量
int init_sem(int sem_id, int value)
{union semun tmp;tmp.val = value;if(semctl(sem_id, 0, SETVAL, tmp) == -1){perror("Init Semaphore Error");return -1;}return 0;
}// P操作:
//  若信号量值为1，获取资源并将信号量值-1 
//  若信号量值为0，进程挂起等待
int sem_p(int sem_id)
{struct sembuf sbuf;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;}return 0;
}// V操作：
//  释放资源并将信号量值+1
//  如果有进程正在挂起等待，则唤醒它们
int sem_v(int sem_id)
{struct sembuf sbuf;sbuf.sem_num = 0; /*序号*/sbuf.sem_op = 1;  /*V操作*/sbuf.sem_flg = SEM_UNDO;if(semop(sem_id, &sbuf, 1) == -1){perror("V operation Error");return -1;}return 0;
}// 删除信号量集
int del_sem(int sem_id)
{union semun tmp;if(semctl(sem_id, 0, IPC_RMID, tmp) == -1){perror("Delete Semaphore Error");return -1;}return 0;
}// 创建一个信号量集
int creat_sem(key_t key)
{int sem_id;if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1){perror("semget error");exit(-1);}init_sem(sem_id, 1);  /*初值设为1资源未占用*/return sem_id;
}int main()
{key_t key;int shmid, semid, msqid;char *shm;char data[] = "this is server";struct shmid_ds buf1;  /*用于删除共享内存*/struct msqid_ds buf2;  /*用于删除消息队列*/struct msg_form msg;  /*消息队列用于通知对方更新了共享内存*/// 获取key值if((key = ftok(".", 'z')) < 0){perror("ftok error");exit(1);}// 创建共享内存if((shmid = shmget(key, 1024, IPC_CREAT|0666)) == -1){perror("Create Shared Memory Error");exit(1);}// 连接共享内存shm = (char*)shmat(shmid, 0, 0);if((int)shm == -1){perror("Attach Shared Memory Error");exit(1);}// 创建消息队列if ((msqid = msgget(key, IPC_CREAT|0777)) == -1){perror("msgget error");exit(1);}// 创建信号量semid = creat_sem(key);// 读数据while(1){msgrcv(msqid, &msg, 1, 888, 0); /*读取类型为888的消息*/if(msg.mtext == 'q')  /*quit - 跳出循环*/ break;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);return 0;
}

//client.c#include<stdio.h>
#include<stdlib.h>
#include<sys/shm.h>  // shared memory
#include<sys/sem.h>  // semaphore
#include<sys/msg.h>  // message queue
#include<string.h>   // memcpy// 消息队列结构
struct msg_form {long mtype;char mtext;
};// 联合体，用于semctl初始化
union semun
{int              val; /*for SETVAL*/struct semid_ds *buf;unsigned short  *array;
};// P操作:
//  若信号量值为1，获取资源并将信号量值-1 
//  若信号量值为0，进程挂起等待
int sem_p(int sem_id)
{struct sembuf sbuf;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;}return 0;
}// V操作：
//  释放资源并将信号量值+1
//  如果有进程正在挂起等待，则唤醒它们
int sem_v(int sem_id)
{struct sembuf sbuf;sbuf.sem_num = 0; /*序号*/sbuf.sem_op = 1;  /*V操作*/sbuf.sem_flg = SEM_UNDO;if(semop(sem_id, &sbuf, 1) == -1){perror("V operation Error");return -1;}return 0;
}int main()
{key_t key;int shmid, semid, msqid;char *shm;struct msg_form msg;int flag = 1; /*while循环条件*/// 获取key值if((key = ftok(".", 'z')) < 0){perror("ftok error");exit(1);}// 获取共享内存if((shmid = shmget(key, 1024, 0)) == -1){perror("shmget error");exit(1);}// 连接共享内存shm = (char*)shmat(shmid, 0, 0);if((int)shm == -1){perror("Attach Shared Memory Error");exit(1);}// 创建消息队列if ((msqid = msgget(key, 0)) == -1){perror("msgget error");exit(1);}// 获取信号量if((semid = semget(key, 0, 0)) == -1){perror("semget error");exit(1);}// 写数据printf("***************************************\n");printf("*                 IPC                 *\n");printf("*    Input r to send data to server.  *\n");printf("*    Input q to quit.                 *\n");printf("***************************************\n");while(flag){char c;printf("Please input command: ");scanf("%c", &c);switch(c){case 'r':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);break;case 'q':msg.mtype = 888;msg.mtext = 'q';msgsnd(msqid, &msg, sizeof(msg.mtext), 0);flag = 0;break;default:printf("Wrong input!\n");/*清空标准输入缓冲区*/while((c=getchar())!='\n' && c!=EOF);}}// 断开连接shmdt(shm);return 0;
}

2.6 socket

Socket 起源于 Unix，原意是插座，在计算机通信领域，Socket 被翻译为套接字，它是计算机之间进行通信的一种约定或一种方式。通过 Socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。

从计算机网络层面来说，Socket 套接字是网络通信的基石，是支持 TCP/IP 协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议，本地主机的 IP 地址，本地进程的协议端口，远地主机的 IP 地址，远地进程的协议端口。

Socket 的本质其实是一个编程接口（API），是应用层与 TCP/IP 协议族通信的中间软件抽象层，它对 TCP/IP 进行了封装。它把复杂的 TCP/IP 协议族隐藏在 Socket 接口后面。对用户来说，只要通过一组简单的 API 就可以实现网络的连接。
详细介绍及代码请看下面链接：
socket基础知识博客

三、总结

1.管道： 速度慢，容量有限，只有父子进程能通讯

2.FIFO： 任何进程间都能通讯，但速度慢

3.消息队列： 容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题

4.信号量： 不能传递复杂消息，只能用来同步

5.共享内存区： 能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存

四、其他相关链接

1. Linux下进程管理基础知识总结

2. socket通信原理及相关函数总结

3. Linux下内核空间和用户空间内存映射图详解