devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【网络编程】实现UDP/TCP客户端、服务器_tcp udp server

作者：AllinToyou | 2024-03-04 18:03:35

赞

踩

tcp udp server

需要云服务器等云产品来学习Linux的同学可以移步/-->腾讯云<--/-->阿里云<--/-->华为云<--/官网，轻量型云服务器低至112元/年，新用户首次下单享超低折扣。

 目录

一、UDP

1、Linux客户端、服务器

1.1udpServer.hpp

1.2udpServer.cc

1.3udpClient.hpp

1.4udpClient.cc

1.5onlineUser.hpp

2、Windows客户端

二、TCP

1、单进程版的TCP客户端、服务器

1.1tcpServer.hpp

1.2tcpServer.cc

1.3tcpClient.hpp

1.4tcpClient.cc

1.5log.hpp

2、多进程版的TCP客户端、服务器

3、多线程版的TCP客户端、服务器

4、线程池版的TCP客户端、服务器

4.1tcpServer.hpp

4.2ThreadPool.hpp 

4.3Task.hpp

5、守护进程+多线程版的TCP客户端、服务器

5.1daemon.hpp

5.2tcpServer.cc

UDP/TCP客户端、服务器代码可参考本人gitee

UDP/TCP套接字的创建流程可参考此处

一、UDP

1、Linux客户端、服务器

1.1udpServer.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <cerrno>
  7. #include <cstring>
  8. #include <cstdlib>
  9. #include <arpa/inet.h>
  10. #include <strings.h>
  11. #include <functional>
  12. namespace Server
  13. {
  14.     const static string defaultIp="0.0.0.0";//缺省的IP
  15.     const static int gnum=1024;
  16.     typedef function<void(int,string,uint16_t,string)> func_t;
  17.     enum 
  18.     {
  19.         USAGE_ERR=1,
  20.         SOCKET_ERR,
  21.         BIND_ERR,
  22.         OPEN_ERR,
  23.     };
  24.     class udpServer
  25.     {
  26.     public:
  27.         udpServer(const func_t& callback,const uint16_t& port,const string& ip=defaultIp)
  28.         :_callback(callback)//udpServer.cc传入的对客户端数据处理的函数
  29.         ,_port(port)
  30.         ,_ip(ip)
  31.         ,_sockfd(-1)
  32.         {}
  33.         void initServer()
  34.         {
  35.              //1、创建socket
  36.             _sockfd=socket(AF_INET,SOCK_DGRAM,0);//网络通信+数据报
  37.             if(-1==_sockfd)
  38.             {
  39.                 cout<<"socket error"<<errno<<":"<<strerror(errno)<<endl;
  40.                 exit(SOCKET_ERR);
  41.             }
  42.             cout<<"socket success"<<":"<<_sockfd<<endl;
  43.             //2、绑定IP和端口号
  44.             struct sockaddr_in local;
  45.             bzero(&local,sizeof(local));//将一段内存初始化为全0
  46.             local.sin_family=AF_INET;//协议族设置为网络通信
  47.             local.sin_port=htons(_port);//设置端口号,需要转为大端，主机转网络
  48.             local.sin_addr.s_addr=inet_addr(_ip.c_str());//将IP字符串转uint32_t的同时转为网络字节序
  49.             //local.sin_addr.s_addr=htonl(INADDR_ANY);//INADDR_ANY就是0，表明任何IP都可以访问这个服务器的_port端口
  50.             int n=bind(_sockfd,(struct sockaddr*)&local,sizeof(local));
  51.             if(-1==n)
  52.             {
  53.                 cout<<"bind error"<<errno<<":"<<strerror(errno)<<endl;
  54.                 exit(BIND_ERR);
  55.             }
  56.         }
  57.         void start()
  58.         {
  59.             char buffer[gnum];
  60.             while(1)
  61.             {
  62.                 //循环读取数据
  63.                 struct sockaddr_in local;//输出型参数
  64.                 socklen_t len=sizeof(local);//必填
  65.                 size_t s=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&local,&len);//阻塞式读取
  66.                 //这里需要关心1、数据是什么2、数据是谁发的
  67.                 if(s>0)
  68.                 {
  69.                     buffer[s]=0;//加上'\0'
  70.                     //1、这是从网络读出来的IP，需要由网络字节序转主机字节序2、整数转点分十进制IP,用inet_ntoa进行转换
  71.                     string clientIp=inet_ntoa(local.sin_addr);//将32位IPv4地址（in_addr结构体）转换成点分十进制字符串形式的IP地址
  72.                     uint16_t clientPort=ntohs(local.sin_port);//一样需要转换字节序
  73.                     string message=buffer;
  74.                     cout<<clientIp<<"["<<clientPort<<"]#"<<message<<endl;
  75.                     //对数据进行处理
  76.                     _callback(_sockfd,clientIp,clientPort,message);
  77.                 }
  78.             }
  79.         }
  80.         ~udpServer()
  81.         {
  82.  
  83.         }
  84.     private:
  85.         uint16_t _port;//端口号
  86.         string _ip;//IP地址(服务器不建议固定的绑定一个IP地址，因为服务器需要接收所有的IP)
  87.         int _sockfd;//套接字文件描述符
  88.         func_t _callback;//回调函数
  89.     };
  90. }

1.2udpServer.cc

  1. #include <memory>
  2. #include <unordered_map>
  3. #include <fstream>
  4. #include <signal.h>
  5. using namespace std;
  6. #include "udpServer.hpp"
  7. #include "onlineUser.hpp"
  8. using namespace Server;
  9. // const std::string dictTxt="./dict.txt";
  10. // unordered_map<string,string> dict;//字典
  11. // std::string key,value;
  12.  
  13. static void Usage(string proc)
  14. {
  15.     cout<<"Usage:\n\t"<<proc<<"local_ip local_port\n\n";
  16. }
  17.  
  18. // static bool cutString(const string& target,string* key,string* value,const string& sep)//字符串截取
  19. // {
  20. //     //string sep=":";
  21. //     auto pos=target.find(sep,0);
  22. //     if(pos==string::npos)
  23. //     {
  24. //         return false;
  25. //     }
  26. //     *key=target.substr(0,pos);
  27. //     *value=target.substr(pos+sep.size());
  28. //     return true;
  29. // }
  30. // static void initDict()//文件操作
  31. // {
  32. //     ifstream in(dictTxt,std::ios_base::binary);
  33. //     if(!in.is_open())//如果文件打开失败
  34. //     {
  35. //         cerr<<"open file"<<dictTxt<<"error"<<endl;
  36. //         exit(OPEN_ERR);
  37. //     }
  38. //     string line;
  39. //     while(getline(in,line))
  40. //     {
  41. //         if(cutString(line,&key,&value,":"))//如果截取成功
  42. //         {
  43. //             dict.insert(make_pair(key,value));//dict.insert(key,value);
  44. //         }
  45. //         else //截取失败
  46. //         {
  47. //             //...
  48. //         }
  49. //     }
  50. //     in.close();
  51. //     cout<<"load dict success"<<endl;
  52. // }
  53. // static void debugPrint()//测试打印函数
  54. // {
  55. //     for(auto& dt:dict)
  56. //     {
  57. //         cout<<dt.first<<"/"<<dt.second<<endl;
  58. //     }
  59. // }
  60. // //客户端单词翻译代码
  61. // void handMessage(int sockfd,string clientIp,uint16_t clientPort,string message)
  62. // {
  63. //     //对客户端的信息进行特定的业务处理，实现了server通信和业务的解耦
  64. //     string response_message;//将查找的字符串保存至此处
  65. //     unordered_map<string,string>::iterator iter=dict.find(message);
  66. //     if(iter==dict.end())
  67. //     {
  68. //         response_message="unknow";
  69. //     }
  70. //     else
  71. //         response_message=iter->second;
  72. //     //服务端向客户端回发数据
  73. //     struct sockaddr_in client;
  74. //     bzero(&client,sizeof(client));
  75. //     client.sin_family=AF_INET;
  76. //     client.sin_addr.s_addr=inet_addr(clientIp.c_str());
  77. //     client.sin_port=htons(clientPort);
  78. //     sendto(sockfd,response_message.c_str(),response_message.size(),0,(struct sockaddr*)&client,sizeof(client));
  79. // }
  80. // //解析客户端上传的命令
  81. // void execCommand(int sockfd,string clientIp,uint16_t clientPort,string cmd)
  82. // {
  83. //     //对客户端的信息进行特定的业务处理，实现了server通信和业务的解耦
  84. //     auto end=cmd.find("rm");
  85. //     if(end!=string::npos)
  86. //     {
  87. //         cerr<<clientIp<<":"<<clientPort<<"非法操作"<<cmd<<endl;
  88. //         return;
  89. //     }
  90. //     string response_message;//将客户端上传的指令保存至此处
  91. //     FILE* fp=popen(cmd.c_str(),"r");
  92. //     if(fp==nullptr)
  93. //     {
  94. //         response_message=cmd+" exec failed";
  95. //     }
  96. //     char line[1024];
  97. //     while(fgets(line,sizeof(line),fp))
  98. //     {
  99. //         response_message+=line;//读出客户端传入的指令
  100. //     }
  101. //     pclose(fp);
  102. //     //服务端向客户端回发数据
  103. //     struct sockaddr_in client;
  104. //     bzero(&client,sizeof(client));
  105. //     client.sin_family=AF_INET;
  106. //     client.sin_addr.s_addr=inet_addr(clientIp.c_str());
  107. //     client.sin_port=htons(clientPort);
  108. //     sendto(sockfd,response_message.c_str(),response_message.size(),0,(struct sockaddr*)&client,sizeof(client));
  109. // }
  110. //聊天室
  111. OnlineUser olUser;
  112. void routeMessage(int sockfd,string clientIp,uint16_t clientPort,string message)
  113. {
  114.     //上线就新增，下线就减掉
  115.     if(message=="online")
  116.     {
  117.         olUser.addUser(clientIp,clientPort);
  118.     }
  119.     if(message=="offline")
  120.     {
  121.         olUser.delUser(clientIp,clientPort);
  122.     }
  123.     if(olUser.isOnline(clientIp,clientPort))
  124.     {
  125.         //广播消息
  126.         olUser.broadcastMessage(sockfd,clientIp,clientPort,message);
  127.     }
  128.     else
  129.     {
  130.         //服务端向客户端回发数据
  131.         string response_message="请先运行online";
  132.         struct sockaddr_in client;
  133.         bzero(&client,sizeof(client));
  134.         client.sin_family=AF_INET;
  135.         client.sin_addr.s_addr=inet_addr(clientIp.c_str());
  136.         client.sin_port=htons(clientPort);
  137.         sendto(sockfd,response_message.c_str(),response_message.size(),0,(struct sockaddr*)&client,sizeof(client));
  138.     }
  139. }
  140. // void reload(int signo)//热加载回调函数
  141. // {
  142. //     (void)signo;
  143. //     initDict();
  144. // }
  145. int main(int argc,char* argv[])//./udpServer port
  146. {
  147.     if(argc!=2)//判断外部传入的参数是否为3
  148.     {
  149.         Usage(argv[0]);
  150.         exit(USAGE_ERR);
  151.     }
  152.     uint16_t port=atoi(argv[1]);//需要转uint16_t整型
  153.  
  154.     // signal(2,reload);//发送信号，实现文本的热加载
  155.     // initDict();
  156.     //std::unique_ptr<udpServer> usvr(new udpServer(handMessage,port));//在线翻译
  157.     //std::unique_ptr<udpServer> usvr(new udpServer(execCommand,port));//指令解析
  158.     std::unique_ptr<udpServer> usvr(new udpServer(routeMessage,port));//聊天室
  159.     usvr->initServer();
  160.     usvr->start();
  161.     return 0;
  162. }

1.3udpClient.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <pthread.h>
  7. #include <cerrno>
  8. #include <cstring>
  9. #include <cstdlib>
  10. #include <arpa/inet.h>
  11. #include <strings.h>
  12. namespace Client
  13. {
  14.     using namespace std;
  15.     class udpClient
  16.     {
  17.     public:
  18.         udpClient(const string& serverIp,const uint16_t& serverPort)
  19.         :_sockfd(-1)
  20.         ,_serverPort(serverPort)
  21.         ,_serverIp(serverIp)
  22.         {}
  23.         void initClient()
  24.         {
  25.             //创建socket
  26.             _sockfd=socket(AF_INET,SOCK_DGRAM,0);
  27.             if(-1==_sockfd)
  28.             {
  29.                 cout<<"socket error"<<errno<<":"<<strerror(errno)<<endl;
  30.                 exit(2);
  31.             }
  32.             cout<<"socket syuccess"<<":"<<_sockfd<<endl;
  33.         }
  34.         static void* readMessage(void* args)//类内创建线程,有个this指针干扰
  35.         {
  36.             int sockfd=*static_cast<int*>(args);
  37.             pthread_detach(pthread_self());
  38.             while(1)
  39.             {
  40.                 //接收服务端发送的数据
  41.                 char buffer[1024];
  42.                 struct sockaddr_in temp;
  43.                 socklen_t len=sizeof(temp);
  44.                 size_t s=recvfrom(sockfd,buffer,sizeof(buffer),0,(struct sockaddr*)&temp,&len);
  45.                 if(s>0)
  46.                 {
  47.                     buffer[s]=0;//字符串以'\0'结尾
  48.                 }
  49.                 cout<<buffer<<endl;
  50.             }
  51.             return nullptr;
  52.         }
  53.         void run()
  54.         {
  55.             pthread_create(&_reader,nullptr,readMessage,(void*)&_sockfd);
  56.             struct sockaddr_in server;
  57.             memset(&server,sizeof(server),0);//初始化为全0
  58.             server.sin_family=AF_INET;
  59.             server.sin_addr.s_addr=inet_addr(_serverIp.c_str());
  60.             server.sin_port=htons(_serverPort);//主机转网络
  61.             string message;
  62.             char cmdline[1024];
  63.             while(1)
  64.             {
  65.                 //cerr<<"Please Enter#";
  66.                 // cin>>message;
  67.                 fprintf(stderr,"Enter#");
  68.                 fflush(stderr);
  69.                 fgets(cmdline,sizeof(cmdline),stdin);
  70.                 cmdline[strlen(cmdline)-1]=0;
  71.                 message=cmdline;
  72.                 //发送数据,sendto的时候，操作系统会帮我们自动绑定客户端端口+IP地址
  73.                 sendto(_sockfd,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));
  74.                 
  75.             }
  76.         }
  77.         ~udpClient()
  78.         {}
  79.     private:
  80.         int _sockfd;
  81.         uint16_t _serverPort;
  82.         string _serverIp;
  83.         pthread_t _reader;//读线程
  84.     };
  85. }

1.4udpClient.cc

  1. #include <memory>
  2. #include "udpClient.hpp"
  3. using namespace Client;
  4. static void Usage(string proc)
  5. {
  6.     cout<<"Usage:\n\t"<<proc<<"server_ip server_port\n\n";
  7. }
  8. int main(int argc,char* argv[])//./udpClient server_ip server_port
  9. {
  10.     if(argc!=3)
  11.     {
  12.         Usage(argv[0]);
  13.         exit(1);
  14.     }
  15.     string serverIp=argv[1];
  16.     uint16_t serverPort=atoi(argv[2]);
  17.     unique_ptr<udpClient> ucli(new udpClient(serverIp,serverPort));
  18.     ucli->initClient();
  19.     ucli->run();
  20.     return 0;
  21. }

1.5onlineUser.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <unordered_map>
  5. #include <sys/types.h>
  6. #include <sys/socket.h>
  7. #include <cerrno>
  8. #include <cstring>
  9. #include <cstdlib>
  10. #include <arpa/inet.h>
  11. using namespace std;
  12. class User
  13. {
  14. public:
  15.     User(const string& ip,const uint16_t& port)
  16.         :_ip(ip)
  17.         ,_port(port)
  18.     {
  19.  
  20.     }
  21.     ~User()
  22.     {}
  23.     string ip()
  24.     {
  25.         return _ip;
  26.     }
  27.     uint16_t port()
  28.     {
  29.         return _port;
  30.     }
  31. private:
  32.     string _ip;//用户IP
  33.     uint16_t _port;//用户端口号
  34.  
  35. };
  36. class OnlineUser
  37. {
  38. public:
  39.     OnlineUser()
  40.     {}
  41.     ~OnlineUser()
  42.     {}
  43.     void addUser(const string& ip,const uint16_t& port)//新增用户
  44.     {
  45.         string id=ip+"-"+to_string(port);
  46.         users.insert(make_pair(id,User(ip,port)));
  47.     }
  48.     void delUser(const string& ip,const uint16_t& port)//删除用户
  49.     {
  50.         string id=ip+"-"+to_string(port);
  51.         users.erase(id);
  52.     }
  53.     bool isOnline(const string& ip,const uint16_t& port)//是否在线
  54.     {
  55.         string id=ip+"-"+to_string(port);
  56.         return users.find(id)==users.end()?false:true;
  57.     }
  58.     void broadcastMessage(int sockfd,const string& ip,const uint16_t& port,const string& message)//给所有的user广播消息
  59.     {
  60.         for(auto& user:users)
  61.         {
  62.             //服务端向客户端回发数据
  63.             struct sockaddr_in client;
  64.             bzero(&client,sizeof(client));
  65.             client.sin_family=AF_INET;
  66.             client.sin_addr.s_addr=inet_addr(user.second.ip().c_str());
  67.             client.sin_port=htons(user.second.port());
  68.             string s=ip+"_"+to_string(port)+"# ";//id+"#"
  69.             s+=message;
  70.             sendto(sockfd,s.c_str(),s.size(),0,(struct sockaddr*)&client,sizeof(client));
  71.         }
  72.     }
  73. private:
  74.     unordered_map<string,User> users;//string:id=ip+"-"+to_string(port);User：User类
  75. };

2、Windows客户端

        可先让上方Linux服务器先运行起来，再让Windows客户端连接上该服务端，实现网络通信。

  1. #define _WINSOCK_DEPRECATED_NO_WARNINGS
  2. #include <iostream>
  3. #include <WinSock2.h>
  4. #include <string>
  5. #include <cstring>
  6. #pragma comment(lib,"ws2_32.lib")
  7. using namespace std;
  8. uint16_t serverPort = 8080;
  9. string serverIp = "43.XXX.105.XX";//你的云服务器IP
  10. #define NUM 1024
  11. int main()
  12. {
  13. 	WSAData wsd;
  14. 	//启动Winsock
  15. 	if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
  16. 	{
  17. 		cout << "WSAStartUp Error = " << WSAGetLastError() << endl;
  18. 		return -1;
  19. 	}
  20. 	else
  21. 	{
  22. 		cout << "WSAStartup Success" << endl;
  23. 	}
  24. 	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);//创建套接字
  25. 	if (sock == SOCKET_ERROR)
  26. 	{
  27. 		cout<<"socket Error = "<< WSAGetLastError() << endl;
  28. 		return -2;
  29. 	}
  30. 	else
  31. 	{
  32. 		cout << "socket Success" << endl;
  33. 	}
  34. 	struct sockaddr_in server;
  35. 	memset(&server, 0, sizeof(server));
  36. 	server.sin_addr.s_addr = inet_addr(serverIp.c_str());
  37. 	server.sin_family = AF_INET;
  38. 	server.sin_port = htons(serverPort);
  39. 	string line;
  40. 	char buffer[NUM];
  41. 	while (1)
  42. 	{
  43. 		//发送数据
  44. 		cout << "Please Enter#";
  45. 		getline(cin, line);
  46. 		int n = sendto(sock, line.c_str(), line.size(), 0, (struct sockaddr*)&server, sizeof(server));
  47. 		if (n < 0)
  48. 		{
  49. 			cerr << "sendto Error" << endl;
  50. 			break;
  51. 		}
  52. 		cout << "发送成功" << endl;
  53. 		//接收数据
  54. 		buffer[0] = 0;//C式清空数组
  55. 		struct sockaddr_in peer;
  56. 		int len = (int)sizeof(peer);
  57. 		n = recvfrom(sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
  58. 		if (n > 0)
  59. 		{
  60. 			buffer[n] = 0;
  61. 			cout << "server 返回的消息是" << buffer << endl;
  62. 		}
  63. 		else break;
  64. 	}
  65. 	closesocket(sock);//关闭套接字
  66. 	WSACleanup();
  67. 	return 0;
  68. }

二、TCP

1、单进程版的TCP客户端、服务器

        单线程会一直在ServerIO读取写入数据，为一个客户端服务，如果此时连接的客户端不止一个，其他客户端发送的信息将不会被显示。需要使用多线程或多进程解决。

1.1tcpServer.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <arpa/inet.h>
  7. #include <netinet/in.h>
  8. #include <string>
  9. #include <cstring>
  10. #include "log.hpp"
  11. namespace Server
  12. {
  13.     enum 
  14.     {
  15.         USAGE_ERR=1,
  16.         SOCKET_ERR,
  17.         BIND_ERR,
  18.         LISTEN_ERR,
  19.     };
  20.     static const uint16_t gport=8080;//缺省的端口号
  21.     static const int gbacklog=5;//最大连接数=5+1
  22.     const static std::string defaultIp="0.0.0.0";//缺省的IP
  23.     class TcpServer
  24.     {
  25.     public:
  26.         TcpServer(const uint16_t& port=gport,const std::string& ip=defaultIp )
  27.             :_listenSocket(-1)
  28.             ,_port(port)   
  29.             ,_ip(ip)
  30.         {
  31.  
  32.         }
  33.         void InitServer()//初始化服务器
  34.         {
  35.             //1、创建sockrt套接字
  36.             _listenSocket=socket(AF_INET,SOCK_STREAM,0);
  37.             if(_listenSocket<0)
  38.             {
  39.                 LogMessage(FATAL,"create socket error");
  40.                 exit(SOCKET_ERR);
  41.             }
  42.             LogMessage(NORMAL,"create socket success");
  43.             //2、绑定端口号+ip地址
  44.             struct sockaddr_in local;
  45.             memset(&local,0,sizeof(local));
  46.             local.sin_addr.s_addr=inet_addr(_ip.c_str());
  47.             local.sin_family=AF_INET;
  48.             local.sin_port=htons(_port);
  49.             if(bind(_listenSocket,(struct sockaddr*)&local,sizeof(local))<0)
  50.             {
  51.                 LogMessage(FATAL,"bind socket error");
  52.                 exit(BIND_ERR);
  53.             }
  54.             LogMessage(NORMAL,"bind socket success");
  55.             //3、设置监听状态
  56.             if(-1==listen(_listenSocket,gbacklog))
  57.             {
  58.                 LogMessage(FATAL,"listen socket error");
  59.                 exit(LISTEN_ERR);
  60.             }
  61.             LogMessage(NORMAL,"listen socket success");
  62.         }
  63.         void Start()//启动服务器
  64.         {
  65.             while(1)
  66.             {
  67.                 //4、服务器获取客户端连接请求
  68.                 struct sockaddr_in peer;//输出型参数，拿到客户端的信息
  69.                 socklen_t len=sizeof(peer);
  70.                 int sock=accept(_listenSocket,(struct sockaddr*)&peer,&len);  
  71.                 if(-1==sock)      
  72.                 {
  73.                     LogMessage(ERROR,"accept error,next");
  74.                     continue;
  75.                 }           
  76.                 LogMessage(NORMAL,"accept a new link success");
  77.                 //5、使用accept的返回值sock进行通信，均为文件操作
  78.                 ServerIO(sock);
  79.                 close(sock);//必须关闭使用完毕的sock，否则文件描述符泄漏
  80.             }
  81.         }
  82.         void ServerIO(int sock)
  83.         {
  84.             char buffer[1024];
  85.             while(1)
  86.             {
  87.                 //服务器读取客户端数据，通过套接字sock这个文件描述符读取数据
  88.                 ssize_t n=read(sock,buffer,sizeof(buffer)-1);
  89.                 if(n>0)
  90.                 {
  91.                     buffer[n]=0;
  92.                     std::cout<<"recv message:"<<buffer<<std::endl;
  93.                     std::string outBuffer=buffer;
  94.                     outBuffer+="[server echo]";
  95.                     //服务器将数据处理后发送回客户端
  96.                     write(sock,outBuffer.c_str(),outBuffer.size());
  97.                 }
  98.                 else if(0==n)//服务器read返回值为0，说明客户端关闭了
  99.                 {
  100.                     LogMessage(NORMAL,"client quit,server quit");
  101.                     break;
  102.                 }
  103.             }
  104.         }
  105.         ~TcpServer()
  106.         {}
  107.     private:
  108.         int _listenSocket;//监听客户端的连接请求，不用于数据通信
  109.         uint16_t _port;//服务器端口号
  110.         std::string _ip;//服务器ip地址
  111.     };
  112. }

1.2tcpServer.cc

  1. #include "tcpServer.hpp"
  2. #include "memory"
  3. using namespace Server;
  4. static void Usage(std::string proc)
  5. {
  6.     std::cout<<"Usage:\n\t"<<proc<<"serverPort\n\n";
  7. }
  8. //./tcpServer local_port
  9. int main(int argc,char* argv[])
  10. {
  11.     if(argc!=2)//判断外部传入的参数是否为2
  12.     {
  13.         Usage(argv[0]);
  14.         exit(USAGE_ERR);
  15.     }
  16.     uint16_t port=std::stoi(argv[1]);
  17.     std::unique_ptr<TcpServer> tsvr(new TcpServer(port));
  18.     tsvr->InitServer();
  19.     tsvr->Start();
  20.     return 0;
  21. }

1.3tcpClient.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <arpa/inet.h>
  7. #include <netinet/in.h>
  8. #include <string>
  9. #include <cstring>
  10. #define NUM 1024
  11. class TcpClient
  12. {
  13. public:
  14.     TcpClient(const std::string& serverIp,const uint16_t& serverPort)
  15.         :_serverIp(serverIp)
  16.         ,_serverPort(serverPort)
  17.         ,_sock(-1)
  18.     {
  19.  
  20.     }
  21.     void InitClient()
  22.     {
  23.         //1、创建套接字
  24.         _sock=socket(AF_INET,SOCK_STREAM,0);
  25.         if(_sock<0)
  26.         {   
  27.             std::cerr<<"cerete socket err"<<std::endl;
  28.             exit(2);
  29.         }
  30.         //2、客户端需要bind，但是客户端的绑定不需要我们自己写，操作系统会去绑定；（无需程序员bind）
  31.     }
  32.     void Start()
  33.     {
  34.         //3、客户端发起连接
  35.         struct sockaddr_in server;
  36.         memset(&server,0,sizeof(server));
  37.         server.sin_addr.s_addr=inet_addr(_serverIp.c_str());
  38.         server.sin_family=AF_INET;
  39.         server.sin_port=htons(_serverPort);
  40.         if(connect(_sock,(struct sockaddr*)&server,sizeof(server))<0)//连接失败
  41.         {
  42.             std::cerr<<"sock connect error"<<std::endl;
  43.         }
  44.         else//连接成功
  45.         {
  46.             //4、客户端发送/接收消息，文件操作
  47.             std::string msg;
  48.             while(1)
  49.             {
  50.                 std::cout<<"Enter:";
  51.                 std::getline(std::cin,msg);
  52.                 write(_sock,msg.c_str(),msg.size());
  53.                 char buffer[NUM];
  54.                 int n=read(_sock,buffer,sizeof(buffer)-1);
  55.                 if(n>0)
  56.                 {
  57.                     buffer[n]=0;
  58.                     std::cout<<"Server 回显消息:"<<buffer<<std::endl;
  59.                 }
  60.                 else
  61.                     break;
  62.             }
  63.         }
  64.     }
  65.     ~TcpClient()
  66.     {
  67.         if(_sock>=0)
  68.         {
  69.             close(_sock);
  70.         }
  71.     }
  72. private:
  73.     int _sock;//客户端套接字
  74.     uint16_t _serverPort;//服务器端口号
  75.     std::string _serverIp;//服务器ip
  76. };

1.4tcpClient.cc

  1. #include "tcpClient.hpp"
  2. #include <memory>
  3. static void Usage(std::string proc)
  4. {
  5.     std::cout<<"Usage:\n\t"<<proc<<"local_ip local_port\n\n";
  6. }
  7. //./tcpClient serverIp serverPort
  8. int main(int argc,char* argv[])
  9. {
  10.     if(argc!=3)
  11.     {
  12.         Usage(argv[0]);
  13.         exit(1);
  14.     }
  15.     std::string serverIp=argv[1];
  16.     uint16_t serverPort=std::stoi(argv[2]);
  17.     std::unique_ptr<TcpClient> tcli(new TcpClient(serverIp,serverPort));
  18.     tcli->InitClient();
  19.     tcli->Start();
  20.     return 0;
  21. }

1.5log.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #define DEBUG 0
  5. #define NORMAL 1
  6. #define WARNING 2
  7. #define ERROR 3
  8. #define FATAL 4
  9. //日志功能
  10. void LogMessage(int level,const std::string& message)
  11. {
  12.     //[日志等级][时间戳/时间][pid][message]
  13.     std::cout<<message<<std::endl;
  14. }

2、多进程版的TCP客户端、服务器

        更换tcpServer.hpp即可，其他文件和单进程版一样。

  1. #pragma once
  2. #include <iostream>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <sys/wait.h>
  6. #include <sys/socket.h>
  7. #include <arpa/inet.h>
  8. #include <netinet/in.h>
  9. #include <string>
  10. #include <cstring>
  11. #include <cstdlib>
  12. #include "log.hpp"
  13. namespace Server
  14. {
  15.     enum 
  16.     {
  17.         USAGE_ERR=1,
  18.         SOCKET_ERR,
  19.         BIND_ERR,
  20.         LISTEN_ERR,
  21.     };
  22.     static const uint16_t gport=8080;//缺省的端口号
  23.     static const int gbacklog=5;//最大连接数=5+1
  24.     const static std::string defaultIp="0.0.0.0";//缺省的IP
  25.     class TcpServer
  26.     {
  27.     public:
  28.         TcpServer(const uint16_t& port=gport,const std::string& ip=defaultIp )
  29.             :_listenSocket(-1)
  30.             ,_port(port)   
  31.             ,_ip(ip)
  32.         {
  33.  
  34.         }
  35.         void InitServer()//初始化服务器
  36.         {
  37.             //1、创建sockrt套接字
  38.             _listenSocket=socket(AF_INET,SOCK_STREAM,0);
  39.             if(_listenSocket<0)
  40.             {
  41.                 LogMessage(FATAL,"create socket error");
  42.                 exit(SOCKET_ERR);
  43.             }
  44.             LogMessage(NORMAL,"create socket success");
  45.             //2、绑定端口号+ip地址
  46.             struct sockaddr_in local;
  47.             memset(&local,0,sizeof(local));
  48.             local.sin_addr.s_addr=inet_addr(_ip.c_str());
  49.             local.sin_family=AF_INET;
  50.             local.sin_port=htons(_port);
  51.             if(bind(_listenSocket,(struct sockaddr*)&local,sizeof(local))<0)
  52.             {
  53.                 LogMessage(FATAL,"bind socket error");
  54.                 exit(BIND_ERR);
  55.             }
  56.             LogMessage(NORMAL,"bind socket success");
  57.             //3、设置监听状态
  58.             if(-1==listen(_listenSocket,gbacklog))
  59.             {
  60.                 LogMessage(FATAL,"listen socket error");
  61.                 exit(LISTEN_ERR);
  62.             }
  63.             LogMessage(NORMAL,"listen socket success");
  64.         }
  65.         void Start()//启动服务器
  66.         {
  67.             while(1)
  68.             {
  69.                 //4、服务器获取客户端连接请求
  70.                 struct sockaddr_in peer;//输出型参数，拿到客户端的信息
  71.                 socklen_t len=sizeof(peer);
  72.                 int sock=accept(_listenSocket,(struct sockaddr*)&peer,&len);  
  73.                 if(-1==sock)      
  74.                 {
  75.                     LogMessage(ERROR,"accept error,next");
  76.                     continue;
  77.                 }           
  78.                 LogMessage(NORMAL,"accept a new link success");
  79.                 // //5、使用accept的返回值sock进行通信，均为文件操作
  80.                 pid_t id=fork();
  81.                 if(id==0)//子进程
  82.                 {
  83.                     close(_listenSocket);//子进程的
  84.                     if(fork()>0) exit(0);//让子进程退出，孙子进程成为孤儿进程，交给1号进程托管回收其退出资源
  85.                     ServerIO(sock);
  86.                     close(sock);//必须关闭使用完毕的sock，否则文件描述符泄漏（虽然下一句代码exit(0),孙子进程退出也会释放文件描述符，最好还是手动关一下）
  87.                     exit(0);
  88.                 }
  89.                 close(sock);//这是用于通信的套接字fd，父进程和孙子进程都有这个文件描述符，父进程关了，该文件描述符引用技术-1，直至孙子进程退出，该fd才会减为0，关闭
  90.                 //父进程
  91.                 //waitpid()
  92.                 pid_t ret=waitpid(id,nullptr,0);//这里不能用非阻塞等待，否则父进程先跑去执行其他代码，可能会被卡在accept出不来了（没有新的客户端来连接的话）
  93.                 if(ret>0)
  94.                 {
  95.                     std::cout<<"waitsucceess"<<ret<<std::endl;
  96.                 }
  97.             }
  98.         }       
  99.         void ServerIO(int sock)
  100.         {
  101.             char buffer[1024];
  102.             while(1)
  103.             {
  104.                 //服务器读取客户端数据，通过套接字sock这个文件描述符读取数据
  105.                 ssize_t n=read(sock,buffer,sizeof(buffer)-1);
  106.                 if(n>0)
  107.                 {
  108.                     buffer[n]=0;
  109.                     std::cout<<"recv message:"<<buffer<<std::endl;
  110.                     std::string outBuffer=buffer;
  111.                     outBuffer+="[server echo]";
  112.                     //服务器将数据处理后发送回客户端
  113.                     write(sock,outBuffer.c_str(),outBuffer.size());
  114.                 }
  115.                 else if(0==n)//服务器read返回值为0，说明客户端关闭了
  116.                 {
  117.                     LogMessage(NORMAL,"client quit,server quit");
  118.                     break;
  119.                 }
  120.             }
  121.         }
  122.         ~TcpServer()
  123.         {}
  124.     private:
  125.         int _listenSocket;//监听客户端的连接请求，不用于数据通信
  126.         uint16_t _port;//服务器端口号
  127.         std::string _ip;//服务器ip地址
  128.     };
  129. }

区别在于这张图里的代码：

1、close(_listenSocket):关闭子进程的监听fd（虽然手动关不关都行，因为下一句代码就让子进程退出了，最好还是手动关一下）

2、if(fork()>0) exit(0)：让子进程创建孙子进程，子进程退出。提前干掉子进程，这样父进程在外部就可以不用阻塞式等待子进程退出了。同时孙子进程成为孤儿进程，会被1号进程领养，程序员无需关心孤儿进程的退出善后工作。

3、孙子进程close(sock)：必须关闭使用完毕的sock，否则文件描述符泄漏（虽然下一句代码exit(0),孙子进程退出也会释放文件描述符，最好还是手动关一下）

4、父进程close(sock)：这是用于通信的套接字fd，父进程和孙子进程都有这个文件描述符，父进程关了，该文件描述符引用计数-1，直至孙子进程退出，该fd才会减为0，关闭，所以父进程提前关闭该fd不会影响孙子进程。但是这里父进程如果不关，客户端连一个fd+1，存在文件描述符泄露。

5、pid_t ret=waitpid(id,nullptr,0)：这里不能用非阻塞等待，否则父进程先跑去执行其他代码，可能会被卡在accept出不来了（如果没有新的客户端来连接的话，将一直卡在accept）

3、多线程版的TCP客户端、服务器

更换tcpServer.hpp即可，其他文件和单进程版一样。

  1. #pragma once
  2. #include <iostream>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <sys/wait.h>
  6. #include <sys/socket.h>
  7. #include <arpa/inet.h>
  8. #include <netinet/in.h>
  9. #include <string>
  10. #include <cstring>
  11. #include <cstdlib>
  12. #include <pthread.h>
  13. #include "log.hpp"
  14. namespace Server
  15. {
  16.     enum 
  17.     {
  18.         USAGE_ERR=1,
  19.         SOCKET_ERR,
  20.         BIND_ERR,
  21.         LISTEN_ERR,
  22.     };
  23.     static const uint16_t gport=8080;//缺省的端口号
  24.     static const int gbacklog=5;//最大连接数=5+1
  25.     const static std::string defaultIp="0.0.0.0";//缺省的IP
  26.     class TcpServer;
  27.     struct ThreadData//用于线程函数传参
  28.     {
  29.         ThreadData(TcpServer* self,const int& sock)
  30.             :_self(self)
  31.             ,_sock(sock)
  32.         {}
  33.         TcpServer* _self;//this
  34.         int _sock;//通信fd
  35.     };
  36.     class TcpServer
  37.     {
  38.     public:
  39.         TcpServer(const uint16_t& port=gport,const std::string& ip=defaultIp )
  40.             :_listenSocket(-1)
  41.             ,_port(port)   
  42.             ,_ip(ip)
  43.         {
  44.  
  45.         }
  46.         void InitServer()//初始化服务器
  47.         {
  48.             //1、创建sockrt套接字
  49.             _listenSocket=socket(AF_INET,SOCK_STREAM,0);
  50.             if(_listenSocket<0)
  51.             {
  52.                 LogMessage(FATAL,"create socket error");
  53.                 exit(SOCKET_ERR);
  54.             }
  55.             LogMessage(NORMAL,"create socket success");
  56.             //2、绑定端口号+ip地址
  57.             struct sockaddr_in local;
  58.             memset(&local,0,sizeof(local));
  59.             local.sin_addr.s_addr=inet_addr(_ip.c_str());
  60.             local.sin_family=AF_INET;
  61.             local.sin_port=htons(_port);
  62.             if(bind(_listenSocket,(struct sockaddr*)&local,sizeof(local))<0)
  63.             {
  64.                 LogMessage(FATAL,"bind socket error");
  65.                 exit(BIND_ERR);
  66.             }
  67.             LogMessage(NORMAL,"bind socket success");
  68.             //3、设置监听状态
  69.             if(-1==listen(_listenSocket,gbacklog))
  70.             {
  71.                 LogMessage(FATAL,"listen socket error");
  72.                 exit(LISTEN_ERR);
  73.             }
  74.             LogMessage(NORMAL,"listen socket success");
  75.         }
  76.         void Start()//启动服务器
  77.         {
  78.             while(1)
  79.             {
  80.                 //4、服务器获取客户端连接请求
  81.                 struct sockaddr_in peer;//输出型参数，拿到客户端的信息
  82.                 socklen_t len=sizeof(peer);
  83.                 int sock=accept(_listenSocket,(struct sockaddr*)&peer,&len);  
  84.                 if(-1==sock)      
  85.                 {
  86.                     LogMessage(ERROR,"accept error,next");
  87.                     continue;
  88.                 }           
  89.                 LogMessage(NORMAL,"accept a new link success");
  90.                 //5、使用accept的返回值sock进行通信，均为文件操作
  91.                 //多线程版
  92.                 pthread_t tid;
  93.                 ThreadData* td=new ThreadData(this,sock);
  94.                 pthread_create(&tid,nullptr,threadRoutine,(void*)td);
  95.             }
  96.         }   
  97.         static void* threadRoutine(void* args)
  98.         {
  99.             pthread_detach(pthread_self());//线程分离
  100.             ThreadData* td=static_cast<ThreadData*>(args);
  101.             td->_self->ServerIO(td->_sock);//线程调用服务函数
  102.             close(td->_sock);
  103.             delete td;
  104.             return nullptr;
  105.         }
  106.         void ServerIO(int sock)
  107.         {
  108.             char buffer[1024];
  109.             while(1)
  110.             {
  111.                 //服务器读取客户端数据，通过套接字sock这个文件描述符读取数据
  112.                 ssize_t n=read(sock,buffer,sizeof(buffer)-1);
  113.                 if(n>0)
  114.                 {
  115.                     buffer[n]=0;
  116.                     std::cout<<"recv message:"<<buffer<<std::endl;
  117.                     std::string outBuffer=buffer;
  118.                     outBuffer+="[server echo]";
  119.                     //服务器将数据处理后发送回客户端
  120.                     write(sock,outBuffer.c_str(),outBuffer.size());
  121.                 }
  122.                 else if(0==n)//服务器read返回值为0，说明客户端关闭了
  123.                 {
  124.                     LogMessage(NORMAL,"client quit,server quit");
  125.                     break;
  126.                 }
  127.             }
  128.         }
  129.         ~TcpServer()
  130.         {}
  131.     private:
  132.         int _listenSocket;//监听客户端的连接请求，不用于数据通信
  133.         uint16_t _port;//服务器端口号
  134.         std::string _ip;//服务器ip地址
  135.     };
  136. }

        在一个进程中的所有线程都可以访问到文件描述符表，属于共享资源，一个线程所对应的fd在使用完毕后需要进行关闭。

4、线程池版的TCP客户端、服务器

        其他文件和单进程版一样。

4.1tcpServer.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <sys/wait.h>
  6. #include <sys/socket.h>
  7. #include <arpa/inet.h>
  8. #include <netinet/in.h>
  9. #include <string>
  10. #include <cstring>
  11. #include <cstdlib>
  12. #include <pthread.h>
  13. #include "log.hpp"
  14. #include "Task.hpp"
  15. #include "ThreadPool.hpp"
  16. namespace Server
  17. {
  18.     enum 
  19.     {
  20.         USAGE_ERR=1,
  21.         SOCKET_ERR,
  22.         BIND_ERR,
  23.         LISTEN_ERR,
  24.     };
  25.     static const uint16_t gport=8080;//缺省的端口号
  26.     static const int gbacklog=5;//最大连接数=5+1
  27.     const static std::string defaultIp="0.0.0.0";//缺省的IP
  28.     class TcpServer;
  29.     struct ThreadData//用于线程函数传参
  30.     {
  31.         ThreadData(TcpServer* self,const int& sock)
  32.             :_self(self)
  33.             ,_sock(sock)
  34.         {}
  35.         TcpServer* _self;//this
  36.         int _sock;//通信fd
  37.     };
  38.     class TcpServer
  39.     {
  40.     public:
  41.         TcpServer(const uint16_t& port=gport,const std::string& ip=defaultIp )
  42.             :_listenSocket(-1)
  43.             ,_port(port)   
  44.             ,_ip(ip)
  45.         {
  46.  
  47.         }
  48.         void InitServer()//初始化服务器
  49.         {
  50.             //1、创建sockrt套接字
  51.             _listenSocket=socket(AF_INET,SOCK_STREAM,0);
  52.             if(_listenSocket<0)
  53.             {
  54.                 LogMessage(FATAL,"create socket error");
  55.                 exit(SOCKET_ERR);
  56.             }
  57.             LogMessage(NORMAL,"create socket success");
  58.             //2、绑定端口号+ip地址
  59.             struct sockaddr_in local;
  60.             memset(&local,0,sizeof(local));
  61.             local.sin_addr.s_addr=inet_addr(_ip.c_str());
  62.             local.sin_family=AF_INET;
  63.             local.sin_port=htons(_port);
  64.             if(bind(_listenSocket,(struct sockaddr*)&local,sizeof(local))<0)
  65.             {
  66.                 LogMessage(FATAL,"bind socket error");
  67.                 exit(BIND_ERR);
  68.             }
  69.             LogMessage(NORMAL,"bind socket success");
  70.             //3、设置监听状态
  71.             if(-1==listen(_listenSocket,gbacklog))
  72.             {
  73.                 LogMessage(FATAL,"listen socket error");
  74.                 exit(LISTEN_ERR);
  75.             }
  76.             LogMessage(NORMAL,"listen socket success");
  77.         }
  78.         void Start()//启动服务器
  79.         {
  80.             //4、线程池初始化
  81.             ThreadPool<Task>::getInstance()->run();//线程启动
  82.             while(1)
  83.             {
  84.                 //5、服务器获取客户端连接请求
  85.                 struct sockaddr_in peer;//输出型参数，拿到客户端的信息
  86.                 socklen_t len=sizeof(peer);
  87.                 int sock=accept(_listenSocket,(struct sockaddr*)&peer,&len);  
  88.                 if(-1==sock)      
  89.                 {
  90.                     LogMessage(ERROR,"accept error,next");
  91.                     continue;
  92.                 }           
  93.                 LogMessage(NORMAL,"accept a new link success");
  94.                 ThreadPool<Task>::getInstance()->push(Task(sock,ServerIO));
  95.             }
  96.         }   
  97.         ~TcpServer()
  98.         {}
  99.     private:
  100.         int _listenSocket;//监听客户端的连接请求，不用于数据通信
  101.         uint16_t _port;//服务器端口号
  102.         std::string _ip;//服务器ip地址
  103.     };
  104. }

4.2ThreadPool.hpp 

  1. #pragma once
  2. #include <vector>
  3. #include <queue>
  4. #include <pthread.h>
  5. #include <unistd.h>
  6. #include <mutex>
  7. #include "Thread.hpp"
  8. #include "LockGuard.hpp"
  9. using namespace ThreadNs;
  10. const int gnum =5;
  11.  
  12. template <class T>//声明
  13. class ThreadPool;
  14.  
  15. template <class T>
  16. struct ThreadData
  17. {
  18.     ThreadData(ThreadPool<T>* tp,const std::string& s)
  19.     :_threadPool(tp)
  20.     ,_name(s)
  21.     {}
  22.     ThreadPool<T>* _threadPool;
  23.     std::string _name;
  24. };
  25. template <class T>
  26. class ThreadPool
  27. {
  28. private:
  29.     //因为普通成员函数第一个参数是this指针，和回调方法不匹配，故改成static类型
  30.     static void* handlerTask(void* args)//args是ThreadData对象指针
  31.     {
  32.         ThreadData<T>* td=static_cast<ThreadData<T>*>(args);
  33.         while(1)
  34.         {
  35.             T t;
  36.             {   //RAII，出了作用域LockGuard会销毁，将析构锁
  37.                 LockGuard lockGuard(td->_threadPool->mutex());//加锁
  38.                 while(td->_threadPool->IsQueueEmpty())//如果队列为空，则等待
  39.                 {
  40.                     td->_threadPool->ThreadWait();
  41.                 }
  42.                 //线程能走到这里，说明队列一定有任务给线程
  43.                 t=td->_threadPool->Pop();//从队列中取出任务
  44.             }
  45.             t();//Task的operator()
  46.         }
  47.         delete td;//析构ThreadData对象
  48.         return nullptr;
  49.     }
  50.     ThreadPool(const int& num=gnum)
  51.     :_num(num)
  52.     {
  53.         pthread_mutex_init(&_mutex,nullptr);
  54.         pthread_cond_init(&_cond,nullptr);
  55.         //创建线程
  56.         for(int i=0;i<_num;++i)
  57.         {
  58.             _threads.push_back(new Thread());
  59.         }
  60.     }
  61.     ThreadPool(const ThreadPool<T>&)=delete;//禁用拷贝构造
  62.     ThreadPool<T>& operator=(const ThreadPool<T>&)=delete;//禁用赋值运算符重载
  63.  
  64. public://解决静态handlerTask是静态函数的问题，这几个都是偷家函数
  65.     void LockQueue()   {pthread_mutex_lock(&_mutex);}
  66.     void UnLockQueue() {pthread_mutex_unlock(&_mutex);}
  67.     bool IsQueueEmpty(){return _taskQueue.empty();}
  68.     void ThreadWait()  {pthread_cond_wait(&_cond,&_mutex);}
  69.     T Pop()         
  70.     {
  71.         T t=_taskQueue.front();
  72.         _taskQueue.pop();
  73.         return t;
  74.     } 
  75.     pthread_mutex_t* mutex()
  76.     {
  77.         return &_mutex;
  78.     }
  79. public: 
  80.     void run()//线程启动
  81.     {
  82.         for(const auto& t:_threads)
  83.         {
  84.             ThreadData<T>* td=new ThreadData<T>(this,t->threadName());
  85.             t->start(handlerTask,(void*)td);
  86.             std::cout<<t->threadName()<<"start..."<<std::endl;
  87.         }
  88.     }
  89.     void push(const T& in)
  90.     {
  91.         //RAII,出了作用域，锁将会被释放
  92.         LockGuard lockGuard(&_mutex);
  93.         _taskQueue.push(in);
  94.         pthread_cond_signal(&_cond);
  95.         std::cout<<"任务发送成功"<<std::endl;
  96.     }
  97.     ~ThreadPool()
  98.     {
  99.         pthread_mutex_destroy(&_mutex);
  100.         pthread_cond_destroy(&_cond);
  101.         for(const auto& t:_threads)
  102.         {
  103.             delete t;
  104.         }
  105.     }
  106.     static ThreadPool<T>* getInstance()//这里的static的作用是让这个函数只有一份，获取单例对象。tp是临界资源，需要加锁
  107.     {
  108.         if(nullptr==tp)//因为锁只创建一次，防止线程进来被锁阻塞
  109.         {
  110.             //只进来一次就够了
  111.             _singletonLock.lock();
  112.             if(nullptr==tp)//说明对象还没有被创建
  113.             {
  114.                 tp=new ThreadPool<T>(); 
  115.             }
  116.             _singletonLock.unlock();
  117.         }
  118.         return tp;
  119.     }
  120. private:
  121.     int _num;//线程个数
  122.     std::vector<Thread*> _threads;//使用vector存放线程
  123.     std::queue<T> _taskQueue;//任务队列，往里面放任务，它是共享资源，需要加锁保护
  124.     pthread_mutex_t _mutex;//互斥锁
  125.     pthread_cond_t _cond;//条件变量
  126.  
  127.     static ThreadPool<T>* tp;//单例模式静态的对象指针
  128.     static std::mutex _singletonLock;//获取单例对象使用的锁
  129.  
  130. };
  131. template <class T>
  132. ThreadPool<T>* ThreadPool<T>::tp=nullptr;
  133.  
  134. template <class T>
  135. std::mutex ThreadPool<T>::_singletonLock;

4.3Task.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <functional>
  4. #include <string>
  5. void ServerIO(int sock)
  6. {
  7.     char buffer[1024];
  8.     while(1)//适应快速响应的任务，这个任务while其实不太合适
  9.     {
  10.         //服务器读取客户端数据，通过套接字sock这个文件描述符读取数据
  11.         ssize_t n=read(sock,buffer,sizeof(buffer)-1);
  12.         if(n>0)
  13.         {
  14.             buffer[n]=0;
  15.             std::cout<<"recv message:"<<buffer<<std::endl;
  16.             std::string outBuffer=buffer;
  17.             outBuffer+="[server echo]";
  18.             //服务器将数据处理后发送回客户端
  19.             write(sock,outBuffer.c_str(),outBuffer.size());
  20.         }
  21.         else if(0==n)//服务器read返回值为0，说明客户端关闭了
  22.         {
  23.             close(sock);
  24.             LogMessage(NORMAL,"client quit,server quit");
  25.             break;
  26.         }
  27.     }
  28. }
  29. class Task
  30. {
  31.     //using func_t=std::function<int(int,int,char)>;
  32.     typedef std::function<void(int)> func_t;//函数对象
  33. public:
  34.     Task()
  35.     {}
  36.     Task(int sock,func_t func)
  37.     :_sock(sock)
  38.     ,_callBack(func)
  39.     {}
  40.     void operator()()//消费者调用
  41.     {
  42.         _callBack(_sock);
  43.     }
  44. private:
  45.     int _sock;
  46.     func_t _callBack;//回调函数
  47. };

5、守护进程+多线程版的TCP客户端、服务器

        其他文件和单进程版一样。

5.1daemon.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <unistd.h>
  4. #include <signal.h>
  5. #include <cstdlib>
  6. #include <cassert>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <fcntl.h>
  10. #define DEV "/dev/null"//数据黑洞，向它写入的数据会被吃掉，读取数据什么都读不到（不会使进程退出）
  11. void DaemonSele(const char* currrPath=nullptr)
  12. {
  13.     //1、让调用进程屏蔽异常的信号
  14.     //SIGPIPE信号会在进程向一个已经关闭的socket连接写数据时产生，如果不处理这个信号，进程会被强制退出。通过忽略SIGPIPE信号，可以避免进程因为这个信号而退出。
  15.     signal(SIGPIPE,SIG_IGN);
  16.     //2、让自己不是组长，调用setsid
  17.     if(fork()>0) exit(0);//守护进程也称精灵进程，本质就是一个孤儿进程
  18.     pid_t n=setsid();
  19.     assert(n!=-1);//失败返回-1
  20.     //3、守护进程脱离终端，所以要关闭或重定向进程默认打开的文件及文件描述符
  21.     int fd=open(DEV,O_RDWR);//以读写的方式打开文件黑洞
  22.     if(fd>=0)//创建成功：重定向
  23.     {
  24.         dup2(fd,0);//将fd覆盖标准输入
  25.         dup2(fd,1);
  26.         dup2(fd,2);
  27.         close(fd);
  28.     }
  29.     else//创建失败：手动关闭文件描述符
  30.     {
  31.         close(0);
  32.         close(1);
  33.         close(2);
  34.     }
  35.     //4、进程执行路径更改（可改可不改）
  36.     if(currrPath)
  37.     {
  38.         chdir(currrPath);
  39.     }
  40. }

5.2tcpServer.cc

  1. #include "tcpServer.hpp"
  2. #include "memory"
  3. #include "daemon.hpp"
  4. using namespace Server;
  5. static void Usage(std::string proc)
  6. {
  7.     std::cout<<"Usage:\n\t"<<proc<<"serverPort\n\n";
  8. }
  9. //./tcpServer local_port
  10. int main(int argc,char* argv[])
  11. {
  12.     if(argc!=2)//判断外部传入的参数是否为2
  13.     {
  14.         Usage(argv[0]);
  15.         exit(USAGE_ERR);
  16.     }
  17.     uint16_t port=std::stoi(argv[1]);
  18.     std::unique_ptr<TcpServer> tsvr(new TcpServer(port));
  19.     tsvr->InitServer();
  20.     DaemonSele();//守护进程化，让这个独立的孤儿进程去启动服务器
  21.     tsvr->Start();
  22.     return 0;
  23. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/188248
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号