进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。
 
IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。
 
一、管道
 
管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。
 
1、特点：
 
 
它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。
 
 
它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。
 
 
它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
 
 
 
二、FIFO
 
FIFO，也称为命名管道，它是一种文件类型。
 
1、特点
 
 
FIFO可以在无关的进程之间交换数据，与无名管道不同。
 
 
FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
 
 
 
三、消息队列
 
消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识。
 
1、特点
 
 
消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
 
 
消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
 
 
消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
 
 
 
四、信号量
 
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
 
1、特点
 
 
信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
 
 
信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
 
 
每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
 
 
支持信号量组。
 
 
 
五、共享内存
 
共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。
 
1、特点
 
 
共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
 
 
因为多个进程可以同时操作，所以需要进行同步。
 
 
信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。
 
进程间的五种通信方式介绍
 
 

HC-05蓝牙串口通信模块应该是使用最广泛的一种蓝牙模块之一了。为什么呢？
 
因为HC05模块是一款高性能主从一体蓝牙串口模块，可以不用知道太多蓝牙相关知识就可以很好的上手。说白了，只是个蓝牙转串口的设备，你只要知道串口怎么编程使用，就可以了，实现了所谓的透明传输。
 
但是就是这么一个很常见的模块，网上很多的博客写的都是错的，或者都是很不详细的。
 
所以本文就介绍一下这款蓝牙通信模块的使用，包括蓝牙模块的调试、手机与蓝牙模块之间的传输、手机蓝牙控制STM32单片机，应该是逐渐深入的一个过程。但是这仅仅是使用，以后有时间应该会对蓝牙有一个稍微深度的学习，而不能仅仅是浮于表面，只会用。
 
 
 
模块名称：HC-05蓝牙串口通信模块
 
参考资料：HC-05蓝牙串口通信模块官方资料包
 
知识储备：【STM32】串口通信基本原理（超基础、详细版）
 
其他模块：USB转TTL模块、手机蓝牙串口助手app
 
手机蓝牙串口助手软件，可以点击链接下载：蓝牙串口。因为这是我见过所有手机端界面最好看的了，其他的界面都有点太糟糕了。
 
 
 
蓝牙模块的调试
 
准备工作
 
USB转TTL模块与HC-05蓝牙模块的接线：
 
两模块共地，两模块共VCC（VCC取5V）；蓝牙模块的RX接转换模块的TX，蓝牙模块的TX接转换模块的RX。如下图所示：
 
 
这个时候就要将转换模块连接到电脑上，然后利用串口调试助手进行蓝牙模块的调试。
 
附可能会用到的驱动：链接：https://pan.baidu.com/s/1bpYLfCr 密码：yabv
 
蓝牙模块的调试
 
HC-05蓝牙串口通讯模块具有两种工作模式：命令响应工作模式和自动连接工作模式。在自动连接工作模式下模块又可分为主（Master）、从（Slave）和回环（Loopback）三种工作角色。
 
当模块处于自动连接工作模式时，将自动根据事先设定的方式连接的数据传输；
当模块处于命令响应工作模式时能执行AT命令，用户可向模块发送各种AT 指令，为模块设定控制参数或发布控制命令。
怎么进入命令响应工作模式？
 
进入命令响应工作模式有两种方法：
 
模块上电，未配对情况下就是AT模式，波特率为模块本身的波特率，默认：9600，发送一次AT指令时需要置高一次PIO11；
PIO11 置高电平后，再给模块上电，此时模块进入AT 模式，波特率固定为：38400，可以直接发送AT指令。
什么叫做置高一次PIO11？
 
在蓝牙模块中有一个小按键，按一下就置高一次PIO11。也就是说，第一种方法需要每发送一次AT指令按一次；而第二种方式是长按的过程中上电，之后就无需再管了，直接发送AT命令即可。
 
需要注意一下，两种进入命令响应工作模式的方式使用的波特率是不一样的，建议使用第二种方式。
 
怎么区分进了命令响应工作模式呢？
 
在蓝牙模块上有灯，当灯快闪的时候，就是自动连接工作模式；当灯慢闪的时候，就是命令响应工作模式。
 
AT命令
 
进入到命令响应工作模式之后，就可以使用串口调试助手进行蓝牙调试了。
 
首先有一点，AT指令不区分大小写，均以回车、换行结尾。下面介绍常用的AT指令：
 

  常用AT指令
 
指令名
响应
含义
AT
OK
测试指令
AT+RESET
OK
模块复位
AT+VERSION?
+VERSION:<Param> OK
获得软件版本号
AT+ORGL
OK
恢复默认状态
AT+ADDR?
+ADDR:<Param> OK
获得蓝牙模块地址
AT+NAME=<Param>
OK
设置设备名称
AT+NAME?
+NAME:<Param> OK
获得设备名称
AT+PSWD=<Param>
OK
设置模块密码
AT+PSWD?
+PSWD:<Param> OK
获得模块密码
AT+UART=<Param1>,<Param2>,<Param3>
OK
设置串口参数
AT+UART?
+UART:<Param1>,<Param2>,<Param3> OK
获得串口参数
对于AT指令，有几点注意：
 
AT+NAME?：获得设备名称，这个AT指令有很大可能性是没有返回的，因为我也看到了很多的例子……，但是其他的指令都是没有问题的，直接设置设备名称就行了；
AT+UART?：获得串口参数，串口的参数一共有三个，波特率、停止位、检验位。其取值如下：

  串口参数
 
参数名称
取值
波特率
 
2400、4800、9600、19200、38400、5760、
 
115200、230400、460800、921600、1382400
 
停止位
 
0：1位
 
1：2位
 
校验位
0：NONE  1：Odd  2：Even
其默认值为：9600，0，0。
 
例子：
 
 
本文中，蓝牙串口的波特率设置成115200。之后的内容，就会采用这个波特率来进行通讯了。
 
 
 
手机与蓝牙模块之间的传输
 
直接将蓝牙模块与转换模块连接，再讲其连接到电脑上，蓝牙模块直接进入自动连接工作模式。
 
此时手机打开蓝牙串口调试应用，用其来连接蓝牙模块。手机蓝牙串口助手软件，可以点击链接下载：蓝牙串口。万分推荐这款，因为界面脱离了那种黑不溜秋的感觉，比较简洁、清爽。
 
这个软件的使用：点击界面右下角蓝牙的标志，选择蓝牙进行连接。
 
然后在电脑上的调试助手和手机的蓝牙串口调试应用之间就可以相互传输了，比如：
 
 
 
可以清楚的看到：电脑向手机发送了“hello you”，手机向电脑发送了“hello world”。
 
 
 
手机蓝牙控制STM32单片机
 
之前的两个例子都是相比较而言比较简单的，这个例子将会涉及到程序的内容了。
 
实现功能：手机通过蓝牙，向STM32单片机发送消息，STM32接收到消息之后原封不动的返回给手机。当然如果掌握了这个例子，也可以修改成，手机发送特定的消息，然后，STM32单片机做出相对应的动作。比如：点亮LED等、发动电机等等。
 
连接说明
 
 
使用USART1进行试验，也就是说STM32选取PA9、PA10来和HC-05进行连接。同时手机通过蓝牙来和HC-05进行连接。
 
原理就是：手机通过蓝牙传输到HC-05上，再通过串口通信和STM32通信；而之前一般都是电脑上通过USB线转串口的方式，通过串口和STM32通信。本质上没有区别的。
 
这个时候就应该更加深刻地体会到了本文开篇的一句话：说白了，只是个蓝牙转串口的设备，你只要知道串口怎么编程使用，就可以了，实现了所谓的透明传输。蓝牙的相关一切都被封装起来了，都不需要接触到。
 
STM32控制程序
 
#include "stm32f10x.h"

 void My_USART1_Init(void)  
{  
    GPIO_InitTypeDef GPIO_InitStrue;  
    USART_InitTypeDef USART_InitStrue;  
    NVIC_InitTypeDef NVIC_InitStrue;  
      
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//GPIO端口使能  
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//串口端口使能  
      
    GPIO_InitStrue.GPIO_Mode=GPIO_Mode_AF_PP;  
    GPIO_InitStrue.GPIO_Pin=GPIO_Pin_9;  
    GPIO_InitStrue.GPIO_Speed=GPIO_Speed_10MHz;  
    GPIO_Init(GPIOA,&GPIO_InitStrue);  
      
    GPIO_InitStrue.GPIO_Mode=GPIO_Mode_IN_FLOATING;  
    GPIO_InitStrue.GPIO_Pin=GPIO_Pin_10;  
    GPIO_InitStrue.GPIO_Speed=GPIO_Speed_10MHz;  
    GPIO_Init(GPIOA,&GPIO_InitStrue);  
      
    USART_InitStrue.USART_BaudRate=115200;  
    USART_InitStrue.USART_HardwareFlowControl=USART_HardwareFlowControl_None;  
    USART_InitStrue.USART_Mode=USART_Mode_Tx|USART_Mode_Rx;  
    USART_InitStrue.USART_Parity=USART_Parity_No;  
    USART_InitStrue.USART_StopBits=USART_StopBits_1;  
    USART_InitStrue.USART_WordLength=USART_WordLength_8b;  
      
    USART_Init(USART1,&USART_InitStrue);
      
    USART_Cmd(USART1,ENABLE);//使能串口1  
      
    USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//开启接收中断  
      
    NVIC_InitStrue.NVIC_IRQChannel=USART1_IRQn;  
    NVIC_InitStrue.NVIC_IRQChannelCmd=ENABLE;  
    NVIC_InitStrue.NVIC_IRQChannelPreemptionPriority=1;  
    NVIC_InitStrue.NVIC_IRQChannelSubPriority=1;  
    NVIC_Init(&NVIC_InitStrue);  
      
}  
  
void USART1_IRQHandler(void)  
{  
    u8 res;  
     if(USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET)  
 {  
     res= USART_ReceiveData(USART1); 	 
     USART_SendData(USART1,res);     
  }  
}  
   
 int main(void)  
 {    
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  
    My_USART1_Init();  
     while(1);  
       
 } 
 
这段程序和【STM32】串口相关配置寄存器、库函数（UART一般步骤）中的程序一模一样，几乎没有什么改动。
 
区别就是，在UART实验中，USART1是和USB转串口模块连接在一起的，然后与电脑上的串口调试助手进行通信；现在改成USART1是和蓝牙模块连接在一起的，然后和手机上的蓝牙串口调试助手进行通信。
 
 
 

题记：机器人中常用的通信方式有3种，tcp通信，udp通信，can通信 
 1、套接字（socket） 
 1.1、什么是socket 
 socket是一种通信机制，可以应用于计算机不同进程之间通信，包括同一台计算机和网络中不同计算机之间的进程之间通信，结果就是支持分布在网络中的各个服务端/客户端的通信。 
 socket的字面意思是插座，插座的作用提供电源，也就是所谓的服务端，相应的插头是客户端，插头插到插座里，联通得到相应的电压，也就是获得相应通信连接。 
 需要注意的是：socket一旦建立连接，通信是双向通信。 
 1.2 socket连接方式 
 socket连接方式用以下步骤来说明。 
 服务端： 
 1)创建socket，也就是创建服务端（插座） 
 2)服务器进程给套接字命名，调用blind函数 
 3)服务器进程监听客户端的请求连接队列，调用listen函数 
 4)服务器进程接受客服连接，调用accept函数，此时程序创建一个新的套接字专门处理一个客户连接，2)步骤的命名的套接字继续用来监听客户连接，一旦调用accept，则继续创建新的套接字。 
 客户端： 
 1)创建一个未命名的套接字（插头） 
 2)命名客户端套接字，根据服务端信息来命名客户端套接字 
 3)指定服务器端地址（找到插座地址），调用connect函数，建立连接
 
本地客户端的例子： 
 client.c
 
//必要的头文件
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>

int main(){
//1)设置变量
int sockfd;//用来装载创建套接字的结果
int len;
struct sockaddr_un address;//用来装载服务端给定的地址
int result;//用来装载是否连接成功的结果1表示成功，-1表示失败
char ch='A';
//2)创建客户端套接字
sockfd=socket(AF_UNIX,SOCK_STREAM,0);
//3)根据服务端，给套接字命名
address.sun_family=AF_UNIX;
strcpy(address.sun_path,"server_socket");
len=sizeof(address);
//4)连接到服务端套接字
result=connet(sockfd,(struct sockaddr*)&address,len);
if(result==-1){
perror("oops:client1");
exit(0);
}
//5)通过套接字进行读写操作
write(sockfd,&ch,1);//通过套接字，修改了ch变量
read(sockfd,&ch,1);//通过套接字，读取了ch变量
printf("char from server=%c\n",ch);
close(sockfd);//用完套接字后关闭
exit(0);
}
 
下面给出一个本地服务端的标准例子 
 server1.c
 
//必要的头文件
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.b>

int main(){
//1)创建必要的变量
int server_sockfd,client_sockfd;//分别用来装载创建的套接字的值
int server_len,client_len;//套接字地址的长度
struct sockaddr_un server_address;//装载套接字地址
struct sockaddr_un client_address;
//2)删除以前的套接字，创建一个未命名的套接字
unlink("server_socket");
server_sockfd=socket(AF_UNIX,SOCK_STREAM,0);
//3)命名套接字
server_address.sun_family=AF_UNIX;
strcpy(server_address.sun_path,"server_socket");
server_len=sizeof(server_address);
blind(server_sockfd,(struct sockaddr*)&server_address,server_len);
//4)创建连接队列，等待客户进行连接
listen(server_sockfd,5);//监听队列为5
while(1){
char ch;
printf("server wating\n");
//服务端接受一个连接
client_len=sizeof(client_address);
client_sockfd=accept(server_sockfd,(struct sockaddr*)&client_address,&client_lent);
//6)对接受的客户端的套接字进行读写
read(client_sockfd,&ch,1);
ch++;
write(client_sockfd,&ch,1);
close(client_sockfd);//用完套接字后需要关闭
}
}

 
 
http://blog.csdn.net/liuzhanchen1987/article/details/7452910
 
 
 
程序员必须让拥有依赖关系的进程集协调，这样才能达到进程的共同目标。可以使用两种技术来达到协调。第一种技术在具有通信依赖关系的两个进程间传递信息。这种技术称做进程间通信（interprocess communication）。第二种技术是同步，当进程间相互具有合作依赖时使用。这两种类型的依赖关系可以同时存在。
 
 
一般而言，进程有单独的地址空间。我们可以了解下可执行程序被装载到内存后建立的一系列映射等理解这一点。如此以来意味着如果我们有两个进程（进程A和进程B），那么，在进程A中声明的数据对于进程B是不可用的。而且，进程B看不到进程A中发生的事件，反之亦然。如果进程A和B一起工作来完成某个任务，必须有一个在两个进程间通信信息和时间的方法。我们这里可以去看看基本的进程组件。注意进程有一个文本、数据以及堆栈片断。进程可能也有从自由存储空间中分配的其它内存。进程所占有的数据一般位于数据片断、堆栈片断或进程的动态分配内存中。数据对于其它进程来说是受保护的。为了让一个进程访问另外一个进程的数据，必须最终使用操作系统调用。与之类似，为了让一个进程知道另一个进程中文本片断中发生的事件，必须在进程间建立一种通信方式。这也需要来自操作系统API的帮助。当进程将数据发送到另一进程时，称做IPC（interprocess communication,进程间通信）。下面先列举几种不同类型的进程间通信方式：
 
 
进程间通信                                 描述
 
 
环境变量/文件描述符            子进程接受父进程环境数据的拷贝以及所有文件描述符。父进程可以在它的数据片断或环境中设置一定的变量，同时子进程接收这些值。父进程可以打开文件，同时推进读/写指针的位置，而且子进程使用相同的偏移访问该文件。
 
 
命令行参数                      在调用exec或派生函数期间，命令行参数可以传递给子进程。
 
 
管道                            用于相关和无关进程间的通信，而且形成两个进程间的一个通信通道，通常使用文件读写程序访问。
 
 
共享内存                        两个进程之外的内存块，两个进程均可以访问它。
 
 
DDE（动态数据交换，Dynamic data exchange）     使用客户机/服务器模型（C/S），服务器对客户的数据     或动作请求作出反应。
 
 
一、环境变量、文件描述符：
 
 
当创建一个子进程时，它接受了父进程许多资源的拷贝。子进程接受了父进程的文本、堆栈
 
 
以及数据片断的拷贝。子进程也接受了父进程的环境数据以及所有文件描述符的拷贝。子进
 
 
程从父进程继承资源的过程创造了进程间通信的一个机会。父进程可以在它的数据片断或环
 
 
境中设置一定的变量，子进程于是接受这些值。同样，父进程也可以打开一个文件，推进到
 
 
文件内的期望位置，子进程接着就可以在父进程离开读/写指针的准确位置访问该文件。
 
 
这类通信的缺陷在于它是单向的、一次性的通信。也就是说，除了文件描述外，如果子进程
 
 
继承了任何其它数据，也仅仅是父进程拷贝的所有数据。 一旦创建了子进程，由子进程对
 
 
这些变量的任何改变都不会反映到父进程的数据中。同样，创建子进程后，对父进程数据的
 
 
任何改变也不会反映到子进程中。所以，这种类型的进程间通信更像指挥棒传递。一旦父进
 
 
程传递了某些资源的拷贝，子进程对它的使用就是独立的，必须使用原始传递资源。
 
 
二、命令行参数：
 
 
通过命令行参数（command-line argument）可以完成另一种单向、一次性的进程间通信
 
 
我前面的文章已经提到过使用命令行参数。命令行参数在调用一个exec或派生调用操作系
 
 
统时传递给子进程。命令行参数通常在其中一个参数中作为NULL终止字符串传递给exec
 
 
或派生函数调用。这些函数可以按单向、一次性方式给子进程传递值。WINDOWS有调用执行
 
 
exe程序的API。大家可以去参考一下ShellExecuteA函数相关。
 
 
三、管道通信：
 
 
继承资源以及命令行参数是最简单形式的进程间通信。它们同时有两个主要限制。除了文件
 
 
描述符外，继承资源是IPC的单向、一次性形式。传递命令参数也是单向、一次性的IPC
 
 
方法。这些方法也只有限制于关联进程，如果不关联，命令行参数和继承资源不能使用。还
 
 
有另一种结构，称做管道(Pipe)，它可以用于在关联进程间以及无关联进程间进行通信。
 
 
管道是一种数据结构，像一个序列化文件一样访问。它形成了两个进程间的一种通信渠道。
 
 
管道结构通过使用文本和写方式来访问。如果进程A希望通过管道发送数据给进程B，那么
 
 
进程A向管道写入数据。为了让进程B接收此数据，进程B必须读取管道，与命令行参数的
 
 
IPC形式不一样。管道可以双向通信。两进程间的数据流是双向通信的。管道可以在程序的
 
 
整个执行期间使用，在进程间发送和接收数据。所以，管道充当可访问管道的进程间的一种
 
 
可活链接，有两种基本管道类型：
 
 
1．  匿名管道
 
 
2．  命名管道
 
 
 
 
上面的图可以看出在没有管道时，两进程是不能互写的。
 
 
 
 
建立管道后就可以相互通信了。
 
 
只有关联进程可以使用匿名管道来通信。无关联进程必须使用命名管道。
 
 
匿名管道：通过文件描述符或文件句柄提供对匿名管道的访问。对系统API的调用创建一个管道，并返回一个文件描述符。这个文件描述符是用作read()或write()函数的一个参数。当通过文件描述符调用read()或write()时，数据的源和目标就是管道。例如，在OS/2环境中使用操作系统函数DosCreatePipe()创建匿名管道：
 
 
int mian( void )
 
 
{
 
 
    PFHILE readHandle;
 
 
PFHILE writeHandle;
 
 
DosCreatePipe( readHandle, writeHandle, size );
 
 
…
 
 
…
 
 
…
 
 
}
 
 
在WINDOWS下例如我写的ASM集成环境通过管道与DOS命令行通信的MFC下代码块：
 
 
void CIDEManager::Commond( CString cmd, char* buf, unsigned int bufsize )
 
 
{
 
 
    SECURITY_ATTRIBUTES sa;
 
 
    HANDLE hRead, hWrite;
 
 
    sa.nLength              = sizeof( SECURITY_ATTRIBUTES );
 
 
    sa.lpSecurityDescriptor = NULL;
 
 
sa.bInheritHandle       = TRUE;
 
 
    if ( !CreatePipe( &hRead, &hWrite, &sa, 0 ) )  // 创建管道
 
 
    {
 
 
        return;
 
 
    }
 
 
    STARTUPINFO si;
 
 
    PROCESS_INFORMATION pi;
 
 
    si.cb = sizeof( STARTUPINFO );
 
 
    GetStartupInfo( &si );
 
 
    si.hStdError   = hWrite;
 
 
    si.hStdOutput  = hWrite;
 
 
    si.wShowWindow = SW_HIDE;
 
 
    si.dwFlags     = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
 
 
if ( !CreateProcess( NULL, ( LPTSTR )( LPCTSTR )cmd, NULL, NULL, TRUE, NULL, NULL, NULL, &si, &pi ) )
 
 
    {
 
 
        return;
 
 
    }
 
 
    CloseHandle( hWrite );
 
 
    DWORD bytesRead;
 
 
    while ( TRUE ) 
 
 
    {
 
 
        memset( buf, 0, bufsize );
 
 
        if ( ReadFile( hRead, buf, bufsize, &bytesRead, NULL ) != NULL )
 
 
        {
 
 
            break;
 
 
        }
 
 
        Sleep( 200 );
 
 
    }
 
 
    CloseHandle( hRead );
 
 
    return;
 
 
}
 
 
命名管道：将管道用作两个无关联进程间的通信渠道，程序员必须使用命名管道，它可以看作一种具有某名字的特殊类型文件。进程可以根据它的名字访问这个管道。通过匿名管道，父和子进程可以单独使用文件描述符来访问他们所共享的管道，因为子进程继承了父进程的文件描述符，同时文件描述符用read()或write()函数的参数。因为无关进程不能访问彼此的文件描述符，所以不能使用匿名管道。由于命名管道提供该管道的一个等价文件名，任何知道此管道名字的进程都可以访问它。下面是命名管道相对于匿名管道的优点：
 
 
命名管道可以被无关联进程使用。
 
 
命名管道可以持久。创建它的程序退出后，它们仍然可以存在。
 
 
命名管道可以在网络或分布环境中使用。
 
 
命名管道容易用于多对一关系中。
 
 
与访问匿名管道一样，命名管道也是通过read()或write()函数来访问。两者之间的主要区别在于命名管道的创建方式以及谁可以反问它们。命名管道可以建立一个进程间通信的C/S模型。访问命名管道的进程可能都位于同一台机器上，或位于通过网络通信的不同机器上。由于管道的名字可以通过管道所在服务器的逻辑名，所以能够跨网络访问管道。例如，ServerName//Pipe//MyPipe（不区分大小写）可以作为一个管道名字。假如Server1是网络服务器的名字。当打开或访问这个管道的调用解析文件名时，首先应该定位Server1，然后访问MyPipe。例子如下：
 
 
服务器端：
 
 
int main( void )
 
 
{
 
 
    HANDLE pipehandle;
 
 
    char buf[ 256 ];
 
 
DWORD bytesRead;
 
 
      if( ( pipehandle = CreateNamedPipe( ".//Pipe//cao", PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, 1, 0, 0, 5000, NULL ) ) == INVALID_HANDLE_VALUE )
 
 
    {
 
 
        printf( "CreateNamedPipe failed with error %d/n", GetLastError() );
 
 
        system( "pause" );
 
 
        return 0;
 
 
    }
 
 
    printf( "server is running/n" );  
 
 
    if( ConnectNamedPipe( pipehandle, NULL ) == 0 )
 
 
    {
 
 
        printf( "connectNamedPipe failed with error %d/n", GetLastError() );
 
 
        CloseHandle( pipehandle );
 
 
        system( "pause" );
 
 
        return 0;
 
 
    }     
 
 
    if( ReadFile( pipehandle, buf, sizeof( buf ), &bytesRead, NULL ) == 0 )
 
 
    {
 
 
        printf( "ReadFile failed with error %d/n", GetLastError() );
 
 
        CloseHandle( pipehandle );
 
 
        system( "pause" );
 
 
        return 0;
 
 
    }
 
 
    printf( "%s/n", buf );       
 
 
    if ( DisconnectNamedPipe( pipehandle ) == 0 )
 
 
    {
 
 
        printf( "DisconnectNamedPipe failed with error %d/n", GetLastError() );
 
 
        CloseHandle( pipehandle );
 
 
        system( "pause" );
 
 
        return 0;
 
 
    }
 
 
    system( "pause" );
 
 
    return 0;
 
 
}
 
 
客户端：
 
 
int main( void )
 
 
{
 
 
    HANDLE pipehandle;
 
 
    DWORD writesbytes;
 
 
    char buff[ 256 ];
 
 
    if( WaitNamedPipe( ".//Pipe//cao", NMPWAIT_WAIT_FOREVER ) == 0 )
 
 
    {
 
 
        printf( "WaitNamedPipe failed with error %d/n", GetLastError() );
 
 
        system( "pause" );
 
 
        return 0;
 
 
    }
 
 
     if( ( pipehandle = CreateFile( ".//Pipe//cao", GENERIC_READ | GENERIC_WRITE, 0, ( LPSECURITY_ATTRIBUTES )NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, ( HANDLE )NULL ) ) == INVALID_HANDLE_VALUE )
 
 
    {
 
 
        printf( "CreateFile failed with error %d/n", GetLastError() );
 
 
        system( "pause" );
 
 
        return 0;
 
 
    }
 
 
    ZeroMemory( &buff, sizeof( buff ) );
 
 
    gets( buff );
 
 
    if( WriteFile( pipehandle, buff, sizeof( buff ), &writesbytes, NULL ) == 0 )
 
 
    {
 
 
        printf( "WriteFile failed with error %d/n", GetLastError() );
 
 
        CloseHandle( pipehandle );
 
 
        system( "pause" );
 
 
        return 0;
 
 
    }     
 
 
    printf( "write %d bytes", writesbytes );
 
 
    CloseHandle( pipehandle );
 
 
    system( "pause" );
 
 
    return 0;
 
 
}
 
 
命名管道不仅可用于无关联进程间、位于不同机器上的两进程间的通信，而且可用于多对一通信，可以建立服务器进程，允许同时通过多个客户访问命名管道。命名管道常常用于多线程服务器。
 
 
四、 共享内存
 
 
共享内存也可以实现进程间的通信。进程需要可以被其他进程浏览的内存块。希望访问这个内存块的其他进程请求对它的访问，或由创建它的进程授予访问内存块的权限。可以访问特定内存块的所有进程对它具有即时可见性。共享内存被映射到使用它的每个进程的地址空间。所以，它看起来像是另一个在进程内声明的变量。当一个进程写共享内存，所有的进程都立即知道写入的内容，而且可以访问。
 
 
进程间共享内存的关系与函数间全局变量的关系相似。程序中的所有函数都可以使用全局变量的值。同样，共享内存块可以被正在执行的所有进程访问。内存块可能共享一个逻辑地址，进程也可以共享某些物理地址。
 
 
共享内存块的创建必须由一个系统API调用来完成。在WIN32环境中，使用CreateFileMapping()、MapViewOfFile()以及MapViewOfFileEx() API能很好地完成。
 
 
共享内存分配位于WIN32系统中2~3GB地址范围内。一旦调用MapViewOfFile()和MapViewOfFileEx(),共享文件映射对象的所有进程都可以立即访问此内存块，而且在需要时，可以读写此内存块。
 
 
五、动态数据交换
 
 
动态数据交换( dynamic data exchange ) 是当今可用的进程间通信最强大和完善的形式之一。动态数据交换使用消息传递、共享内存、事务协议、客户/服务器范畴、同步规则以及会话协议来让数据和控制信息在进程间流动。动态数据交换对话( dynamic data exchange session, DDE )的基本模型是客户、服务器。服务器对来自客户的数据或动作作出反应。客户和服务器可以以多种关系来通信。
 
 
一个服务器可以与任意数量的客户通信。一个客户也可以与任意数量的服务器通信。单个DDE代理既可以是客户，也可以是服务器。也就是说，进程可以从一个正为另一个进程执行服务的DDE代理请求服务。