78.pipe多管道云端，客户端通信

压力测试截图:

云端

• 定义管道缓存区大小，最多连接数量（线程个数），当前线程个数，管道名字

   //缓冲区大小
   #define SIZE 4096
   //最多连接数量
   #define MAX_CONNECT 128
   //一开始有10个线程存在
   int  startthreadnum = ;
   //管道名字
   char  pipename[] = "\\\\.\\Pipe\\cloudpipe";

• 创建结构体，存储线程，管道和事件的信息

   //创建结构体，存储线程，管道和事件的信息
   typedef struct info
   {
       HANDLE hthread;
       HANDLE hpipe;//管道信息
       HANDLE hevent;//事件用于初始化一个结构体用于连接管道，并存储连接的信息
   }PIPE_ST;

• 创建结构体

   //128个结构体
   PIPE_ST  pipeinst[MAX_CONNECT];

• 初始化结构体，并开启线程

   //创建管道，事件，并启动线程
   void start()
   {
       for (int i = ; i <startthreadnum; i++)
       {
           //创建管道,如果同名则操作同一个管道
           pipeinst[i].hpipe = CreateNamedPipeA(
               pipename,//管道名称
               PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED,//管道读写属性
               PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,//消息模式，读模式，等待模式阻塞
               ,//最多使用本管道的实例个数
               ,//输出缓冲区大小
               ,//输入缓冲区大小
               ,//超时，无限等待
               NULL);
           if (pipeinst[i].hpipe == INVALID_HANDLE_VALUE)
           {
               printf("\n%d失败",i);
               return;
           }
           //创建事件
           pipeinst[i].hevent = CreateEventA(NULL, FALSE, FALSE, FALSE);//创建事件
           //创建线程
           pipeinst[i].hthread=CreateThread(NULL,,severThread,&pipeinst[i],,NULL);
       }
       printf("sever start");
  
   }

• 线程函数

   //服务器线程
   DWORD WINAPI severThread(void *lp)
   {
       //存储读取的数量
       DWORD nread = ;
       //存储写入的数量
       DWORD nwrite = ;
       //检测IO是否完成
       DWORD dwbyte = ;
       char szbuf[SIZE] = {  };
  
       //获取当前结构体
       PIPE_ST curpipe = *(PIPE_ST*)lp;
       //用事件初始化一个结构体用于连接管道，存储连接的信息
       OVERLAPPED overlap = { , , , , curpipe.hevent };
  
       while ()
       {
           //数据清零
           memset(szbuf, , sizeof(szbuf));
           //链接上管道，并把信息写入overlap
           ConnectNamedPipe(curpipe.hpipe, &overlap);
           //等待
           WaitForSingleObject(curpipe.hevent, INFINITE);
           //检测IO，如果完成就跳出
           if (!GetOverlappedResult(curpipe.hpipe,&overlap,&dwbyte,TRUE))
           {
               break;
           }
           //读取管道中的数据到szbuf中
           if (!ReadFile(curpipe.hpipe,szbuf,SIZE,&nread,NULL))
           {
               puts("read fail");
               break;
           }
           //从读取的数据中获取数据
           int a, b;
           sscanf(szbuf, "%d %d", &a, &b);
           //缓存区清零
           memset(szbuf, , sizeof(szbuf));
           //计算结果
           sprintf(szbuf, "%d", a + b);
           //把结果写入管道
           WriteFile(curpipe.hpipe, szbuf, strlen(szbuf), &nwrite, NULL);
           //断开连接
           DisconnectNamedPipe(curpipe.hpipe);
       }
       return ;
   }

客户端

• 定义管道缓存区大小，管道名字，以及管道连接的句柄

   #define SIZE 4096
   char  pipename[] = "\\\\.\\Pipe\\cloudpipe";
   HANDLE m_pipe = NULL;

• 生成随机数用于给服务器进行计算

   int a;
   int b;
   void run()
   {
       time_t ts;
       unsigned int num = time(&ts);
       srand(num);
       a = rand() % ;
       b= rand() % ;
   }

• 打开管道，并向管道中写入数据，再读取计算后的结果

   m_pipe = CreateFileA(pipename, //名称
           GENERIC_WRITE | GENERIC_READ,//读写
           ,//共享属性,1独有
           NULL,//默认安全属性
           OPEN_EXISTING,//打开已经存在的
           FILE_ATTRIBUTE_NORMAL,
           NULL);
  
       if (m_pipe==INVALID_HANDLE_VALUE)
       {
           printf("失败");
           return;
       }
       //存储读取写入了多少个
       int nwrite;
       int nread;
       //生成随机数
       run();
       //存储写入的数据
       char winfo[] = {  };
       //格式到winfo中
       sprintf(winfo, "%d %d", a, b);
       //写入管道
       WriteFile(m_pipe, winfo, strlen(winfo), &nwrite, NULL);
       //清零
       memset(winfo, , sizeof(winfo));
       //读取管道计算后的数据到winfo中
       ReadFile(m_pipe, winfo, , &nread, NULL);
       //获取服务器计算的结果
       int  res;
       sscanf(winfo, "%d", &res);
       printf("\n%d+%d=%d", a, b, res);

服务器端完整代码:

 #define  _CRT_SECURE_NO_WARNINGS
 #include<stdio.h>
 #include<time.h>
 #include<stdlib.h>
 #include<Windows.h>

 //缓冲区大小
 #define SIZE 4096
 //最多连接数量
 #define MAX_CONNECT 128
 //一开始有10个线程存在
 int  startthreadnum = ;
 //管道名字
 char  pipename[] = "\\\\.\\Pipe\\cloudpipe";

 //创建结构体，存储线程，管道和事件的信息
 typedef struct info
 {
     HANDLE hthread;
     HANDLE hpipe;//管道信息
     HANDLE hevent;//事件用于初始化一个结构体用于连接管道，并存储连接的信息
 }PIPE_ST;

 //128个结构体
 PIPE_ST  pipeinst[MAX_CONNECT];

 //服务器线程
 DWORD WINAPI severThread(void *lp)
 {
     //存储读取的数量
     DWORD nread = ;
     //存储写入的数
     DWORD nwrite = ;
     //检测IO是否完成
     DWORD dwbyte = ;
     char szbuf[SIZE] = {  };

     //获取当前结构体
     PIPE_ST curpipe = *(PIPE_ST*)lp;
     //用事件初始化一个结构体用于连接管道，存储连接的信息
     OVERLAPPED overlap = { , , , , curpipe.hevent };

     while ()
     {
         //数据清零
         memset(szbuf, , sizeof(szbuf));
         //链接上管道，并把信息写入overlap
         ConnectNamedPipe(curpipe.hpipe, &overlap);
         //等待
         WaitForSingleObject(curpipe.hevent, INFINITE);
         //检测IO，如果完成就跳出
         if (!GetOverlappedResult(curpipe.hpipe,&overlap,&dwbyte,TRUE))
         {
             break;
         }
         //读取管道中的数据到szbuf中
         if (!ReadFile(curpipe.hpipe,szbuf,SIZE,&nread,NULL))
         {
             puts("read fail");
             break;
         }
         //从读取的数据中获取数据
         int a, b;
         sscanf(szbuf, "%d %d", &a, &b);
         //缓存区清零
         memset(szbuf, , sizeof(szbuf));
         //计算结果
         sprintf(szbuf, "%d", a + b);
         //把结果写入管道
         WriteFile(curpipe.hpipe, szbuf, strlen(szbuf), &nwrite, NULL);
         //断开连接
         DisconnectNamedPipe(curpipe.hpipe);
     }
     return ;
 }

 //创建管道，事件，并启动线程
 void start()
 {
     for (int i = ; i <startthreadnum; i++)
     {
         //创建管道
         pipeinst[i].hpipe = CreateNamedPipeA(
             pipename,//管道名称
             PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED,//管道读写属性
             PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,//消息模式，读模式，等待模式阻塞
             ,//最多使用本管道的实例个数
             ,//输出缓冲区大小
             ,//输入缓冲区大小
             ,//超时，无限等待
             NULL);
         if (pipeinst[i].hpipe == INVALID_HANDLE_VALUE)
         {
             printf("\n%d失败",i);
             return;
         }
         //创建事件
         pipeinst[i].hevent = CreateEventA(NULL, FALSE, FALSE, FALSE);//创建事件
         //创建线程
         pipeinst[i].hthread=CreateThread(NULL,,severThread,&pipeinst[i],,NULL);
     }
     printf("sever start");

 }

 void main()
 {
     start();
     system("pause");
 }

客户端完整代码:

 #define  _CRT_SECURE_NO_WARNINGS
 #include<stdio.h>
 #include<time.h>
 #include<stdlib.h>
 #include<Windows.h>

 #define SIZE 4096
 char  pipename[] = "\\\\.\\Pipe\\cloudpipe";
 HANDLE m_pipe = NULL;

 int a;
 int b;
 void run()
 {
     time_t ts;
     unsigned int num = time(&ts);
     srand(num);
     a = rand() % ;
     b= rand() % ;
 }

 void main()
 {
     m_pipe = CreateFileA(pipename, //名称
         GENERIC_WRITE | GENERIC_READ,//读写
         ,//共享属性,1独有
         NULL,//默认安全属性
         OPEN_EXISTING,//打开已经存在的
         FILE_ATTRIBUTE_NORMAL,
         NULL);

     if (m_pipe==INVALID_HANDLE_VALUE)
     {
         printf("失败");
         return;
     }
     //存储读取写入了多少个
     int nwrite;
     int nread;
     //生成随机数
     run();
     //存储写入的数据
     char winfo[] = {  };
     //格式到winfo中
     sprintf(winfo, "%d %d", a, b);
     //写入管道
     WriteFile(m_pipe, winfo, strlen(winfo), &nwrite, NULL);
     //清零
     memset(winfo, , sizeof(winfo));
     //读取管道计算后的数据到winfo中
     ReadFile(m_pipe, winfo, , &nread, NULL);
     //获取服务器计算的结果
     int  res;
     sscanf(winfo, "%d", &res);
     printf("\n%d+%d=%d", a, b, res);
     system("pause");
 }

压力测试代码

 #include <stdio.h>
 #include <stdlib.h>
 #include <Windows.h>

 void main()
 {

     while ()
     {
         for (int i = ; i < ;i++)
         {
             ShellExecuteA(NULL, "open", "E:\\工具\\20150523\\pipe\\Debug\\客户端.exe", NULL, NULL, );
             Sleep();
         }

     }

 }