邮槽和命名管道的区别

最新推荐文章于 2024-05-16 17:27:57 发布
最新推荐文章于 2024-05-16 17:27:57 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： vc知识集锦 文章标签： vc++ c++ windows 对话框 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heary29/article/details/43954769
版权
邮槽：只允许从客户端发送到服务器，没有可靠性保证，根据广播通信体系所设计，使用邮槽可以建立不可靠的单向数据传输。其优点就是可以很方便的向一个或者多个服务器广播消息

  管道（Pipe）实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。命名管道（Named Pipes）是在管道服务器和一台或多台管道客户机之间进行单向或双向通信的一种命名的管道。一个命名管道的所有实例共享同一个管道名，但是每一个实例均拥有独立的缓存与句柄，并且为客户——服务通信提供有一个分离的管道。实例的使用保证了多个管道客户能够在同一时间使用同一个命名管道。

消息管道(Message Pipe)
用于设置应用程序间的一条永久通讯通道，通过该通道可以象自己的应用程序访问一个平面文件一样读写数据。
匿名管道(Anonymous Pipes)
单向流动，并且只能够在同一电脑上的各个进程之间流动。
命名管道(Named Pipes)
双向，跨网络，任何进程都可以轻易的抓住，放进管道的数据有固定的格式，而使用ReadFile()只能读取该大小的倍数。
可以被使用于I/O Completion Ports
 
相同点：
1、  都是进程间的通信
2、  都是在重命名机制的基础上实现的（）
3、  都采用通用命名规则UNC（Universal Naming Convention）
4、  支持多客户端链接？？？
不同点：
1、  邮槽是单向通信，服务器只读，客户端只写，不支持重叠IO模式
2、  命名管道，可以是双向通信，可以采用重叠IO模式


邮槽的实现：
服务端：
1) 用CreateMailslot API函数创建一个邮槽句柄。
2) 调用ReadFile API函数，并使用现成的邮槽句柄，从任何客户机接收数据。
客户端：
1) 使用CreateFile这个API函数，针对想向其传送数据的邮槽，打开指向它的一个引用句
柄。
2) 调用WriteFile这个API函数，向邮槽写入数据。
 
命名管道的实现：
服务端：
1) 使用API函数CreateNamedPipe，创建一个命名管道实例句柄。
    2) 使用API函数ConnectNamedPipe，在命名管道实例上监听客户机连接请求。
    3) 分别使用ReadFile和WriteFile这两个API函数，从客户机接收数据，或将数据发给客户
机。
    4) 使用API函数DisconnectNamedPipe，关闭命名管道连接。
    5) 使用API函数CloseHandle，关闭命名管道实例句柄。
客户端：
1) 用API函数WaitNamedPipe，等候一个命名管道实例可供自己使用。
    2) 用API函数CreateFile，建立与命名管道的连接。
    3) 用API函数WriteFile和ReadFile，分别向服务器发送数据，或从中接收数据。
    4) 用API函数CloseHandle，关闭打开的命名管道会话。



命名管道的代码实现：
     服务端：
    

view plaincopy to clipboardprint?
// PipeServer.cpp : Defines the entry point for the console application.  
// 管道通信服务器  
 
#include "stdafx.h"  
#include <Windows.h>  
#include <stdio.h>  
#include <iostream>  
using namespace std;  
 
 
#define NUM_PIPES 5  
#define BUFFER_SIZE 256  
  
  
int _tmain(int argc, _TCHAR* argv[])  
{  
    DWORD dwTransferred;  
    HANDLE hPipe[NUM_PIPES];  
    char szBuffer[NUM_PIPES][BUFFER_SIZE];  
    OVERLAPPED Ovlap[NUM_PIPES];  
    HANDLE hEvent[NUM_PIPES];  
    DWORD dwTime = 1000;  
    BOOL bRead[NUM_PIPES];  
  
    for ( int i = 0; i < NUM_PIPES; i++ )  
    {  
        // create pipe  
        if ( (hPipe[i] = CreateNamedPipe("\\\\.\\pipe\\socket_pipe",  
            PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,  
            PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,  
            NUM_PIPES,  
            0,  
            0,  
            dwTime,  
            NULL)) == INVALID_HANDLE_VALUE )  
        {  
            printf("Create Pipe Error: %d\n", GetLastError());  
  
            return -1;  
        }  
  
        // Create Event  
        if ( (hEvent[i] = CreateEvent( NULL, TRUE, FALSE, NULL ) ) == NULL )  
        {  
            printf("Create Event Error: %d\n", GetLastError());  
  
            continue;  
        }  
  
        bRead[i] = FALSE;  
  
        // Init OVERLAPPED  
        ZeroMemory( &Ovlap[i], sizeof(OVERLAPPED) );  
        Ovlap[i].hEvent = hEvent[i];  
  
        // disconnect pipe  
        if ( DisconnectNamedPipe( hPipe[i] ) == 0 )  
        {  
            printf("DisconnectNamedPipe Error: %d\n", GetLastError());  
  
            return -1;  
        }  
        // connect pipe  
        if ( ConnectNamedPipe( hPipe[i], &Ovlap[i] ) == 0 )  
        {  
            if ( GetLastError() != ERROR_IO_PENDING )  
            {  
                printf("Connect Name Pipe Error: %d\n", GetLastError());  
  
                CloseHandle(hPipe[i]);  
                return -1;  
            }  
        }  
  
    }  
  
  
    printf("---------------------Server Is Start---------------------\n");  
  
  
    DWORD dwRet, dwPipe;  
  
    while ( 1 )  
    {  
        // waiting for Event  
        if ( (dwRet = WaitForMultipleObjects( NUM_PIPES, hEvent, FALSE, INFINITE ))  
            == WAIT_FAILED)  
        {  
            printf("Wait For MultipleObject Error: %d\n", GetLastError());  
  
            return -1;  
        }  
  
        dwPipe = dwRet - WAIT_OBJECT_0;  
        ResetEvent( hEvent[dwPipe] );  
  
  
        // Get Info  
        if ( GetOverlappedResult( hPipe[dwPipe], &Ovlap[dwPipe], &dwTransferred, TRUE ) == 0 )  
        {  
            printf("GetOverlappedResult Error: %d\n", GetLastError());  
  
            if ( DisconnectNamedPipe( hPipe[dwPipe] ) == 0 )  
            {  
                printf("DisconnectNamedPipe Error: %d\n", GetLastError());  
  
                return -1;  
            }  
  
            // Connect again  
            if ( ConnectNamedPipe( hPipe[dwPipe], &Ovlap[dwPipe] ) == 0 )  
            {  
                printf("DisconnectNamedPipe Error: %d\n", GetLastError());  
  
                return -1;  
            }  
  
            bRead[dwPipe] = FALSE;  
        }  
        else  
        {  
            if ( bRead[dwPipe] == FALSE )  
            {  
                ZeroMemory( &Ovlap[dwPipe], sizeof(OVERLAPPED)  );  
                Ovlap[dwPipe].hEvent = hEvent[dwPipe];  
  
                if ( ReadFile( hPipe[dwPipe], szBuffer[dwPipe],   
                    BUFFER_SIZE, NULL, &Ovlap[dwPipe] )  
                    == 0 )  
                {  
                    if ( GetLastError() != ERROR_IO_PENDING )  
                    {  
                        printf("ReadFile Error: %d\n", GetLastError());  
  
                        return -1;  
                    }  
                }  
  
                bRead[dwPipe] = TRUE;  
            }  
            else  
            {  
                printf("Recevied %d Bytes", dwTransferred);  
  
                ZeroMemory( &Ovlap[dwPipe], sizeof(OVERLAPPED)  );  
                Ovlap[dwPipe].hEvent = hEvent[dwPipe];  
  
                if ( WriteFile( hPipe[dwPipe], szBuffer[dwPipe], dwTransferred, NULL, &Ovlap[dwPipe] ) == 0 )  
                {  
                    if ( GetLastError() != ERROR_IO_PENDING )  
                    {  
                        printf("ReadFile Error: %d\n", GetLastError());  
  
                        return -1;  
                    }  
                }  
  
                bRead[dwPipe] = FALSE;  
            }  
        }  
    }  
  
    for ( int i = 0; i < NUM_PIPES; i++ )  
    {  
        CloseHandle(hPipe[i]);  
    }  
  
    system("pause");  
    return 0;  
}  
    客户端：
    
view plaincopy to clipboardprint?
// PipeClient.cpp : Defines the entry point for the console application.  
// 管道通信客服端  
 
#include "stdafx.h"  
#include <Windows.h>  
#include <stdio.h>  
#include <iostream>  
using namespace std;  
 
#define BUFFER_SIZE 256  
#define PIPE "\\\\.\\pipe\\socket_pipe"  
  
int _tmain(int argc, _TCHAR* argv[])  
{  
    HANDLE hPipe;  
    DWORD dwWrite;  
  
    // waiting  
    if ( WaitNamedPipe( PIPE, NMPWAIT_WAIT_FOREVER ) == FALSE )  
    {  
        printf("WaitNamedPipe Error: %d\n", GetLastError());  
  
        return -1;  
    }  
  
    // create pipe  
    if ( (hPipe = CreateFile( PIPE, GENERIC_READ | GENERIC_WRITE,  
                              0,  
                              NULL,  
                              OPEN_EXISTING,  
                              FILE_ATTRIBUTE_NORMAL,  
                              NULL) ) == INVALID_HANDLE_VALUE)  
    {  
        printf("CreateFile Error: %d\n", GetLastError());  
  
        return -1;  
    }  
      
    // send  
    if ( WriteFile( hPipe, "This is Test Pipe", 17, &dwWrite, NULL ) == 0 )  
    {  
        printf("CreateFile Error: %d\n", GetLastError());  
  
        CloseHandle( hPipe );  
        return -1;  
    }  
  
    DWORD dwRead;  
    char szBuffer[BUFFER_SIZE];  
    if ( ReadFile( hPipe, szBuffer, BUFFER_SIZE, &dwRead, NULL ) == 0 )  
    {  
        if ( GetLastError() != ERROR_IO_PENDING )  
        {  
            printf("ReadFile Error: %d\n", GetLastError());  
  
            return -1;  
        }  
    }  
  
    szBuffer[dwRead] = '\0';  
  
    printf("%s", szBuffer);  
    system("pause");  
  
    // recv  
    return 0;  
}  
heary29
关注
专栏目录
vc 进程通信（剪贴板 命名管道 匿名管道 邮槽）
08-17
本篇将详细探讨在VC++中实现的四种进程通信方法：剪贴板、命名管道、匿名管道和邮槽。 1. 剪贴板通信： 剪贴板是操作系统提供的一种通用机制，允许应用程序之间共享数据。在VC++中，可以使用Windows API函数来操作...
MFC—邮槽与管道
御承扬的博客
08-05 568
邮槽和管道是完成进程间通信的重要方法，用于在进程间传输各种类型的数据。邮槽是单向的数据传输通道；管道又分为匿名管道和命名管道，匿名管道是本地的双向数据传输通道，命名管道是支持网络和本地两种方式的双向数据传输通道。
进程的通信 - 邮槽
qq_54169998的博客
11-17 770
邮槽是Windows系统提供的一种单向进程间的通信机制。对于相对简短的地坪率信息发送，使用邮槽通常比命名管道或者Unix域套接字更简单使用邮槽通信的进程分为服务端和客户端。邮槽，在创建时需要指定邮槽名，创建后邮槽。在邮槽创建后，客户端可以通过邮槽名打开邮槽，在获得句柄后可以向邮槽写入消息。，只有服务端才能从邮槽中读取消息，客户端只能写入消息。消息先入先出。客户端先写入的消息在服务端先被读取。通过邮槽通信的数据可以是任意格式的，但是一条消息。邮槽除了在本机内进行进程间的通信外，在主机间也可以通信。
邮槽
MOKA
01-18 712
Microsoft Windows NT, Windows 2000, Window 95 和Windows 98 ----但不包括Windows CE----提供了一种简单的单向的"进程间通信"(interprocess communication,  IPC)机制. 这个机制的名字非常古怪,叫做"邮槽(Mailslot).用最简单的话来说,通过邮槽,客户机进程可将消息传送或广播给一个或多个服务
（六）Win32进程通信 —— 邮槽的使用
浪子花梦
02-14 633
邮槽 邮槽是Windows操作系统提供的一种单向进程间通信机制，可用于单机或者网络上的多机分布式环境。对于相对简短的低频率信息发送，使用邮槽通常比命名管道或者Unix域套接字更简单。 从中我们可以读出三个简单的信息： 邮槽传输数据是单向的（客户端 --> 服务端） 可以在进程间通信，也可以在网络间通信 每次传输的数据比较小（400B） 邮槽的名称： \\\\.\\mailslo...
Linux进程通信 ---匿名/命名管道 --- 共享内存
CHJBL的博客
07-03 375
进程通信，匿名管道，命名管道，共享内存
进程通信--邮槽
09-19
邮槽名字可以是全局的，也可以是命名空间内的，这取决于通信的范围。 2. 发送消息：创建邮槽之后，进程可以向邮槽中写入消息。消息通常包含一个消息ID和消息体，消息ID用于区分不同类型的消息，而消息体则携带实际...
2.4实验四：使用命名管道实现进程通信.pdf
10-14
在Windows系统中，进程通信机制包括命名管道、匿名管道、邮槽、套接字等多种方式。其中，命名管道是一种常用的进程通信机制，它允许两个或多个进程之间进行通信。 二、命名管道的概念和类型 命名管道是一种特殊的...
MailSlot简单封装和使用
08-31
邮槽是一个命名的数据通道，由服务端创建，客户端可以通过指定的邮槽名发送消息。邮槽具有广播特性，即一个邮槽可以接收来自多个客户端的消息，但服务端只能有一个。邮槽数量无限制，且消息大小通常不超过4K字节。 ...
各种多进程之间的通信实例
01-17
邮槽（命名管道）是Windows操作系统提供的一种进程间通信方式。它允许一个进程写入数据，而其他进程可以读取这些数据。邮槽具有先进先出（FIFO）的特性，类似于一个消息队列。进程可以通过创建、读取或写入邮槽来...
【Linux学习】进程间通信的方式（匿名管道、命名管道、共享内存）
qq_61635026的博客
11-07 1149
进程间通信（IPC，Interprocess communication）是一组编程接口，让程序员能够协调不同的进程，使之**能在一个操作系统里同时运行，并相互传递、交换信息。
【Linux】命名管道 && 共享内存
最新发布
2301_79585944的博客
05-16 1261
世上有两种耀眼的光芒，一种是正在升起的太阳，一种是正在努力学习编程的你!一个爱学编程的人。各位看官，我衷心的希望这篇博客能对你们有所帮助，同时也希望各位看官能对我的文章给与点评，希望我们能够携手共同促进进步，在编程的道路上越走越远！提示：以下是本篇文章正文内容，下面案例可供参考好了，本篇博客到这里就结束了，如果有更好的观点，请及时留言，我会认真观看并学习。不积硅步，无以至千里；不积小流，无以成江海。
Linux进程通信：命名管道，System V共享内存
xiao_xiao21的博客
11-28 872
Linux进程通信：命名管道，System V共享内存
pipe管道通信
wang_leiboke的专栏
05-22 477
pipe函数是用来创建管道的，当它创建成功会返回两个文件描述符，0是读，1是写；在用管道时，当我们使用读端就要关闭写，使用写端就要关闭读的功能。 #include #include #include #include int main() {  float shu[2]={0.0f};  double shou[2];  int i=0;  int ret;  double
vb 管道共享
lbuskeep的专栏
04-01 1803
<br />Dim hReturn As Long<br />    Dim dwOpenMode As Long, dwPipeMode As Long<br />    dwOpenMode = FILE_FLAG_OVERLAPPED Or PIPE_ACCESS_DUPLEX<br />    dwPipeMode = PIPE_NOWAIT Or PIPE_TYPE_MESSAGE Or PIPE_READMODE_MESSAGE<br />    hNamePipe = CreateNamedP
Linux 进程通信：命名管道、共享内存
Han同学
03-24 1632
Linux 进程通信：命名管道、共享内存
进程间通信之邮槽
weixin_34010566的博客
07-06 124
  简介 有时候我们需要一个程序与另一个程序之间进行通信。你可能在多台机器上有多个服务器运行，而在一个中央位置对一个或多个服务器进行远程监控。Windows平台为我们提供了一系列通信方式，从Socket到命名管道，DDE,DCOM，邮槽等。本文中作者将探讨邮槽这一通信机制，假定读者熟悉CreateFile(),ReadFile(),WriteFile()等API函数，此外还假定读者熟悉重叠I/O...
进程间通信 | 匿名管道 | 命名管道 | 共享内存 | 消息队列 | 信号 | Socket | 代码实现
qq_63159859的博客
03-18 868
进程间通信的本质，前提是要进程看到同一块"内存"，这个"内存"不隶属那个进程，是进程间共享的！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值