wordpress多站点子域名,做网站还有前景吗,网页版微信网址,小说+wordpress接着上一篇文章#xff1a;http://t.csdnimg.cn/GZDlI
在上一篇文章中#xff0c;我们实现的是UDP协议的#xff0c;今天我们就要来实现一下TCP版本的
接下来接下来实现一批基于 TCP 协议的网络程序#xff0c;本节只介绍基于IPv4的socket网络编程 基于 TCP 的网络编程开…接着上一篇文章http://t.csdnimg.cn/GZDlI
在上一篇文章中我们实现的是UDP协议的今天我们就要来实现一下TCP版本的
接下来接下来实现一批基于 TCP 协议的网络程序本节只介绍基于IPv4的socket网络编程 基于 TCP 的网络编程开发分为服务器端和客户端两部分常见的核心步骤和流程如下 1.TCP网络通信程序
1.1.程序结构
分别实现客户端与服务器客户端向服务器发送消息服务器收到消息后回响给客户端有点类似于 echo 指令 这个程序我们已经基于 UDP 协议实现过了换成 TCP 协议实现时程序的结构是没有变化的同样需要 server.hpp、server.cc、client.hpp、client.cc 这几个文件 创建 server.hpp 服务器头文件 #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.hnamespace nt_server
{const uint16_t default_port 8877; // 默认端口号const std::string default_ip 0.0.0.0;//默认IPenum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR};class TcpServer{public:TcpServer( const uint16_t port default_port,const std::string ip default_ip):ip_(ip),port_(port){}~TcpServer(){}// 初始化服务器void InitServer(){}// 启动服务器void StartServer(){}private:int sock_; // 套接字存疑uint16_t port_; // 端口号std::string ip_;//ip地址};
}创建 server.cc 服务器源文件 #include string
#include vector
#include memory // 智能指针相关头文件
#include cstdio
#include server.hppusing namespace std;
using namespace nt_server;//业务处理函数
std::string ExecCommand(const std::string request)
{ return request;
}void Usage(const char* program)
{cout Usage: endl;cout \t program ServerPort endl;
}int main(int argc, char* argv[])
{if (argc ! 2){// 错误的启动方式提示错误信息Usage(argv[0]);return USAGE_ERR;}//命令行参数都是字符串我们需要将其转换成对应的类型uint16_t port stoi(argv[1]);//将字符串转换成端口号unique_ptrTcpServer usvr (new TcpServer(port));usvr-InitServer();usvr-StartServer();return 0;
}创建 client.hpp 客户端头文件 #pragma once#include iostream
#include string
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#include err.hppnamespace nt_client
{enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR};class TcpClient{public:TcpClient(const std::string ip, const uint16_t port):server_ip_(ip), server_port_(port){}~TcpClient(){}// 初始化客户端void InitClient(){}// 启动客户端void StartClient(){}private:int sock_; // 套接字std::string server_ip_; // 服务器IPuint16_t server_port_; // 服务器端口号};
}创建 client.cc 客户端源文件 #include memory
#include client.hppusing namespace std;
using namespace nt_client;void Usage(const char *program)
{cout Usage: endl;cout \t program ServerIP ServerPort endl;
}int main(int argc, char *argv[])
{if (argc ! 3){// 错误的启动方式提示错误信息Usage(argv[0]);return USAGE_ERR;}// 服务器IP与端口号string ip(argv[1]);uint16_t port stoi(argv[2]);unique_ptrTcpClient usvr(new TcpClient(ip, port));usvr-InitClient();usvr-StartClient();return 0;
}同时需要一个 Makefile 文件用于快速编译和清理可执行程序 创建 Makefile 文件 .PHONY:all
all:server clientserver:server.ccg -o $ $^ -stdc11client:client.ccg -o $ $^ -stdc11.PHONY:clean
clean:rm -rf server client1.2.服务端设计
1.2.1.初始化服务端——socket和bind函数
基于 TCP 协议实现的网络程序也需要 创建套接字、绑定 IP 和端口号
注意在使用 socket 函数创建套接字时UDP 协议需要指定参数2为 SOCK_DGRAMTCP 协议则是指定参数2为 SOCK_STREAM server.hpp的初始化部分 // 初始化服务器void InitServer(){// 1.创建套接字sock_ socket(AF_INET, SOCK_STREAM, 0);if (sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Socket Success! sock_ std::endl;// 2.绑定IP地址与端口号struct sockaddr_in local;memset(local, 0, sizeof(local)); // 清零local.sin_family AF_INET; // 网络local.sin_addr.s_addr inet_addr(default_ip.c_str()); // 我设置为默认绑定任意可用IP地址local.sin_port htons(port_); // 我设置为默认是8877if(bind(sock_,(const sockaddr *)local, sizeof(local))0){std::cout Bind IPPort Fail: strerror(errno) std::endl;exit(BIND_ERR);}// 3.TODO}注意 在绑定端口号时一定需要把主机序列转换为网络序列 为什么在绑定端口号阶段需要手动转换为网络序列而在发送信息阶段则不需要 这是因为在发送信息阶段recvfrom / sendto 等函数会自动将需要发送的信息转换为网络序列接收信息时同样会将其转换为主机序列所以不需要手动转换 这个代码和UDP版本的差不多 如果使用的 UDP 协议那么初始化服务器到此就结束了但我们本文中使用的是 TCP 协议这是一个 面向连接 的传输层协议意味着在初始化服务器时需要设置服务器为 监听 状态 TCP是面向连接的服务器一般是比较被动的没人访问这个服务器只能干等着而且也不能退出。就像你是一家餐馆的老板你只能在餐馆里被动的等待顾客的到来顾客什么时候来你也不知道。服务器要一直要处于等待链接到来的状态——也就是监听状态。
1.2.2.监听状态——listen函数
对于服务器它是被动连接的。举一个生活中的例子通常的情况下移动的客服相当于服务器是等待着客户相当于客户端电话的到来。而这个过程需要调用listen()函数。
#includesys/socket.h
int listen(int sockfd, int backlog);
listen() 函数的主要作用就是将套接字( sockfd )变成被动的连接监听套接字被动等待客户端的连接。所谓被动监听是指当没有客户端请求时套接字处于“睡眠”状态只有当接收到客户端请求时套接字才会被“唤醒”来响应请求。
我们看看参数 int sockfd 服务端的socket也就是socket函数创建的标识绑定的未连接的套接字的描述符。 int backlog backlog 为请求队列的最大长度。 比如有100个用户链接请求但是系统一次只能处理20个那么剩下的80个不能不理人家所以系统就创建个队列记录这些暂时不能处理一会儿处理的连接请求依先后顺序处理那这个队列到底多大就是这个参数设置比如2那么就允许两个新链接排队。这个不能无限大那内存就不够了。 当套接字正在处理客户端请求时如果有新的请求进来套接字是没法处理的只能把它放进缓冲区待当前请求处理完毕后再从缓冲区中读取出来处理。如果不断有新的请求进来它们就按照先后顺序在缓冲区中排队直到缓冲区满。这个缓冲区就称为请求队列Request Queue。 缓冲区的长度能存放多少个客户端请求可以通过 listen() 函数的 backlog 参数来指定但究竟为多少并没有什么标准可以根据你的需求来自定义设定并发量小的话可以是10或者20。 如果将 backlog 的值设置为 SOMAXCONN就由系统来决定请求队列长度这个值一般比较大可能是几百或者更多。 当请求队列满时就不再接收新的请求对于 Linux客户端会收到 ECONNREFUSED 错误对于 Windows客户端会收到 WSAECONNREFUSED 错误。 这里需要注意的是listen()函数不会阻塞它主要做的事情为将该套接字和套接字对应的连接队列长度告诉 Linux 内核然后listen()函数就结束。 注意listen() 只是让套接字处于监听状态并没有接收请求。接收请求需要使用 accept() 函数。 server.hpp的初始化服务器部分 #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#includecstringnamespace nt_server
{const uint16_t default_port 8877; // 默认端口号const std::string default_ip 0.0.0.0; // 默认IPconst int backlog5;//请求队列的最大长度enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR};class TcpServer{public:TcpServer( const uint16_t port default_port,const std::string ip default_ip): ip_(ip), port_(port){}~TcpServer(){}// 初始化服务器void InitServer(){// 1.创建套接字sock_ socket(AF_INET, SOCK_STREAM, 0);if (sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Socket Success! sock_ std::endl;// 2.绑定IP地址与端口号struct sockaddr_in local;memset(local, 0, sizeof(local)); // 清零local.sin_family AF_INET; // 网络local.sin_addr.s_addr inet_addr(default_ip.c_str()); // 我设置为默认绑定任意可用IP地址local.sin_port htons(port_); // 我设置为默认是8877if(bind(sock_,(const sockaddr *)local, sizeof(local))0){std::cout Bind IPPort Fail: strerror(errno) std::endl;exit(BIND_ERR);}if(listen(sock_,backlog)0){perror(Listen fail);exit(LIS_ERR);}}// 启动服务器void StartServer(){}private:int sock_; // 套接字存疑uint16_t port_; // 端口号std::string ip_; // ip地址};
}
至此我们的服务器初始化部分已经完成了 ,接下来我们进入服务器运行函数的设计。
// 启动服务器void StartServer(){for(;;){std::coutTCP SERVER is running.....std::endl;sleep(1);}}
这个时候我们就可以运行起来测试一下我们的服务器 查看监听的TCP端口 netstat -ntlp 很好完美通过测试 1.2.3.接受连接——accept函数 首先我要说的是listen() 只是让套接字进入监听状态并没有真正接收客户端请求listen() 后面的代码会继续执行直到遇到 accept()。accept() 会阻塞程序执行后面代码不能被执行直到有新的请求到来。
当套接字处于监听状态时可以通过 accept() 函数来接收客户端请求。它的原型为 sockfd 为服务器端套接字addr 为 sockaddr_in 结构体变量addrlen 为参数 addr 的长度可由 sizeof() 求得。其中 addr 与 addrlen 是一个 输入输出型 参数类似于 recvfrom 中的参数 accept() 返回一个新的套接字来和客户端通信addr 保存了客户端的IP地址和端口号而 sockfd 是服务器端的套接字大家注意区分。后面和客户端通信时要使用这个新生成的套接字而不是原来服务器端的套接字。 基于TCP连接的服务器端为什么需要用两个套接字 在服务器端socket()返回的套接字用于监听listen和接受accept客户端的连接请求。这个套接字不能用于与客户端之间发送和接收数据。 accept()接受一个客户端的连接请求并返回一个新的套接字。所谓“新的”就是说这个套接字与socket()返回的用于监听和接受客户端的连接请求的套接字不是同一个套接字。与本次接受的客户端的通信是通过在这个新的套接字上发送和接收数据来完成的。 再次调用accept()可以接受下一个客户端的连接请求并再次返回一个新的套接字与socket()返回的套接字、之前accept()返回的套接字都不同的新的套接字。这个新的套接字用于与这次接受的客户端之间的通信。 假设一共有3个客户端连接到服务器端。那么在服务器端就一共有4个套接字第1个是socket()返回的、用于监听的套接字其余3个是分别调用3次accept()返回的不同的套接字。如果已经有客户端连接到服务器端不再需要监听和接受更多的客户端连接的时候可以关闭由socket()返回的套接字而不会影响与客户端之间的通信。 当某个客户端断开连接、或者是与某个客户端的通信完成之后服务器端需要关闭用于与该客户端通信的套接字。 这样子的话我们网络通信使用的都是accept函数返回的套接字那么服务端的socket套接字就只有监听作用 我们得把它们区分出来一个就叫listen_sock_另外一个叫accept_socket server.hpp的StartServer的内容 #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#includecstring
#includeunistd.hnamespace nt_server
{const uint16_t default_port 8877; // 默认端口号const std::string default_ip 0.0.0.0; // 默认IPconst int backlog5;//请求队列的最大长度enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR};class TcpServer{public:TcpServer( const uint16_t port default_port,const std::string ip default_ip): ip_(ip), port_(port){}~TcpServer(){}// 初始化服务器void InitServer(){// 1.创建套接字listen_sock_ socket(AF_INET, SOCK_STREAM, 0);if (listen_sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Socket Success! listen_sock_ std::endl;// 2.绑定IP地址与端口号struct sockaddr_in local;memset(local, 0, sizeof(local)); // 清零local.sin_family AF_INET; // 网络local.sin_addr.s_addr inet_addr(default_ip.c_str()); // 我设置为默认绑定任意可用IP地址local.sin_port htons(port_); // 我设置为默认是8877if(bind(listen_sock_,(const sockaddr *)local, sizeof(local))0){std::cout Bind IPPort Fail: strerror(errno) std::endl;exit(BIND_ERR);}if(listen(listen_sock_,backlog)0){perror(Listen fail);exit(LIS_ERR);}}// 启动服务器void StartServer(){for(;;){//1.获取新连接struct sockaddr_in client;socklen_t lensizeof(client);int accept_socketaccept(listen_sock_,(struct sockaddr*)client,len);if(accept_socket0){std::coutaccept failedstd::endl;continue;}std::coutget a new link...,sockfd:accept_socketstd::endl;//2.根据新连接来进行通信}}private:int listen_sock_; // socket套接字uint16_t port_; // 端口号std::string ip_; // ip地址};
}
这个时候我们就可以来测试一下我们的连接了可是我们没有写客户端怎么办 1.2.3.1.测试工具——telnet Linux其实有这么一个工具可以干这个测试的工作 telnet telnet是一种用于远程登录的网络协议可以将本地计算机链接到远程主机。 Linux提供了telnet命令它允许用户在本地计算机上通过telnet协议连接到远程主机并执行各种操作。 使用telnet命令可以建立客户端与服务器之间的虚拟终端连接这使得用户可以通过网络远程登录到其他计算机并在远程计算机上执行命令就像直接在本地计算机上操作一样。 要使用telnet命令首先需要确保你的Linux系统已经安装了telnet软件包。如果未安装可以通过以下命令在终端中安装 sudo yum install telnet 安装完成后你可以通过以下命令来使用telnet命令 telnet [选项] [主机名或IP地址] [端口号]可以使用不同的选项和参数来执行不同的操作下面是一些常用的选项和参数 -l 用户名指定用户名进行登录。-p 端口号指定要连接的远程主机端口号。-E在telnet会话中打开字符转义模式。-e 字符指定telnet会话中的转义字符。-r在执行用户登录之前不要求用户名。-K在连接到telnet会话时要求密码。 好了我们现在就来使用 我们点击ctrl]就能进入连接 我们这个时候将服务端退出却发现我们的连接还在 我们再次启动服务端就出现了下面这些提示 这些东西刚好就验证了上面所说的东西。 如果已经有客户端连接到服务器端不再需要监听和接受更多的客户端连接的时候可以关闭由socket()返回的套接字而不会影响与客户端之间的通信。 我们这个时候如果想终止我们客户端的连接只需要在客户端输入q即可 1.2.4.网络通信——read和write函数
目前我们的网络连接已经完成了。接下来是通信的时刻。 我们在上面说过accept()接受一个客户端的连接请求并返回一个新的套接字。所谓“新的”就是说这个套接字与socket()返回的用于监听和接受客户端的连接请求的套接字不是同一个套接字。与本次接受的客户端的通信是通过在这个新的套接字上发送和接收数据来完成的。 Linux 不区分套接字文件和普通文件使用 write() 可以向套接字中写入数据使用 read() 可以从套接字中读取数据。 两台计算机之间的通信相当于两个套接字之间的通信在服务器端用 write() 向套接字写入数据客户端就能收到然后再使用 read() 从套接字中读取出来就完成了一次通信。
好了话不多说我们将这个通信模块写出了
// 业务处理
void Service(int sock, const std::string clientip, const uint16_t clientport)
{char buff[1024];std::string who clientip - std::to_string(clientport);while (true){ssize_t n read(sock, buff, sizeof(buff) - 1); // 预留 \0 的位置if (n 0){// 读取成功buff[n] \0;std::cout Server get: buff from who std::endl;std::string respond func_(buff); // 实际业务处理由上层指定// 发送给服务器write(sock, buff, strlen(buff));}else if (n 0){// 表示当前读取到文件末尾了结束读取std::cout Client who sock quit! std::endl;close(sock); // 关闭文件描述符break;}else{// 读取出问题暂时std::cerr Read Fail! strerror(errno) std::endl;close(sock); // 关闭文件描述符break;}}
}根据UDP的经验我们很快就能写出下面这个 server.hpp #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#includecstring
#includeunistd.h
#includefunctionalnamespace nt_server
{const uint16_t default_port 8877; // 默认端口号const std::string default_ip 0.0.0.0; // 默认IPconst int backlog5;//请求队列的最大长度using func_t std::functionstd::string(std::string); // 回调函数类型enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR};class TcpServer{public:TcpServer(const func_t func,const uint16_t port default_port,const std::string ip default_ip): ip_(ip), port_(port),func_(func)//注意这里要传1个业务处理函数{}~TcpServer(){}// 初始化服务器void InitServer(){// 1.创建套接字listen_sock_ socket(AF_INET, SOCK_STREAM, 0);if (listen_sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Socket Success! listen_sock_ std::endl;// 2.绑定IP地址与端口号struct sockaddr_in local;memset(local, 0, sizeof(local)); // 清零local.sin_family AF_INET; // 网络local.sin_addr.s_addr inet_addr(default_ip.c_str()); // 我设置为默认绑定任意可用IP地址local.sin_port htons(port_); // 我设置为默认是8877if(bind(listen_sock_,(const sockaddr *)local, sizeof(local))0){std::cout Bind IPPort Fail: strerror(errno) std::endl;exit(BIND_ERR);}if(listen(listen_sock_,backlog)0){perror(Listen fail);exit(LIS_ERR);}}// 启动服务器void StartServer(){for(;;){//1.获取新连接struct sockaddr_in client;socklen_t lensizeof(client);int accept_socketaccept(listen_sock_,(struct sockaddr*)client,len);if(accept_socket0){std::coutaccept failedstd::endl;continue;}//2.业务处理//2.1客户端信息存储uint16_t clientportntohs(client.sin_port);//客户端端口号char iptr[32];inet_ntop(AF_INET,(client.sin_addr),iptr,sizeof(iptr));//客户端IPstd::cout Server accept iptr - clientport accept_socket from listen_sock_ success! std::endl;//2.2.业务处理Service(accept_socket,iptr,clientport); }}// 通信服务业务处理void Service(int sock, const std::string clientip, const uint16_t clientport){char buff[1024];std::string who clientip - std::to_string(clientport);while (true){ssize_t n read(sock, buff, sizeof(buff) - 1); // 预留 \0 的位置if (n 0){// 读取成功buff[n] \0;std::cout Server get: buff from who std::endl;std::string respond func_(buff); // 实际业务处理由上层指定// 发送给服务器write(sock, buff, strlen(buff));}else if (n 0){// 表示当前读取到文件末尾了结束读取std::cout Client who sock quit! std::endl;close(sock); // 关闭文件描述符break;}else{// 读取出问题暂时std::cerr Read Fail! strerror(errno) std::endl;close(sock); // 关闭文件描述符break;}}}private:int listen_sock_; // socket套接字uint16_t port_; // 端口号std::string ip_; // ip地址func_t func_;//业务处理函数};
}
1.2.5.服务器源文件设计
对于当前的 TCP 网络程序字符串回响来说业务处理函数逻辑非常简单无非就是直接将客户端发送过来的消息重新转发给客户端
server.cc #include string
#include vector
#include memory // 智能指针相关头文件
#include cstdio
#include server.hppusing namespace std;
using namespace nt_server;// 业务处理回调函数字符串回响
string echo(string request)
{return request;
}void Usage(const char* program)
{cout Usage: endl;cout \t program ServerPort endl;
}int main(int argc, char* argv[])
{if (argc ! 2){// 错误的启动方式提示错误信息Usage(argv[0]);return USAGE_ERR;}//命令行参数都是字符串我们需要将其转换成对应的类型uint16_t port stoi(argv[1]);//将字符串转换成端口号unique_ptrTcpServer usvr (new TcpServer(echo,port));usvr-InitServer();usvr-StartServer();return 0;
}
好了我们来测试 很完美啊服务器收到了我们发的对方也能收到
可是这个不是我们写的客户端我们得自己去实现一下自己的客户端
1.3.客户端设计
话不多说先看原理图 可以看到啊这个客户端的实现可比服务端简单的多。 client.cc #include iostream
#include memory
#include client.hppusing namespace std;
using namespace nt_client;void Usage(const char* program)
{cout Usage: endl;cout \t program ServerIP ServerPort endl;
}int main(int argc, char* argv[])
{if (argc ! 3){// 错误的启动方式提示错误信息Usage(argv[0]);return USAGE_ERR;}//命令行参数都是字符串我们需要将其转换成对应的类型std::string ipargv[1];uint16_t port stoi(argv[2]);//将字符串转换成端口号unique_ptrTcpClient usvr (new TcpClient(ip,port));usvr-InitClient();usvr-StartClient();return 0;
}
1.3.1.初始化客户端——socket函数
这个和UDP版本的其实很像。 对于客户端来说服务器的 IP 地址与端口号是两个不可或缺的元素因此在客户端类中server_ip 和 server_port 这两个成员是少不了的当然得有 socket 套接字 初始化客户端只需要干一件事创建套接字客户端是主动发起连接请求的一方也就意味着它不需要使用 listen 函数设置为监听状态 此外呢和UDP版的程序一样TCP版本的也是不需要我们手动写代码去bind的也是操作系统自己去自动bind的 client.hpp 客户端头文件 #pragma once#include iostream
#include string
#include cstring
#include cerrno
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.hnamespace nt_client
{enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR};class TcpClient{public:TcpClient(const std::string ip, const uint16_t port):server_ip_(ip), server_port_(port){}~TcpClient(){}// 初始化客户端void InitClient(){// 创建套接字sock_ socket(AF_INET, SOCK_STREAM, 0);if (sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Sock Succeess! sock_ std::endl;}// 启动客户端void StartClient(){}private:int sock_; // 套接字std::string server_ip_; // 服务器IPuint16_t server_port_; // 服务器端口号};
}1.3.2.连接服务器——connect函数
因为 TCP 协议是面向连接的服务器已经处于处理连接请求的状态了客户端现在需要做的就是尝试进行连接使用 connect 函数进行连接
#include sys/types.h
#include sys/socket.h
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);参数 第一个参数int sockdf socket文件描述符 第二个参数 const struct sockaddr *addr 传入参数指定服务器端地址信息含IP地址和端口号 第三个参数socklen_t addrlen 传入参数,传入sizeof(addr)大小 返回值 成功 0 失败-1设置errno
当客户端调用 connect函数之后发生一下情况之一才会返回完成函数调用
服务器端接收连接请求发生断网的异常情况而终端连接请求 需要注意的是所谓的“接收连接”并不意味着服务器调用 accept函数。其实是服务器端把连接请求信息记录到listen的请求队列因此 connect函数返回后并不进行数据交换。而是要等服务器端 accept 之后才能进行数据交换read、write。 客户端端需要调用connect()连接服务器connect和bind的参数形式一致区别在于bind的参数是自己的地址而connect的参数是对方的地址。
这就是客户端的难点所在了。 注意 在连接过程中可能遇到很多问题比如 网络传输失败、服务器未启动 等这些问题的最终结果都是客户端连接失败如果按照之前的逻辑失败就退出那么客户端的体验感会非常不好因此在面对连接失败这种常见问题时客户端应该尝试重连如果重连数次后仍然失败才考虑终止进程 StartClient() 启动客户端函数 — 位于 client.hpp 中的 TcpClient 类 // 启动客户端
void StartClient()
{// 填充服务器的 sockaddr_in 结构体信息struct sockaddr_in server;socklen_t len sizeof(server);memset(server, 0, len);server.sin_family AF_INET;inet_aton(server_ip_.c_str(), server.sin_addr); // 将点分十进制转化为二进制IP地址的另一种方法server.sin_port htons(server_port_);// 尝试重连 5 次int n 5;while(n){int ret connect(sock_, (const struct sockaddr*)server, len);if(ret 0){// 连接成功可以跳出循环break;}// 尝试进行重连std::cerr 网络异常正在进行重连... 剩余连接次数: --n std::endl;sleep(1);}// 如果剩余重连次数为 0证明连接失败if(n 0){std::cerr 连接失败! strerror(errno) std::endl;close(sock_);exit(CONNECT_ERR);}// 连接成功std::cout 连接成功! std::endl;// 进行业务处理// GetService();
} 当然相应的错误码也得添加我们在下面的源代码里再告诉大家
我们现在可以来试运行一下现在先不启动服务器编译并启动客户端模拟连接失败的情况 如果在数秒之后启动再服务器可以看到重连成功 1.3.3.获取服务
客户端在进行获取服务的时候同样可以使用 read 和 write 进行网络通信 Service() 获取服务函数 — 位于 client.hpp 客户端头文件中的 TcpClient 类 // 获取服务
void GetService()
{char buff[1024];std::string who server_ip_ - std::to_string(server_port_);while(true){// 由用户输入信息std::string msg;std::cout Please Enter ;std::getline(std::cin, msg);// 发送信息给服务器write(sock_, msg.c_str(), msg.size());// 接收来自服务器的信息ssize_t n read(sock_, buff, sizeof(buff) - 1);if(n 0){// 正常通信buff[n] \0;std::cout Client get: buff from who std::endl;}else if(n 0){// 读取到文件末尾服务器关闭了std::cout Server who quit! std::endl;close(sock_); // 关闭文件描述符break;}else{// 读取异常std::cerr Read Fail! strerror(errno) std::endl;close(sock_); // 关闭文件描述符break;}}
}1.3.4.客户端源代码
至此整个 基于 TCP 协议的字符串回响程序 就完成了 client.hpp #pragma once#include iostream
#include string
#include cstring
#include cerrno
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#includeunistd.h
#includesys/wait.hnamespace nt_client
{enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR,CONNECT_ERR};class TcpClient{public:TcpClient(const std::string ip, const uint16_t port):server_ip_(ip), server_port_(port){}~TcpClient(){}// 初始化客户端void InitClient(){// 创建套接字sock_ socket(AF_INET, SOCK_STREAM, 0);if (sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Sock Succeess! sock_ std::endl;}// 启动客户端void StartClient(){// 填充服务器的 sockaddr_in 结构体信息struct sockaddr_in server;socklen_t len sizeof(server);memset(server, 0, len);//清空server.sin_family AF_INET;//网络通信inet_aton(server_ip_.c_str(), server.sin_addr); // 将点分十进制转化为二进制IP地址的另一种方法server.sin_port htons(server_port_);// 尝试重连 5 次int n 5;while (n){int ret connect(sock_, (const struct sockaddr *)server, len);if (ret 0){// 连接成功可以跳出循环break;}// 尝试进行重连std::cerr 网络异常正在进行重连... 剩余连接次数: --n std::endl;sleep(1);}// 如果剩余重连次数为 0证明连接失败if (n 0){std::cerr 连接失败! strerror(errno) std::endl;close(sock_);exit(CONNECT_ERR);}// 连接成功std::cout 连接成功! std::endl;// 获取服务GetService();}// 获取服务void GetService(){char buff[1024];std::string who server_ip_ - std::to_string(server_port_);while (true){// 由用户输入信息std::string msg;std::cout Please Enter ;std::getline(std::cin, msg);// 发送信息给服务器write(sock_, msg.c_str(), msg.size());// 接收来自服务器的信息ssize_t n read(sock_, buff, sizeof(buff) - 1);if (n 0){// 正常通信buff[n] \0;std::cout Client get: buff from who std::endl;}else if (n 0){// 读取到文件末尾服务器关闭了std::cout Server who quit! std::endl;close(sock_); // 关闭文件描述符break;}else{// 读取异常std::cerr Read Fail! strerror(errno) std::endl;close(sock_); // 关闭文件描述符break;}}}private:int sock_; // 套接字std::string server_ip_; // 服务器IPuint16_t server_port_; // 服务器端口号};
} client.cc #include iostream
#include memory
#include client.hppusing namespace std;
using namespace nt_client;void Usage(const char* program)
{cout Usage: endl;cout \t program ServerIP ServerPort endl;
}int main(int argc, char* argv[])
{if (argc ! 3){// 错误的启动方式提示错误信息Usage(argv[0]);return USAGE_ERR;}//命令行参数都是字符串我们需要将其转换成对应的类型std::string ipargv[1];uint16_t port stoi(argv[2]);//将字符串转换成端口号unique_ptrTcpClient usvr (new TcpClient(ip,port));usvr-InitClient();usvr-StartClient();return 0;
}
1.4.测试 可以看到当客户端向服务器发起连接请求时服务器可以识别并接受连接双方建立连接关系后可以正常进行通信当客户端主动退出断开连接服务器也能感知到并判断出是谁断开了连接 当客户端已经和服务端成功连接上了但是这个时候终止了服务端我们此时立马重启服务器会发现短期内无法再次启动服务显示端口正在被占用这是由于 TCP 协议断开连接时的特性导致的正在处于 TIME_WAIT 状态详细原因将会在后续博客中讲解 服务端关闭的时候客户端还是存在连接的但是发出消息之后就会自动退出。
到目前为止我们的程序都是运行的挺好的接下来我们再加入一个客户端看看 对于之前编写的 字符串回响程序 来说如果只有一个客户端进行连接并通信是没有问题的但如果有多个客户端发起连接请求并尝试进行通信服务器是无法应对的
我们可以看看server.hpp的 // 启动服务器void StartServer(){for(;;){//1.获取新连接。。。。。。int accept_socketaccept(listen_sock_,(struct sockaddr*)client,len);。。。。。//2.2.业务处理Service(accept_socket,iptr,clientport); }}
原因在于 服务器是一个单进程版本处理连接请求 和 业务处理 是按顺序执行的如果想处理下一个连接请求需要把当前的业务处理完成 为什么客户端B会显示当前已经连接成功 这是因为是客户端是主动发起连接请求的一方在请求发出后如果出现连接错误客户端就认为已经连接成功了但实际上服务器还没有处理这个连接请求 A客户端断开连接服务端才会去处理B客户端的连接此时才轮到B客户端和服务器进行通信 这显然是服务器的问题处理连接请求 与 提供服务 应该交给两个不同的执行流完成可以使用多进程或者多线程解决。
1.5.多进程版服务器
1.5.1.父进程阻塞等待
所以当前需要实现的网络程序核心功能为当服务器成功处理连接请求后fork 新建一个子进程用于进行业务处理原来的进程专注于处理连接请求 子进程创建成功后会继承父进程的文件描述符表能轻而易举的获取客户端的 socket 套接字从而进行网络通信 当然不止文件描述符表得益于 写时拷贝 机制子进程还会共享父进程的变量当发生修改行为时才会自己创建 注意 当子进程取走客户端的 socket 套接字进行通信后父进程需要将其关闭因为它不需要了避免文件描述符泄漏
// 进程创建、等待所需要的头文件
#include unistd.h
#include sys/wait.h
#include sys/types.h// 启动服务器void StartServer(){for (;;){// 1.获取新连接struct sockaddr_in client;socklen_t len sizeof(client);int accept_socket accept(listen_sock_, (struct sockaddr *)client, len);if (accept_socket 0){std::cout accept failed std::endl;continue;}// 2.业务处理// 2.1客户端信息存储uint16_t clientport ntohs(client.sin_port); // 客户端端口号char clientip[32];inet_ntop(AF_INET, (client.sin_addr), clientip, sizeof(clientip)); // 客户端IPstd::cout Server accept clientip - clientport accept_socket from listen_sock_ success! std::endl;// 3.创建子进程pid_t id fork();if (id 0){// 创建子进程失败暂时不与当前客户端建立通信会话close(accept_socket);std::cerr Fork Fail! std::endl;}else if (id 0){// 子进程内close(listen_sock_); // 子进程不需要监听建议关闭// 执行业务处理函数Service(accept_socket, clientip, clientport);exit(0); // 子进程退出}else//父进程{// 父进程需要等待子进程pid_t ret waitpid(id, nullptr, 0); // 默认为阻塞式等待if (ret id)std::cout Wait id success!;}}}虽然此时成功创建了子进程但父进程处理连接请求仍然需要等待子进程退出后才能继续运行说白了就是 父进程现在处于阻塞等待状态还是会出现上面那种问题 还是出现了上面那个问题 因此父进程应该需要设置为 非阻塞等待
1.5.2.非阻塞等待版本
要是想父进程不阻塞等待其实有很多种方法
方式一通过参数设置为非阻塞等待不推荐方式二设置 SIGCHLD 信号的处理动作为子进程回收不是很推荐方式三忽略 SIGCHLD 信号推荐使用方式四设置孙子进程不是很推荐
我们接下来来一一学习。 方式一通过参数设置为非阻塞等待不推荐 这个完成起来就很简单了可以直接给 waitpid() 函数的参数3传递 WNOHANG表示当前为 非阻塞等待
pid_t ret waitpid(id, nullptr, WNOHANG); // 设置为非阻塞式等待也是可以正常通信 这里显示有3个进程 这种方法可行但不推荐原因如下虽然设置成了非阻塞式等待但父进程终究是需要通过 waitpid() 函数来尝试等待子进程倘若父进程一直卡在 accept() 函数处会导致子进程退出后暂时无人收尸进而导致资源泄漏 方式二设置 SIGCHLD 信号的处理动作为子进程回收不是很推荐 SIGCHLD信号的含义 简单的说子进程退出时父进程会收到一个SIGCHLD信号默认的处理动作是忽略这个信号也就是什么都不做。 我们知道我们可以使用signal函数来修改SIGCHLD信号的处理动作而常规的做法是在这个信号处理函数中调用wait函数获取子进程的退出状态。 我们知道unix中信号是采用异步处理某事的机制好比说你准备去做某事去之前跟邻居张三说如果李四来找你的话就通知他一声这让你可以抽身出来去做这件事而李四真正来访时会有人通知你这个就是异步信号一个较为形象的比喻。 一般的父进程在生成子进程之后会有两种情况
一是父进程继续去做别的事情类似上面举的例子另一是父进程啥都不做一直在wait子进程退出。
SIGCHLD信号就是为这第一种情况准备的它让父进程去做别的事情而只要父进程注册了处理该信号的函数在子进程退出时就会调用该函数在函数中wait子进程得到终止状态之后再继续做父进程的事情。
设置 SIGCHLD 信号的处理动作为 回收子进程后父进程就不必再考虑回收子进程的问题 注意 因为现在处于 TcpServer 类中handler() 函数需要设置为静态避免隐含的 this 指针避免不符合 signal() 函数中信号处理函数的参数要求 #include signal.h // 信号处理相关头文件// 需要设置为静态
static void handler(int signo)
{printf(进程 %d 捕捉到了 %d 号信号\n, getpid(), signo);// 这里的 1 表示父进程等待时只要是已经退出了的子进程都可以进行回收while (1){pid_t ret waitpid(-1, NULL, WNOHANG);if (ret 0)printf(父进程: %d 已经成功回收了 %d 号进程\n, getpid(), ret);elsebreak;}printf(子进程回收成功\n);
}// 启动服务器
void StartServer()
{// 设置 SIGCHLD 信号的处理动作signal(SIGCHLD, handler);while (!quit_){// ...// 3.创建子进程pid_t id fork();if(id 0){// 创建子进程失败暂时不与当前客户端建立通信会话close(accept_socket);std::cerr Fork Fail! std::endl;}else if(id 0){// 子进程内close(listen_sock_); // 子进程不需要监听建议关闭// 执行业务处理函数Service(accept_socket, clientip, clientport);exit(0); // 子进程退出}}
}我们来测试一下 为什么不是很推荐这种方法因为这种方法实现起来比较麻烦不如直接忽略 SIGCHLD 信号 方式三忽略 SIGCHLD 信号推荐使用 子进程在终止时会给父进程发生SIGCHLD信号17号信号该信号的默认处理动作是什么都不做这个时候父进程必须检测并回收子进程。 我们上面说过使用signal可以修改对信号的默认处理动作那么我们可以把这个默认处理动作修改成直接忽略该信号
就是下面这个
// 忽略 SIGCHLD 信号signal(SIGCHLD, SIG_IGN); 这个SIG_IGN是函数指针表示忽略信号。 上面这个语句将SIGCHLD信号17号信号的处理方式设为忽略这里的忽略是个特例只是父进程不对其进行处理转而由 init进程爷爷进程 对其负责自动清理资源并进行回收不会产生 僵尸进程省去了大量僵尸进程占用系统资源。(Linux Only) 直接在 StartServer() 服务器启动函数刚开始时使用 signal() 函数设置 SIGCHLD 信号的执行动作为 忽略 忽略了该信号后就不需要父进程等待子进程退出了由操作系统承担
#include signal.h // 信号处理相关头文件// 启动服务器
void StartServer()
{// 忽略 SIGCHLD 信号signal(SIGCHLD, SIG_IGN);while (!quit_){// ...// 3.创建子进程pid_t id fork();if(id 0){// 创建子进程失败暂时不与当前客户端建立通信会话close(sock);std::cerr Fork Fail! std::endl;}else if(id 0){// 子进程内close(listensock_); // 子进程不需要监听建议关闭// 执行业务处理函数Service(sock, clientip, clientport);exit(0); // 子进程退出}}
}我们连接 我们断开连接 我们发现子进程没有变僵尸进程很完美。 方式四设置孙子进程不是很推荐 众所周知父进程只需要对子进程负责至于孙子进程交给子进程负责如果某个子进程的父进程终止运行了那么它就会变成 孤儿进程父进程会变成 1 号进程也就是由操作系统领养回收进程的重担也交给了操作系统 可以利用该特性在子进程内部再创建一个子进程孙子进程然后子进程退出父进程可以直接回收不必阻塞子进程孙子进程的父进程变成 1 号进程
这种实现方法比较巧妙而且与我们后面即将学到的 守护进程 有关
注意 使用这种方式时父进程是需要等待子进程退出的
// 启动服务器
void StartServer()
{while (!quit_){// ...// 3.创建子进程pid_t id fork();if(id 0){// 创建子进程失败暂时不与当前客户端建立通信会话close(sock);std::cerr Fork Fail! std::endl;}else if(id 0){// 子进程内close(listensock_); // 子进程不需要监听建议关闭// 再创建孙子进程if(fork() 0)exit(0); // 孙子进程创建成功的话子进程退出由父进程接受孙子进程// 执行业务处理函数Service(sock, clientip, clientport);exit(0); // 子进程退出}else{// 父进程需要等待子进程pid_t ret waitpid(id, nullptr, 0);if(ret id)std::cout Wait id success!;}}
}这种方法代码也很简单但依旧不推荐因为倘若连接请求变多会导致孤儿进程变多孤儿进程由操作系统接管数量变多会给操作系统带来负担
以上就是设置 非阻塞 的四种方式推荐使用方式二忽略 SIGCHLD 信号
至此我们的 字符串回响程序 可以支持多客户端了 1.5.3.服务端源代码
这里补充一个点当子进程取走 sock 套接字进行网络通信后父进程就不需要使用 sock 套接字了可以将其进行关闭下次连接时继续使用避免文件描述符不断增长
// 启动服务器
void StartServer()
{// 忽略 SIGCHLD 信号signal(SIGCHLD, SIG_IGN);while (!quit_){// 1.处理连接请求// ...// 2.如果连接失败继续尝试连接// ...// 连接成功获取客户端信息// ...// 3.创建子进程// ...close(accept_socket); // 父进程不再需要资源建议关闭}
}这个补丁可以减少资源消耗建议加上前面是忘记加了并且不太好修改server.hpp 服务器头文件完整代码如下
#pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#include cstring
#include unistd.h
#include functional
#include unistd.h
#include sys/wait.h
#include signal.h // 信号处理相关头文件namespace nt_server
{const uint16_t default_port 8877; // 默认端口号const std::string default_ip 0.0.0.0; // 默认IPconst int backlog 5; // 请求队列的最大长度using func_t std::functionstd::string(std::string); // 回调函数类型enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR};class TcpServer{public:TcpServer(const func_t func, const uint16_t port default_port, const std::string ip default_ip): ip_(ip), port_(port), func_(func) // 注意这里要传1个业务处理函数{}~TcpServer(){}// 初始化服务器void InitServer(){// 1.创建套接字listen_sock_ socket(AF_INET, SOCK_STREAM, 0);if (listen_sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Socket Success! listen_sock_ std::endl;// 2.绑定IP地址与端口号struct sockaddr_in local;memset(local, 0, sizeof(local)); // 清零local.sin_family AF_INET; // 网络local.sin_addr.s_addr inet_addr(default_ip.c_str()); // 我设置为默认绑定任意可用IP地址local.sin_port htons(port_); // 我设置为默认是8877if (bind(listen_sock_, (const sockaddr *)local, sizeof(local)) 0){std::cout Bind IPPort Fail: strerror(errno) std::endl;exit(BIND_ERR);}if (listen(listen_sock_, backlog) 0){perror(Listen fail);exit(LIS_ERR);}}// 启动服务器void StartServer(){// 忽略 SIGCHLD 信号signal(SIGCHLD, SIG_IGN);for (;;){// 1.获取新连接struct sockaddr_in client;socklen_t len sizeof(client);int accept_socket accept(listen_sock_, (struct sockaddr *)client, len);if (accept_socket 0){std::cout accept failed std::endl;continue;}// 2.业务处理// 2.1客户端信息存储uint16_t clientport ntohs(client.sin_port); // 客户端端口号char clientip[32];inet_ntop(AF_INET, (client.sin_addr), clientip, sizeof(clientip)); // 客户端IPstd::cout Server accept clientip - clientport accept_socket from listen_sock_ success! std::endl;// 3.创建子进程pid_t id fork();if (id 0){// 创建子进程失败暂时不与当前客户端建立通信会话close(accept_socket);std::cerr Fork Fail! std::endl;}else if (id 0){// 子进程内close(listen_sock_); // 子进程不需要监听建议关闭// 执行业务处理函数Service(accept_socket, clientip, clientport);exit(0); // 子进程退出}close(accept_socket); // 父进程不再需要资源建议关闭}}// 通信服务业务处理void Service(int sock, const std::string clientip, const uint16_t clientport){char buff[1024];std::string who clientip - std::to_string(clientport);while (true){ssize_t n read(sock, buff, sizeof(buff) - 1); // 预留 \0 的位置if (n 0){// 读取成功buff[n] \0;std::cout Server get: buff from who std::endl;std::string respond func_(buff); // 实际业务处理由上层指定// 发送给服务器write(sock, buff, strlen(buff));}else if (n 0){// 表示当前读取到文件末尾了结束读取std::cout Client who sock quit! std::endl;close(sock); // 关闭文件描述符break;}else{// 读取出问题暂时std::cerr Read Fail! strerror(errno) std::endl;close(sock); // 关闭文件描述符break;}}}private:int listen_sock_; // socket套接字uint16_t port_; // 端口号std::string ip_; // ip地址func_t func_; // 业务处理函数};
}
1.6.多线程版本服务器
从内核的观点看
进程的目的就是担当分配系统资源CPU时间、内存等的基本单位。线程是进程的一个执行流是CPU调度和分派的基本单位它是比进程更小的能独立运行的基本单位。
线程它们彼此之间使用相同的地址空间共享大部分数据启动一个线程所花费的空间远远小于启动一个进程所花费的空间
而且线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。
据统计总的说来一个进程的开销大约是一个线程开销的30倍左右当然在具体的系统上这个数据可能会有较大的区别。
由于我们的多进程消耗的资源太大了我们可以使用多线程版本
1.6.1.使用原生线程库
我们使用我们的线程处理函数 由于我们创建线程是用来提供服务的而服务端的业务中有一个Service()它需要我们的线程去传入 Service() 函数中的所有参数同时也需要具备调用 Service() 业务处理函数的能力我们只能把Service() 函数中的所有参数和this指针传进去而这单凭一个 void* 的参数是无法解决的为此我们可以创建一个类里面可以包含我们所需要的参数——Service() 函数中的所有参数和this指针
// 包含我们所需参数的类型
class ThreadData
{
public:ThreadData(int sock, const std::string ip, const uint16_t port, TcpServer* ptr):sock_(sock), clientip_(ip), clientport_(port), current_(ptr){}// 设置为公有是为了方便访问
public:int sock_;std::string clientip_;uint16_t clientport_;TcpServer* current_; // 指向 TcpServer 对象的指针
};接下来就可以考虑如何借助多线程了 线程创建后需要关闭不必要的 socket 套接字吗 不需要线程之间是可以共享这些资源的无需关闭 如何设置主线程不必等待次线程退出 可以把次线程进行分离 所以接下来我们需要在连接成功后创建次线程利用已有信息构建 ThreadData 对象为次线程编写回调函数最终目的是为了执行 Service() 函数 注意 因为当前在类中线程的回调函数需要使用 static 设置为静态函数 server.hpp #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#include cstring
#include unistd.h
#include functional
#include unistd.h
#include sys/wait.h
#include signal.h // 信号处理相关头文件
#includepthread.hnamespace nt_server
{const uint16_t default_port 8877; // 默认端口号const std::string default_ip 0.0.0.0; // 默认IPconst int backlog 5; // 请求队列的最大长度enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR};class TcpServer; // 前置声明// 包含我们所需参数的类型class ThreadData{public:ThreadData(int sock, const std::string ip, const uint16_t port, TcpServer* ptr):sock_(sock), clientip_(ip), clientport_(port), current_(ptr){}// 设置为公有是为了方便访问public:int sock_;std::string clientip_;uint16_t clientport_;TcpServer* current_; // 指向 TcpServer 对象的指针};using func_t std::functionstd::string(std::string); // 回调函数类型class TcpServer{public:TcpServer(const func_t func, const uint16_t port default_port, const std::string ip default_ip): ip_(ip), port_(port), func_(func) // 注意这里要传1个业务处理函数{}~TcpServer(){}// 初始化服务器void InitServer(){// 1.创建套接字listen_sock_ socket(AF_INET, SOCK_STREAM, 0);if (listen_sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Socket Success! listen_sock_ std::endl;// 2.绑定IP地址与端口号struct sockaddr_in local;memset(local, 0, sizeof(local)); // 清零local.sin_family AF_INET; // 网络local.sin_addr.s_addr inet_addr(default_ip.c_str()); // 我设置为默认绑定任意可用IP地址local.sin_port htons(port_); // 我设置为默认是8877if (bind(listen_sock_, (const sockaddr *)local, sizeof(local)) 0){std::cout Bind IPPort Fail: strerror(errno) std::endl;exit(BIND_ERR);}if (listen(listen_sock_, backlog) 0){perror(Listen fail);exit(LIS_ERR);}}// 启动服务器void StartServer(){// 忽略 SIGCHLD 信号signal(SIGCHLD, SIG_IGN);for (;;){// 1.获取新连接struct sockaddr_in client;socklen_t len sizeof(client);int accept_socket accept(listen_sock_, (struct sockaddr *)client, len);if (accept_socket 0){std::cout accept failed std::endl;continue;}// 2.业务处理// 2.1客户端信息存储uint16_t clientport ntohs(client.sin_port); // 客户端端口号char clientip[32];inet_ntop(AF_INET, (client.sin_addr), clientip, sizeof(clientip)); // 客户端IPstd::cout Server accept clientip - clientport accept_socket from listen_sock_ success! std::endl;// 3.创建线程及所需要的线程信息类ThreadData* td new ThreadData(accept_socket, clientip, clientport, this);pthread_t p;pthread_create(p, nullptr, Routine, td);}}// 线程回调函数static void* Routine(void* args){// 线程分离pthread_detach(pthread_self());ThreadData* td static_castThreadData*(args);// 调用业务处理函数td-current_-Service(td-sock_, td-clientip_, td-clientport_);// 销毁对象delete td;return (void*)0;}// 通信服务业务处理void Service(int sock, const std::string clientip, const uint16_t clientport){char buff[1024];std::string who clientip - std::to_string(clientport);while (true){ssize_t n read(sock, buff, sizeof(buff) - 1); // 预留 \0 的位置if (n 0){// 读取成功buff[n] \0;std::cout Server get: buff from who std::endl;std::string respond func_(buff); // 实际业务处理由上层指定// 发送给服务器write(sock, buff, strlen(buff));}else if (n 0){// 表示当前读取到文件末尾了结束读取std::cout Client who sock quit! std::endl;close(sock); // 关闭文件描述符break;}else{// 读取出问题暂时std::cerr Read Fail! strerror(errno) std::endl;close(sock); // 关闭文件描述符break;}}}private:int listen_sock_; // socket套接字uint16_t port_; // 端口号std::string ip_; // ip地址func_t func_; // 业务处理函数};
}
因为当前使用了 原生线程库所以在编译时需要加上 -lpthread makefile .PHONY:all
all:server clientserver:server.ccg -o $ $^ -stdc11 -lpthreadclient:client.ccg -o $ $^ -stdc11 -lpthread.PHONY:clean
clean:rm -rf server client
接下来就是编译并运行程序可以看到 当前只有一个进程同时有两个线程在运行 1.6.1.线程池版本 上面那个版本其实有点问题连接都准备好了才创建线程如果创建线程所需要的资源较多会拖慢服务器整体连接效率
如果每来一个用户我们就得创建一个线程那么当来了很多用户就会消耗很多资源。
我们不想等到客户来了才创建我们的线程我们可以提前创建好
我们不提供死循环服务
为此可以改用之前实现的 线程池我们把那个线程池的代码拿过来 ThreadPool.hpp #pragma once#include iostream
#include vector
#include string
#include queue
#include pthread.h
#include unistd.h// 线程信息结构体
struct ThreadInfo
{pthread_t tid; // 线程IDstd::string name; // 线程名称
};// 默认线程数量
static const int defalutnum 5;// 线程池模板类
template class T
class ThreadPool
{
private:// 互斥锁加锁函数void Lock(){pthread_mutex_lock(mutex_);}// 互斥锁解锁函数void Unlock(){pthread_mutex_unlock(mutex_);}// 唤醒等待的线程void Wakeup(){pthread_cond_signal(cond_);}// 线程休眠等待条件变量void ThreadSleep(){pthread_cond_wait(cond_, mutex_);}// 判断任务队列是否为空bool IsQueueEmpty(){return tasks_.empty();}// 根据线程ID获取线程名称std::string GetThreadName(pthread_t tid){for (const auto ti : threads_){if (ti.tid tid)return ti.name;}return None;}public:// 线程处理任务的函数static void *HandlerTask(void *args){ThreadPoolT *tp static_castThreadPoolT *(args);std::string name tp-GetThreadName(pthread_self());while (true){tp-Lock();while (tp-IsQueueEmpty()){tp-ThreadSleep();}T t tp-Pop();tp-Unlock();t.Run();}}// 启动线程池中的所有线程void Start(){int num threads_.size();for (int i 0; i num; i){threads_[i].name thread- std::to_string(i 1);pthread_create((threads_[i].tid), nullptr, HandlerTask, this);}}// 从任务队列中取出一个任务T Pop(){T t tasks_.front();tasks_.pop();return t;}// 向任务队列中添加一个任务void Push(const T t){Lock();tasks_.push(t);Wakeup();Unlock();}// 获取线程池单例对象static ThreadPoolT *GetInstance(){if (nullptr tp_) // 如果线程池对象不存在则创建一个新的线程池对象{pthread_mutex_lock(lock_); // 加锁保证线程安全if (nullptr tp_) // 再次检查是否已经创建了线程池对象防止多线程环境下的竞争条件{std::cout log: singleton create done first! std::endl;tp_ new ThreadPoolT(); // 创建线程池对象}pthread_mutex_unlock(lock_); // 解锁}return tp_; // 返回线程池对象指针}private:// 构造函数初始化线程池可以指定线程数量默认为defalutnumThreadPool(int num defalutnum) : threads_(num){pthread_mutex_init(mutex_, nullptr); // 初始化互斥锁pthread_cond_init(cond_, nullptr); // 初始化条件变量}// 析构函数销毁线程池资源~ThreadPool(){pthread_mutex_destroy(mutex_); // 销毁互斥锁pthread_cond_destroy(cond_); // 销毁条件变量}// 禁止拷贝构造和赋值操作符确保线程池对象的单一性ThreadPool(const ThreadPoolT ) delete;const ThreadPoolT operator(const ThreadPoolT ) delete; // abc
private:// 线程信息列表std::vectorThreadInfo threads_;// 任务队列std::queueT tasks_;// 互斥锁和条件变量用于同步和通信pthread_mutex_t mutex_;pthread_cond_t cond_;// 线程池单例对象指针和互斥锁静态成员变量static ThreadPoolT *tp_;static pthread_mutex_t lock_;
};// 初始化线程池单例对象指针和互斥锁静态成员变量
template class T
ThreadPoolT *ThreadPoolT::tp_ nullptr;
template class T
pthread_mutex_t ThreadPoolT::lock_ PTHREAD_MUTEX_INITIALIZER;
为了使用上面这个线程池我们很快就能写出下面这些代码 // 启动服务器void StartServer(){.......//线程池的设计--》使用之前必须先启动ThreadPoolTask::GetInstance()-Start();for (;;){......// 3.把任务交给线程池Task task1(accept_socket,clientip,clientport);ThreadPoolTask::GetInstance()-Push(task1);}}
这里提一点 我创建task1的时候为什么传这3个参数 我创建task1是为了把任务交给线程池但是我们的任务是什么是这个Server函数 大家可以回去看看server.hpp看看Server函数的参数就明白了。 接下来就要设计我们的Task类了 Task.hpp #pragma once#include iostream//任务类
class Task
{
public:Task(int sockfd, const std::string clientip, const uint16_t clientport):sockfd_(sockfd),clientip_(clientip),clientport_(clientport){}~Task(){}void Run()//因为我们的线程池要求Task类必须含有Run函数{ }private:int sockfd_;std::string clientip_;uint16_t clientport_;
};
这里提一下我们创建了Task.hpp那么原来server.hpp的Server函数和线程回调函数就可以删除了 Task.hpp完全体 #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#include cstring
#include unistd.h
#include functional
#include unistd.h
#include sys/wait.h
#includepthread.husing func_t std::functionstd::string(std::string); // 回调函数类型// 任务类
class Task
{
public:Task(int sockfd, const std::string clientip, const uint16_t clientport,const func_t func): sockfd_(sockfd), clientip_(clientip), clientport_(clientport), func_2(func) // 注意这里要传1个业务处理函数{}~Task(){}void Run(){char buff[1024];std::string who clientip_ - std::to_string(clientport_);//while (true),如果线程池的线程一直循环在干这件事的话效率会极其低下ssize_t n read((sockfd_),buff, sizeof(buff)- 1); // 预留 \0 的位置if (n 0){// 读取成功buff[n] \0;std::cout Server get: buff from who std::endl;std::string respond func_2(buff); // 实际业务处理由上层指定// 发送给服务器write(sockfd_, buff, strlen(buff));}else if (n 0){// 表示当前读取到文件末尾了结束读取std::cout Client who sockfd_ quit! std::endl;close(sockfd_); // 关闭文件描述符 }else{// 读取出问题暂时std::cerr Read Fail! strerror(errno) std::endl;close(sockfd_); // 关闭文件描述符}}private:int sockfd_;//accept返回的套接字std::string clientip_;//用户IPuint16_t clientport_;//用户端口号func_t func_2; // 业务处理函数
}; 大家注意到了没有其实这个Run就是之前的Server函数只不过有一些小改动那就是while死循环没有了这是因为我们这次使用的是线程池线程池的线程个数是有限的如果写死循环的话那么就只能提供少量连接服务了。所以我们把死循环去掉了注意最后要关闭sockfd_哦 此外我们为了解耦引入了回调函数这样子就能将业务处理分离。 server.cc #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#include cstring
#include unistd.h
#include functional
#include unistd.h
#include sys/wait.h
#includepthread.h
#includeThreadpool.hpp
#includeTask.hppnamespace nt_server
{const uint16_t default_port 8877; // 默认端口号const std::string default_ip 0.0.0.0; // 默认IPconst int backlog 5; // 请求队列的最大长度enum{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR};class TcpServer; // 前置声明// 包含我们所需参数的类型class ThreadData{public:ThreadData(int sock, const std::string ip, const uint16_t port, TcpServer* ptr):sock_(sock), clientip_(ip), clientport_(port), current_(ptr){}// 设置为公有是为了方便访问public:int sock_;std::string clientip_;uint16_t clientport_;TcpServer* current_; // 指向 TcpServer 对象的指针};using func_t std::functionstd::string(std::string); // 回调函数类型class TcpServer{public:TcpServer(const func_t func, const uint16_t port default_port, const std::string ip default_ip): ip_(ip), port_(port), func_1(func) // 注意这里要传1个业务处理函数{}~TcpServer(){}// 初始化服务器void InitServer(){// 1.创建套接字listen_sock_ socket(AF_INET, SOCK_STREAM, 0);if (listen_sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Socket Success! listen_sock_ std::endl;// 2.绑定IP地址与端口号struct sockaddr_in local;memset(local, 0, sizeof(local)); // 清零local.sin_family AF_INET; // 网络local.sin_addr.s_addr inet_addr(default_ip.c_str()); // 我设置为默认绑定任意可用IP地址local.sin_port htons(port_); // 我设置为默认是8877if (bind(listen_sock_, (const sockaddr *)local, sizeof(local)) 0){std::cout Bind IPPort Fail: strerror(errno) std::endl;exit(BIND_ERR);}if (listen(listen_sock_, backlog) 0){perror(Listen fail);exit(LIS_ERR);}}// 启动服务器void StartServer(){for (;;){//线程池的设计--》使用之前必须先启动ThreadPoolTask::GetInstance()-Start();// 1.获取新连接struct sockaddr_in client;socklen_t len sizeof(client);int accept_socket accept(listen_sock_, (struct sockaddr *)client, len);if (accept_socket 0){std::cout accept failed std::endl;continue;}// 2.业务处理// 2.1客户端信息存储uint16_t clientport ntohs(client.sin_port); // 客户端端口号char clientip[32];inet_ntop(AF_INET, (client.sin_addr), clientip, sizeof(clientip)); // 客户端IPstd::cout Server accept clientip - clientport accept_socket from listen_sock_ success! std::endl;// 3.把任务交给线程池Task task1(accept_socket,clientip,clientport,func_1);//和原来Server函数的参数差不多这里还多传了一个回调函数ThreadPoolTask::GetInstance()-Push(task1);}}private:int listen_sock_; // socket套接字uint16_t port_; // 端口号std::string ip_; // ip地址func_t func_1; // 业务处理函数};
} server.cc #include string
#include vector
#include memory // 智能指针相关头文件
#include cstdio
#include server.hppusing namespace std;
using namespace nt_server;// 业务处理回调函数字符串回响
string echo(string request)
{return request;
}void Usage(const char* program)
{cout Usage: endl;cout \t program ServerPort endl;
}int main(int argc, char* argv[])
{if (argc ! 2){// 错误的启动方式提示错误信息Usage(argv[0]);return USAGE_ERR;}//命令行参数都是字符串我们需要将其转换成对应的类型uint16_t port stoi(argv[1]);//将字符串转换成端口号unique_ptrTcpServer usvr (new TcpServer(echo,port));usvr-InitServer();usvr-StartServer();return 0;
}我们可以检测一下 ps -aL | head -1 ps -aL | grep server 可以看到一启动就有6个线程——一个主线程5个是线程池里面的
我们连接看看 我们发现我们发送第一条信息是正常的但是发第二条信息的时候没有成功直接告诉我说断开连接了。
这个其实是正常的。因为我们也没有提供常服务因为资源是有有限的。
1.7.守护进程版服务器
1.7.1.守护进程 Daemon
守护进程是一种长期运行的进程守护进程的生存期不一定长但一般应该这样做一般是操作系统启动的时候它就启动操作系统关闭的时候它才关闭。
守护进程跟终端无关联也就是说它们没有控制终端所以控制终端退出也不会导致守护进程退出。
守护进程是在后台运行的不会占着终端终端可以执行其他命令。
守护进程是运行在后台的一种特殊进程它独立于控制终端并且周期性地执行某种任务或循环等待处理某些事件的发生它不需要用户输入就能运行而且提供某种服务不是对整个系统就是对某个用户程序提供服务。Linux系统的大多数服务器就是通过守护进程实现的。守护进程一般在系统启动时开始运行除非强行终止否则直到系统关机才随之一起停止运行守护进程一般都以root用户权限运行因为要使用某些特殊的端口1-1024或者资源守护进程的父进程一般都是init进程因为它真正的父进程在fork出守护进程后就直接退出了所以守护进程都是孤儿进程由init接管守护进程是非交互式程序没有控制终端所以任何输出无论是向标准输出设备stdout还是标准出错设备stderr的输出都需要特殊处理。守护进程的名称通常以d结尾比如sshd、xinetd、crond等 注意 1.守护进程是一个生存周期较长的进程通常独立于控制终端并且周期性的执行某种任务或者等待处理某些待发生的事件2.大多数服务都是通过守护进程实现的3.关闭终端相应的进程都会被关闭而守护进程却能够突破这种限制 守护进程不会收到来自内核的 SIGHUP 信号也就是说如果守护进程收到了 SIGHUP 信号那么肯定是另外的进程发的。
很多守护进程把 SIGHUP 信号作为通知信号表示配置文件已经发生改动守护进程应该重新读入其配置文件。
守护进程不会收到来自内核的 SIGINT 信号CtrlC)、SIGWINCH 信号终端窗口大小改变。 1.7.2.进程组 还记得ps指令上面这些是什么吗 这个进程组是什么 顾名思义进程组就是一个或多个进程的集合。这些进程并不是孤立的他们彼此之间或者存在父子、兄弟关系或者在功能上有相近的联系。每个进程都有父进程而所有的进程以init进程为根形成一个树状结构。 那为啥Linux里要有进程组呢 其实提供进程组就是为了方便对进程进行管理。假设要完成一个任务需要同时并发100个进程。当用户处于某种原因要终止 这个任务时要是没有进程组就需要手动的一个个去杀死这100个进程并且必须要严格按照进程间父子兄弟关系顺序否则会扰乱进程树。有了进程组就可以将这100个进程设置为一个进程组它们共有1个组号pgrp并且有选取一个进程作为组长通常是“辈分”最高的那个通常该进程的ID也就作为进程组的ID。现在就可以通过杀死整个进程组来关闭这100个进程并且是严格有序的。组长进程可以创建一个进程组创建该组中的进程然后终止。只要在某个进程组中一个进程存在则该进程组就存在这与其组长进程是否终止无关。 进程必定属于一个进程组也只能属于一个进程组。 一个进程组中可以包含多个进程。 进程组的生命周期从被创建开始到其内所有进程终止或离开该组。 内核中sys_getpgrp()系统调用用来获取当前进程所在进程组号 修改进程组ID的接口如下 int setpgid(pid_t pid, pid_t pgid); 这个函数的含义是找到进程ID为pid的进程将其进程组ID修改为pgid如果pid的值为0则表示要修改调用进程的进程组ID。该接口一般用来创建一个新的进程组。 1.7.2.作业 Shell分前后台来控制的不是进程而是作业Job或者进程组Process Group。一个前台作业可以由多个进程组成一个后台也可以由多个进程组成Shell可以运行一个前台作业和任意多个后台作业这称为作业控制。 作业与进程组的区别如果作业中的某个进程又创建了子进程则子进程不属于作业。一旦作业运行结束Shell就把自己提到前台如果原来的前台进程还存在如果这个子进程还没终止它自动变为后台进程组。 一个或多个进程组的集合比如用户从登陆到退出这个期间用户运行的所有进程都属于该会话周期 1.7.3.会话 再看下会话。由于Linux是多用户多任务的分时系统所以必须要支持多个用户同时使用一个操作系统。当一个用户登录一次系统就形成一次会话 。一个会话可包含多个进程组但只能有一个前台进程组。每个会话都有一个会话首领leader即创建会话的进程。 sys_setsid()调用能创建一个会话。 #include unistd.h
pid_t setsid(void); 如果这个函数的调用进程不是进程组组长那么调用该函数会发生以下事情 1创建一个新会话会话ID等于进程ID调用进程成为会话的首进程。2创建一个进程组进程组ID等于进程ID调用进程成为进程组的组长。3该进程没有控制终端如果调用setsid前该进程有控制终端这种联系就会断掉。 调用setsid函数的进程不能是进程组的组长否则调用会失败返回-1并置errno为EPERM。 这个限制是比较合理的。如果允许进程组组长迁移到新的会话而进程组的其他成员仍然在老的会话中那么就会出现同一个进程组的进程分属不同的会话之中的情况这就破坏了进程组和会话的严格的层次关系了。 必须注意的是只有当前进程不是进程组的组长时才能创建一个新的会话。调用setsid 之后该进程成为新会话的leader。 一个会话可以有一个控制终端。这通常是登陆到其上的终端设备在终端登陆情况下或伪终端设备在网络登陆情况下。建立与控制终端连接的会话首进程被称为控制进程。一个会话中的几个进程组可被分为一个前台进程组以及一个或多个后台进程组。所以一个会话中应该包括控制进程会话首进程一个前台进程组和任意后台进程组。 我们使用 XShell 等工具登录 Linux 服务器时会在服务器中创建一个 会话bash可以在该会话内创建 进程当 进程 间有关系时构成一个 进程组组长 进程的 PID 就是该 进程组 的 PGID Linux 中的登录操作实际上就是创建了一个会话Windows 中也是如此当你的 Windows 变卡时可以使用 [注销] 按钮结束整个会话重新登录电脑就会流畅如初 1.7.5.控制终端 会话的领头进程打开一个终端之后, 该终端就成为该会话的控制终端 (SVR4/Linux) 例如上面就是4个终端。4个终端登陆的都是同一个账号。 与控制终端建立连接的会话领头进程称为控制进程 (session leader) 一个会话可以有一个控制终端。这通常是登陆到其上的终端设备在终端登陆情况下或伪终端设备在网络登陆情况下。建立与控制终端连接的会话首进程被称为控制进程。 产生在控制终端上的输入和信号将发送给会话的前台进程组中的所有进程 终端上的连接断开时 (比如网络断开或 Modem 断开), 挂起信号将发送到控制进程(session leader) 进程属于一个进程组进程组属于一个会话会话可能有也可能没有控制终端。一般而言当用户在某个终端上登录时一个新的会话就开始了。进程组由组中的领头进程标识领头进程的进程标识符就是进程组的组标识符。类似地每个会话也对应有一个领头进程。 同一会话中的进程通过该会话的领头进程和一个终端相连该终端作为这个会话的控制终端。一个会话只能有一个控制终端而一个控制终端只能控制一个会话。用户通过控制终端可以向该控制终端所控制的会话中的进程发送键盘信号。 同一会话中只能有一个前台进程组属于前台进程组的进程可从控制终端获得输入而其他进程均是后台进程可能分属于不同的后台进程组。 当我们打开多个终端窗口时实际上就创建了多个终端会话。每个会话都会有自己的前台工作和后台工作。 Linux 中一切皆文件终端文件也是如此这里的终端其实就是当前 bash 输出结果时使用的文件也就是屏幕终端文件位于 dev/pts 目录下如果向指定终端文件中写入数据那么对方也可以直接收到 (关联终端文件说白了就是打开了文件一方写一方读不就是管道吗)
1.7.6.创建守护进程的过程 创建守护进程的过程 1fork()创建子进程父进程exit()退出 这是创建守护进程的第一步。由于守护进程是脱离控制终端的因此完成第一步后就会在Shell终端里造成程序已经运行完毕的假象。之后的所有工作都在子进程中完成而用户在Shell终端里则可以执行其他命令从而在形式上做到了与控制终端的脱离在后台工作。 2在子进程中调用 setsid() 函数创建新的会话 在调用了fork()函数后子进程全盘拷贝了父进程的会话期、进程组、控制终端等虽然父进程退出了但会话期、进程组、控制终端等并没有改变因此这还不是真正意义上的独立开来而 setsid() 函数能够使进程完全独立出来。 3再次 fork() 一个孙进程并让子进程退出 为什么要再次fork呢假定有这样一种情况之前的父进程fork出子进程以后还有别的事情要做在做事情的过程中因为某种原因阻塞了而此时的子进程因为某些非正常原因要退出的话就会形成僵尸进程所以由子进程fork出一个孙进程以后立即退出孙进程作为守护进程会被init接管此时无论父进程想做什么都随它了。 4在孙进程中调用 chdir() 函数让根目录 ”/” 成为孙进程的工作目录 这一步也是必要的步骤使用fork创建的子进程继承了父进程的当前工作目录。由于在进程运行中当前目录所在的文件系统如“/mnt/usb”是不能卸载的这对以后的使用会造成诸多的麻烦比如系统由于某种原因要进入单用户模式。因此通常的做法是让/作为守护进程的当前工作目录这样就可以避免上述的问题当然如有特殊需要也可以把当前工作目录换成其他的路径如/tmp改变工作目录的常见函数是chdir。 5在孙进程中调用 umask() 函数设置进程的文件权限掩码为0 文件权限掩码是指屏蔽掉文件权限中的对应位。比如有个文件权限掩码是050它就屏蔽了文件组拥有者的可读与可执行权限。由于使用fork函数新建的子进程继承了父进程的文件权限掩码这就给该子进程使用文件带来了诸多的麻烦。因此把文件权限掩码设置为0可以大大增强该守护进程的灵活性。设置文件权限掩码的函数是umask。在这里通常的使用方法为umask(0)。 6在孙进程中关闭任何不需要的文件描述符 同文件权限码一样用fork函数新建的子进程会从父进程那里继承一些已经打开了的文件。这些被打开的文件可能永远不会被守护进程读写但它们一样消耗系统资源而且可能导致所在的文件系统无法卸下。 在上面的第2)步之后守护进程已经与所属的控制终端失去了联系。因此从终端输入的字符不可能达到守护进程守护进程中用常规方法如printf输出的字符也不可能在终端上显示出来。所以文件描述符为0、1和2 的3个文件常说的输入、输出和报错已经失去了存在的价值也应被关闭。 7守护进程退出处理 当用户需要外部停止守护进程运行时往往会使用 kill 命令停止该守护进程。所以守护进程中需要编码来实现 kill 发出的signal信号处理达到进程的正常退出。 一张简单的图可以完美诠释之前几个步骤 1.7.7.直接调用系统现成的接口
使用daemon()函数可以简化守护进程的创建过程。daemon()函数是一个库函数用于将当前进程转换为守护进程。该函数的原型如下
#include unistd.hint daemon(int nochdir, int noclose);参数说明
nochdir如果该参数为0则将当前工作目录更改为根目录如果为1则不更改当前工作目录。noclose如果该参数为0则关闭所有与终端相关的文件描述符如果为1则不关闭文件描述符。
一般情况下daemon() 函数的两个参数都只需要传递 0默认工作在 / 路径下默认重定向至 /dev/null /dev/null 就像是一个 黑洞可以把所有数据都丢入其中相当于丢弃数据 我们怎么改装我们的代码呢其实特别简单 server.cc 服务器源文件 #include string
#include vector
#include memory // 智能指针相关头文件
#include cstdio
#include server.hppusing namespace std;
using namespace nt_server;// 业务处理回调函数字符串回响
string echo(string request)
{return request;
}void Usage(const char* program)
{cout Usage: endl;cout \t program ServerPort endl;
}int main(int argc, char* argv[])
{if (argc ! 2){// 错误的启动方式提示错误信息Usage(argv[0]);return USAGE_ERR;}// 直接守护进程化daemon(0, 0);//命令行参数都是字符串我们需要将其转换成对应的类型uint16_t port stoi(argv[1]);//将字符串转换成端口号unique_ptrTcpServer usvr (new TcpServer(echo,port));usvr-InitServer();usvr-StartServer();return 0;
}
只要在这里调用就行了。特别简单 现在服务器启动后会自动变成 后台进程并且自成一个 新会话归操作系统管守护进程 本质上是一种比较坚强的 孤儿进程 我们连接看看 我们发现现在是可以通信的。 注意 现在标准输出、标准错误都被重定向至 /dev/null 中了之前向屏幕输出的数据现在都会直接被丢弃如果想保存数据可以选择使用日志 我们可以使用kill -9把这个守护进程杀了
1.7.7.自己创建守护进程版本的服务器
手动实现守护进程时需要注意以下几点
忽略异常信号0、1、2 要做特殊处理文件描述符进程的工作路径可能要改变从用户目录中脱离至根目录
具体实现步骤如下
1、忽略常见的异常信号SIGPIPE、SIGCHLD2、如何保证自己不是组长 创建子进程 成功后父进程退出子进程变成守护进程3、新建会话自己成为会话的 话首进程4、可选更改守护进程的工作路径chdir5、处理后续对于 0、1、2 的问题
对于 标准输入、标准输出、标准错误 的处理方式有两种
暴力处理直接关闭 fd优雅处理将 fd 重定向至 /dev/null也就是 daemon() 函数的做法 Daemon.hpp 守护进程头文件 #pragma once#include iostream
#include cstring
#include cerrno
#include signal.h
#include unistd.h
#include sys/types.h
#include sys/stat.h
#include fcntl.h
#includeSign.hpp//存放了退出码等信息static const char *path /home/A;//设置守护进程的工作目录这里大家要自己设置啊void Daemon()
{// 1、忽略常见信号signal(SIGPIPE, SIG_IGN);signal(SIGCHLD, SIG_IGN);// 2、创建子进程自己退休pid_t id fork();if (id 0)exit(0);else if (id 0){// 子进程创建失败std::coutFork Fail: strerror(errno)std::endl;exit(FORK_ERR);}// 3、新建会话使自己成为一个单独的组pid_t ret setsid();if (ret -1){// 守护化失败std::coutSetsid Fail: strerror(errno)std::endl;exit(SETSID_ERR);}// 4、更改工作路径int n chdir(path);if (n -1){// 更改路径失败std::coutChdir Fail: strerror(errno)std::endl;exit(CHDIR_ERR);}// 5、重定向标准输入输出错误int fd open(/dev/null, O_RDWR);if (fd -1){// 文件打开失败std::coutOpen Fail: strerror(errno)std::endl;exit(OPEN_ERR);}// 重定向标准输入、标准输出、标准错误dup2(fd, 0);dup2(fd, 1);dup2(fd, 2);close(fd);
} StartServer() 服务器启动函数 — 位于 server.hpp 服务器头文件中的 TcpServer 类 #include Daemon.hpp// 启动服务器
void StartServer()
{// 守护进程化Daemon();// ...
}至此我们完成了
我们直接奉献上源代码 Daemon.hpp #pragma once#include iostream
#include cstring
#include cerrno
#include signal.h
#include unistd.h
#include sys/types.h
#include sys/stat.h
#include fcntl.henum
{USAGE_ERR 1,SOCKET_ERR,BIND_ERR,LIS_ERR,CONNECT_ERR,FORK_ERR,SETSID_ERR,CHDIR_ERR,OPEN_ERR
};
//因为这个头文件会被server.hpp包含server.hpp会被server.cc包含
//刚好这三个文件里都要使用这些退出码信息所以放在这里一次即可static const char *path /home/zs_108/A;//设置守护进程的工作目录这里大家要自己设置啊void Daemon()
{// 1、忽略常见信号signal(SIGPIPE, SIG_IGN);signal(SIGCHLD, SIG_IGN);// 2、创建子进程自己退休pid_t id fork();if (id 0)exit(0);else if (id 0){// 子进程创建失败std::coutFork Fail: strerror(errno)std::endl;exit(FORK_ERR);}// 3、新建会话使自己成为一个单独的组pid_t ret setsid();if (ret -1){// 守护化失败std::coutSetsid Fail: strerror(errno)std::endl;exit(SETSID_ERR);}// 4、更改工作路径int n chdir(path);if (n -1){// 更改路径失败std::coutChdir Fail: strerror(errno)std::endl;exit(CHDIR_ERR);}// 5、重定向标准输入输出错误int fd open(/dev/null, O_RDWR);if (fd -1){// 文件打开失败std::coutOpen Fail: strerror(errno)std::endl;exit(OPEN_ERR);}// 重定向标准输入、标准输出、标准错误dup2(fd, 0);dup2(fd, 1);dup2(fd, 2);close(fd);
} Task.hpp #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#include cstring
#include unistd.h
#include functional
#include unistd.h
#include sys/wait.h
#includepthread.husing func_t std::functionstd::string(std::string); // 回调函数类型// 任务类
class Task
{
public:Task(int sockfd, const std::string clientip, const uint16_t clientport,const func_t func): sockfd_(sockfd), clientip_(clientip), clientport_(clientport), func_2(func) // 注意这里要传1个业务处理函数{}~Task(){}void Run(){char buff[1024];std::string who clientip_ - std::to_string(clientport_);//while (true),如果线程池的线程一直循环在干这件事的话效率会极其低下ssize_t n read((sockfd_),buff, sizeof(buff)- 1); // 预留 \0 的位置if (n 0){// 读取成功buff[n] \0;std::cout Server get: buff from who std::endl;std::string respond func_2(buff); // 实际业务处理由上层指定// 发送给服务器write(sockfd_, buff, strlen(buff));}else if (n 0){// 表示当前读取到文件末尾了结束读取std::cout Client who sockfd_ quit! std::endl;close(sockfd_); // 关闭文件描述符 }else{// 读取出问题暂时std::cerr Read Fail! strerror(errno) std::endl;close(sockfd_); // 关闭文件描述符}close(sockfd_);//由于没有死循环我们必须将其关闭}private:int sockfd_;//accept返回的套接字std::string clientip_;//用户IPuint16_t clientport_;//用户端口号func_t func_2; // 业务处理函数
}; ThreadPool.hpp #pragma once#include iostream
#include vector
#include string
#include queue
#include pthread.h
#include unistd.h// 线程信息结构体
struct ThreadInfo
{pthread_t tid; // 线程IDstd::string name; // 线程名称
};// 默认线程数量
static const int defalutnum 5;// 线程池模板类
template class T
class ThreadPool
{
private:// 互斥锁加锁函数void Lock(){pthread_mutex_lock(mutex_);}// 互斥锁解锁函数void Unlock(){pthread_mutex_unlock(mutex_);}// 唤醒等待的线程void Wakeup(){pthread_cond_signal(cond_);}// 线程休眠等待条件变量void ThreadSleep(){pthread_cond_wait(cond_, mutex_);}// 判断任务队列是否为空bool IsQueueEmpty(){return tasks_.empty();}// 根据线程ID获取线程名称std::string GetThreadName(pthread_t tid){for (const auto ti : threads_){if (ti.tid tid)return ti.name;}return None;}public:// 线程处理任务的函数static void *HandlerTask(void *args){ThreadPoolT *tp static_castThreadPoolT *(args);std::string name tp-GetThreadName(pthread_self());while (true){tp-Lock();while (tp-IsQueueEmpty()){tp-ThreadSleep();}T t tp-Pop();tp-Unlock();t.Run();}}// 启动线程池中的所有线程void Start(){int num threads_.size();for (int i 0; i num; i){threads_[i].name thread- std::to_string(i 1);pthread_create((threads_[i].tid), nullptr, HandlerTask, this);}}// 从任务队列中取出一个任务T Pop(){T t tasks_.front();tasks_.pop();return t;}// 向任务队列中添加一个任务void Push(const T t){Lock();tasks_.push(t);Wakeup();Unlock();}// 获取线程池单例对象static ThreadPoolT *GetInstance(){if (nullptr tp_) // 如果线程池对象不存在则创建一个新的线程池对象{pthread_mutex_lock(lock_); // 加锁保证线程安全if (nullptr tp_) // 再次检查是否已经创建了线程池对象防止多线程环境下的竞争条件{std::cout log: singleton create done first! std::endl;tp_ new ThreadPoolT(); // 创建线程池对象}pthread_mutex_unlock(lock_); // 解锁}return tp_; // 返回线程池对象指针}private:// 构造函数初始化线程池可以指定线程数量默认为defalutnumThreadPool(int num defalutnum) : threads_(num){pthread_mutex_init(mutex_, nullptr); // 初始化互斥锁pthread_cond_init(cond_, nullptr); // 初始化条件变量}// 析构函数销毁线程池资源~ThreadPool(){pthread_mutex_destroy(mutex_); // 销毁互斥锁pthread_cond_destroy(cond_); // 销毁条件变量}// 禁止拷贝构造和赋值操作符确保线程池对象的单一性ThreadPool(const ThreadPoolT ) delete;const ThreadPoolT operator(const ThreadPoolT ) delete; // abc
private:// 线程信息列表std::vectorThreadInfo threads_;// 任务队列std::queueT tasks_;// 互斥锁和条件变量用于同步和通信pthread_mutex_t mutex_;pthread_cond_t cond_;// 线程池单例对象指针和互斥锁静态成员变量static ThreadPoolT *tp_;static pthread_mutex_t lock_;
};// 初始化线程池单例对象指针和互斥锁静态成员变量
template class T
ThreadPoolT *ThreadPoolT::tp_ nullptr;
template class T
pthread_mutex_t ThreadPoolT::lock_ PTHREAD_MUTEX_INITIALIZER; server.hpp #pragma once#include iostream
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include arpa/inet.h
#include cstring
#include unistd.h
#include functional
#include unistd.h
#include sys/wait.h
#include pthread.h
#include Threadpool.hpp
#include Task.hpp
#include Daemon.hppconst uint16_t default_port 8877; // 默认端口号
const std::string default_ip 0.0.0.0; // 默认IP
const int backlog 5; // 请求队列的最大长度class TcpServer; // 前置声明// 包含我们所需参数的类型
class ThreadData
{
public:ThreadData(int sock, const std::string ip, const uint16_t port, TcpServer *ptr): sock_(sock), clientip_(ip), clientport_(port), current_(ptr){}// 设置为公有是为了方便访问
public:int sock_;std::string clientip_;uint16_t clientport_;TcpServer *current_; // 指向 TcpServer 对象的指针
};using func_t std::functionstd::string(std::string); // 回调函数类型class TcpServer
{
public:TcpServer(const func_t func, const uint16_t port default_port, const std::string ip default_ip): ip_(ip), port_(port), func_1(func) // 注意这里要传1个业务处理函数{}~TcpServer(){}// 初始化服务器void InitServer(){// 1.创建套接字listen_sock_ socket(AF_INET, SOCK_STREAM, 0);if (listen_sock_ -1){std::cerr Create Socket Fail! strerror(errno) std::endl;exit(SOCKET_ERR);}std::cout Create Socket Success! listen_sock_ std::endl;// 2.绑定IP地址与端口号struct sockaddr_in local;memset(local, 0, sizeof(local)); // 清零local.sin_family AF_INET; // 网络local.sin_addr.s_addr inet_addr(default_ip.c_str()); // 我设置为默认绑定任意可用IP地址local.sin_port htons(port_); // 我设置为默认是8877if (bind(listen_sock_, (const sockaddr *)local, sizeof(local)) 0){std::cout Bind IPPort Fail: strerror(errno) std::endl;exit(BIND_ERR);}if (listen(listen_sock_, backlog) 0){perror(Listen fail);exit(LIS_ERR);}}// 启动服务器void StartServer(){// 守护进程化Daemon();for (;;){// 线程池的设计--》使用之前必须先启动ThreadPoolTask::GetInstance()-Start();// 1.获取新连接struct sockaddr_in client;socklen_t len sizeof(client);int accept_socket accept(listen_sock_, (struct sockaddr *)client, len);if (accept_socket 0){std::cout accept failed std::endl;continue;}// 2.业务处理// 2.1客户端信息存储uint16_t clientport ntohs(client.sin_port); // 客户端端口号char clientip[32];inet_ntop(AF_INET, (client.sin_addr), clientip, sizeof(clientip)); // 客户端IPstd::cout Server accept clientip - clientport accept_socket from listen_sock_ success! std::endl;// 3.把任务交给线程池Task task1(accept_socket, clientip, clientport, func_1); // 和原来Server函数的参数差不多这里还多传了一个回调函数ThreadPoolTask::GetInstance()-Push(task1);}}private:int listen_sock_; // socket套接字uint16_t port_; // 端口号std::string ip_; // ip地址func_t func_1; // 业务处理函数
}; server.cc #include string
#include vector
#include memory // 智能指针相关头文件
#include cstdio
#include server.hppusing namespace std;// 业务处理回调函数字符串回响
string echo(string request)
{return request;
}void Usage(const char* program)
{cout Usage: endl;cout \t program ServerPort endl;
}int main(int argc, char* argv[])
{if (argc ! 2){// 错误的启动方式提示错误信息Usage(argv[0]);return USAGE_ERR;}//命令行参数都是字符串我们需要将其转换成对应的类型uint16_t port stoi(argv[1]);//将字符串转换成端口号unique_ptrTcpServer usvr (new TcpServer(echo,port));usvr-InitServer();usvr-StartServer();return 0;
}
我们运行一下 完美收工
