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

压力测试截图:

云端

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

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

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

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

• 创建结构体

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

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

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

• 线程函数

  //服务器线程
  DWORD WINAPI severThread(void *lp)
  {
      //存储读取的数量
      DWORD nread = 0;
      //存储写入的数量
      DWORD nwrite = 0;
      //检测IO是否完成
      DWORD dwbyte = 0;
      char szbuf[SIZE] = { 0 };
  
      //获取当前结构体
      PIPE_ST curpipe = *(PIPE_ST*)lp;
      //用事件初始化一个结构体用于连接管道，存储连接的信息
      OVERLAPPED overlap = { 0, 0, 0, 0, curpipe.hevent };
  
      while (1)
      {
          //数据清零
          memset(szbuf, 0, 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, 0, sizeof(szbuf));
          //计算结果
          sprintf(szbuf, "%d", a + b);
          //把结果写入管道
          WriteFile(curpipe.hpipe, szbuf, strlen(szbuf), &nwrite, NULL);
          //断开连接
          DisconnectNamedPipe(curpipe.hpipe);
      }
      return 0;
  }

客户端

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

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

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

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

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

  m_pipe = CreateFileA(pipename, //名称
          GENERIC_WRITE | GENERIC_READ,//读写
          0,//共享属性,1独有
          NULL,//默认安全属性
          OPEN_EXISTING,//打开已经存在的
          FILE_ATTRIBUTE_NORMAL,
          NULL);
  
      if (m_pipe==INVALID_HANDLE_VALUE)
      {
          printf("失败");
          return;
      }
      //存储读取写入了多少个
      int nwrite;
      int nread;
      //生成随机数
      run();
      //存储写入的数据
      char winfo[1024] = { 0 };
      //格式到winfo中
      sprintf(winfo, "%d %d", a, b);
      //写入管道
      WriteFile(m_pipe, winfo, strlen(winfo), &nwrite, NULL);
      //清零
      memset(winfo, 0, sizeof(winfo));
      //读取管道计算后的数据到winfo中
      ReadFile(m_pipe, winfo, 1024, &nread, NULL);
      //获取服务器计算的结果
      int  res;
      sscanf(winfo, "%d", &res);
      printf("
  %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 = 10;
//管道名字
char  pipename[128] = "\\.\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 = 0;
    //存储写入的数
    DWORD nwrite = 0;
    //检测IO是否完成
    DWORD dwbyte = 0;
    char szbuf[SIZE] = { 0 };

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

    while (1)
    {
        //数据清零
        memset(szbuf, 0, 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, 0, sizeof(szbuf));
        //计算结果
        sprintf(szbuf, "%d", a + b);
        //把结果写入管道
        WriteFile(curpipe.hpipe, szbuf, strlen(szbuf), &nwrite, NULL);
        //断开连接
        DisconnectNamedPipe(curpipe.hpipe);
    }
    return 0;
}

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


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



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

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

 压力测试代码

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

void main()
{


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


        
    }



}