项目(百万并发网络通信架构)9.4---多线程客户端服务端最终代码测试

前言

• 前面几篇文章改造好了客户端与服务端的代码，本文进行测试
• 服务端是多线程的，其业务逻辑代码中用到了多线程
• 客户端的业务逻辑代码不是多线程的，只是其测试代码main函数中用到了多线程

一、测试10000客户端连接

客户端测试代码如下

• 这个代码在前面文章介绍过，此处只是将客户端的数量cCount变量改为了10000

   

    

     

      

     
     

      

       #include "EasyTcpClient.hpp"
      
     
    

     

      

     
     

      

       #include <thread>
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       bool g_bRun = 
       false;
      
     
    

     

      

     
     

      

       const 
       int cCount = 
       10000; 
       //客户端的数量
      
     
    

     

      

     
     

      

       const 
       int tCount = 
       4;    
       //线程的数量
      
     
    

     

      

     
     

      

       EasyTcpClient* client[cCount];
       //客户端的数组
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       void cmdThread();
      
     
    

     

      

     
     

      

       void sendThread(int id);
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       int main()
      
     
    

     

      

     
     

      

       {
      
     
    

     

      

     
     

      

       	g_bRun = 
       true;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       //UI线程，可以输入命令
      
     
    

     

      

     
     

      
	
       std::
       thread t(cmdThread);
      
     
    

     

      

     
     

      

       	t.detach();
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       //启动发送线程
      
     
    

     

      

     
     

      
	
       for (
       int n = 
       0; n < tCount; ++n)
      
     
    

     

      

     
     

      

       	{
      
     
    

     

      

     
     

      
		
       std::
       thread t(sendThread, n + 1);
      
     
    

     

      

     
     

      

       		t.detach();
      
     
    

     

      

     
     

      

       	}
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       while (g_bRun)
      
     
    

     

      

     
     

      

       		Sleep(
       100);
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       /*getchar();
      
     
    

     

      

     
     

      

        getchar();*/
      
     
    

     

      

     
     

      
	
       return 
       0;
      
     
    

     

      

     
     

      

       }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       void cmdThread()
      
     
    

     

      

     
     

      

       {
      
     
    

     

      

     
     

      
	
       char cmdBuf[
       256] = {};
      
     
    

     

      

     
     

      
	
       while (
       true)
      
     
    

     

      

     
     

      

       	{
      
     
    

     

      

     
     

      
		
       std::
       cin >> cmdBuf;
      
     
    

     

      

     
     

      
		
       if (
       0 == 
       strcmp(cmdBuf, 
       "exit"))
      
     
    

     

      

     
     

      

       		{
      
     
    

     

      

     
     

      

       			g_bRun = 
       false;
      
     
    

     

      

     
     

      
			
       break;
      
     
    

     

      

     
     

      

       		}
      
     
    

     

      

     
     

      
		
       else {
      
     
    

     

      

     
     

      
			
       std::
       cout << 
       "命令不识别，请重新输入" << 
       std::
       endl;
      
     
    

     

      

     
     

      

       		}
      
     
    

     

      

     
     

      

       	}
      
     
    

     

      

     
     

      

       }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       void sendThread(int id)
      
     
    

     

      

     
     

      

       {
      
     
    

     

      

     
     

      
	
       /*
      
     
    

     

      

     
     

      

        下面这几个变量是为了平均每个线程创建的客户端的数量：
      
     
    

     

      

     
     

      

        例如，本次测试时客户端数量为1000，线程数量为4，那么每个线程应该创建250个客户端
      
     
    

     

      

     
     

      

        线程1：c=250，begin=0,end=250
      
     
    

     

      

     
     

      

        线程2：c=250，begin=250,end=500
      
     
    

     

      

     
     

      

        线程3：c=250，begin=500,end=750
      
     
    

     

      

     
     

      

        线程4：c=250，begin=750,end=1000
      
     
    

     

      

     
     

      

        */
      
     
    

     

      

     
     

      
	
       int c = cCount / tCount;
      
     
    

     

      

     
     

      
	
       int begin = (id - 
       1)*c;
      
     
    

     

      

     
     

      
	
       int end = id*c;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       for (
       int n = begin; n < end; ++n) 
       //创建客户端
      
     
    

     

      

     
     

      

       	{
      
     
    

     

      

     
     

      

       		client[n] = 
       new EasyTcpClient;
      
     
    

     

      

     
     

      

       	}
      
     
    

     

      

     
     

      
	
       for (
       int n = begin; n < end; ++n) 
       //让每个客户端连接服务器
      
     
    

     

      

     
     

      

       	{
      
     
    

     

      

     
     

      

       		client[n]->ConnectServer(
       "192.168.0.105", 
       4567);
      
     
    

     

      

     
     

      

       	}
      
     
    

     

      

     
     

      
	
       printf(
       "Thread<%d>,Connect=<begin=%d, end=%d>\n", id, (begin + 
       1), end);
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       //连接成功之后，等待3秒再去发送数据
      
     
    

     

      

     
     

      
	
       std::chrono::
       microseconds t(3000);
      
     
    

     

      

     
     

      
	
       std::this_thread::sleep_for(t);
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       //这里定义为数组，可以随根据需求修改客户端单次发送给服务端的数据包数量
      
     
    

     

      

     
     

      
	
       const 
       int nNum = 
       1;
      
     
    

     

      

     
     

      

       	Login login[nNum];
      
     
    

     

      

     
     

      
	
       for (
       int n = 
       0; n < nNum; ++n)
      
     
    

     

      

     
     

      

       	{
      
     
    

     

      

     
     

      
		
       strcpy(login[n].userName, 
       "dongshao");
      
     
    

     

      

     
     

      
		
       strcpy(login[n].PassWord, 
       "123456");
      
     
    

     

      

     
     

      

       	}
      
     
    

     

      

     
     

      
	
       //在外面定义nLen，就不用每次在for循环中SendData时还要去sizeof计算一下login的大小
      
     
    

     

      

     
     

      
	
       int nLen = 
       sizeof(login);
      
     
    

     

      

     
     

      
	
       //循环向服务端发送消息
      
     
    

     

      

     
     

      
	
       while (g_bRun)
      
     
    

     

      

     
     

      

       	{
      
     
    

     

      

     
     

      
		
       for (
       int n = begin; n < end; ++n)
      
     
    

     

      

     
     

      

       		{
      
     
    

     

      

     
     

      

       			client[n]->SendData(login, nLen);
      
     
    

     

      

     
     

      

       			client[n]->Onrun();
      
     
    

     

      

     
     

      

       		}
      
     
    

     

      

     
     

      

       	}
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       //关闭客户端
      
     
    

     

      

     
     

      
	
       for (
       int n = begin; n < end; ++n)
      
     
    

     

      

     
     

      

       	{
      
     
    

     

      

     
     

      

       		client[n]->CloseSocket();
      
     
    

     

      

     
     

      
		
       delete client[n];
      
     
    

     

      

     
     

      

       	}
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       printf(
       "thread<%d>:all clients close the connection!\n");
      
     
    

     

      

     
     

      

       }
      
     
   

服务端测试代码

• 因为是10000个客户端连接，因此需要将EasyTcpServer.hpp中的FD_SETSIZE宏定义改为超过10000的数字（此处改为10240）

   

    

     

      

     
     

      

       #include "EasyTcpServer.hpp"
      
     
    

     

      

     
     

      

       #include "MessageHeader.hpp"
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       int main()
      
     
    

     

      

     
     

      

       {
      
     
    

     

      

     
     

      

       	EasyTcpServer server;
      
     
    

     

      

     
     

      

       	server.Bind(
       "192.168.0.105", 
       4567);
      
     
    

     

      

     
     

      

       	server.Listen(
       5);
      
     
    

     

      

     
     

      

       	server.Start(
       4);
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
	
       while (server.isRun())
      
     
    

     

      

     
     

      

       	{
      
     
    

     

      

     
     

      

       		server.Onrun();
      
     
    

     

      

     
     

      

       	}
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       	server.CloseSocket();
      
     
    

     

      

     
     

      
	
       std::
       cout << 
       "服务端停止工作!" << 
       std::
       endl;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       	getchar();  
       //防止程序一闪而过
      
     
    

     

      

     
     

      
	
       return 
       0;
      
     
    

     

      

     
     

      

       }
      
     
   

运行结果

• 左侧为服务端，显示接收到1000个客户端，每秒接收到的数据为10万左右

二、总结

• 本文测试了10000个客户端连接服务器，并且客户端与服务端有数据的收发
• 因为客户端的数量为10000，且客户端与服务端之间有数据的收发，因此网络中传入的数据较多，程序运行一会儿就会卡顿。原因有：
  • 本人的机子性能限制
  • 客户端数量过多，服务端和客户端程序中虽然设计了接收缓冲区（参阅前面的7.x相关文章），但是没有设计发送缓冲区，因此数据交互一会儿后缓冲区膨胀，导致程序会慢慢变卡
• 在后面的文章中会介绍设计发送缓冲区，待续