【Linux编程】TcpServer 类的计划与实现：构建高性能的 TCP 服务器（二） ...

TcpServer 类的计划与实现：构建高性能的 TCP 服务器

在现代网络编程中，构建一个高效、稳定的 TCP 服务器是许多网络应用的底子。本文将具体介绍一个基于 C++ 的 TcpServer 类的计划与实现，该类提供了创建 TCP 服务器、处置惩罚客户端连接、数据传输和接收等功能。通过这个类，我们可以更轻易地理解和实现 TCP 通信的细节。
1. TcpServer 类概述

TcpServer 类是一个用于创建和管理 TCP 服务器的类。它封装了套接字创建、绑定、监听、客户端连接处置惩罚、数据发送和接收等操作，使得网络通信更加简洁和易于管理。
2. 类构造与析构

• 构造函数 TcpServer::TcpServer(int _port) 和 TcpServer::TcpServer(std::string _host, int _port) 初始化服务器的主机地址和端口，并创建套接字。
  

1. TcpServer::TcpServer(int _port) : TcpServer("0.0.0.0", _port) {
2. }
4. TcpServer::TcpServer(std::string _host, int _port) : host(_host), port(_port) {
5.     std::cout << "create tcp server start." << std::endl;
6.     socket_fd = socket(AF_INET, SOCK_STREAM, 0);
7.     if (socket_fd == -1) {
8.         std::cout << "socket create error!";
9.         return;
10.     }
11.     int ret = set_epoll_mode(socket_fd, O_NONBLOCK);
12.     if (ret < 0) {
13.         std::cout << "epoll_mode failed:" << ret << std::endl;
14.         close(socket_fd);
15.         return;
16.     }
17.     server_addr.sin_family = AF_INET;
18.     inet_pton(AF_INET, host.c_str(), &server_addr.sin_addr);
19.     server_addr.sin_port = htons(port);
20.     int opt = 1;
21.     setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
22.     isCreate = true;
23.     std::cout << "create tcp server ok." << std::endl;
24. }

复制代码

• 析构函数 TcpServer::~TcpServer() 虚析构函数，确保派生类的析构函数被精确调用。
  

1. TcpServer::~TcpServer() {
2. }

复制代码

3. 服务器启动与停止

• 启动服务器 TcpServer::Start() 绑定套接字到指定端口，并开始监听。
  

1. void TcpServer::Start() {
2.     if (running || !isCreate) {
3.         std::cout << "TcpServer start failed!" << "running=" << running << ", port=" << port << std::endl;
4.         return;
5.     }
6.     auto ret = bind(socket_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
7.     if (ret == -1) {
8.         std::cout << "bind faild:" << ret << std::endl;
9.         close(socket_fd);
10.         return;
11.     }
12.     ret = listen(socket_fd, SOMAXCONN);
13.     if (ret == -1) {
14.         std::cout << "Listen failed:" << ret << std::endl;
15.         close(socket_fd);
16.         return;
17.     }
18.     std::cout << "server open: " << host << ":" << port << std::endl;
19.     epoll_start();
20. }

复制代码

• 停止服务器 TcpServer::Stop() 关闭服务器并释放资源。
  

1. void TcpServer::Stop() {
2.     this->Close();
3. }

复制代码

4. 资源管理

• 关闭连接 TcpServer::Close() 关闭套接字和 epoll 文件形貌符，释放资源。
  

1. void TcpServer::Close() {
2.     isCreate = false;
3.     running = false;
4.     socket_event.data.fd = socket_fd;
5.     int ret = epoll_ctl(epoll_fd, EPOLL_CTL_DEL, socket_fd, &socket_event);
6.     ret = close(socket_fd);
7.     std::cout << "socket_fd已关闭:" << ret << std::endl;
8.     for (TcpClient *client : clients)
9.         client->Close();
10.     ret = close(epoll_fd);
11.     std::cout << "TcpServer epoll_fd已关闭:" << ret << std::endl;
12. }

复制代码

5. 非阻塞模式设置

• 设置非阻塞模式 TcpServer::set_epoll_mode() 设置套接字为非阻塞模式。
  

1. int TcpServer::set_epoll_mode(int sock_fd, int mode) {
2.     int flags = fcntl(sock_fd, F_GETFL, 0);
3.     if (flags == -1) {
4.         std::cout << "epoll_mode failed:" << sock_fd << std::endl;
5.         return -1;
6.     }
7.     return fcntl(sock_fd, F_SETFL, flags | mode);
8. }

复制代码

6. 客户端连接处置惩罚

• 客户端接受线程 TcpServer::client_accept_thread() 处置惩罚客户端连接和数据事件。
  

1. void TcpServer::client_accept_thread() {
2.     struct epoll_event client_events[1024];
3.     while (running) {
4.         int ret = epoll_wait(epoll_fd, client_events, 1024, -1);
5.         if (ret < 0) {
6.             if (errno == EAGAIN || errno == EWOULDBLOCK)
7.                 continue;
8.             else {
9.                 std::cerr << "epoll_wait failed: " << ret << " : " << errno << " : " << strerror(errno) << std::endl;
10.                 break;
11.             }
12.         }
13.         for (int n = 0; n < ret; ++n) {
14.             if (client_events[n].data.fd == socket_fd) {
15.                 client_connect();
16.             } else {
17.                 struct epoll_event client_event = client_events[n];
18.                 auto client = std::find_if(clients.begin(), clients.end(), [&client_event](const TcpClient *_client)
19.                                            { return (_client->client_fd == client_event.data.fd); });
20.                 if (client == clients.end())
21.                     continue;
22.                 int ret = (*client)->data_receive(*client);
23.                 if (ret == 0) {
24.                     clients.erase(client);
25.                     delete *client;
26.                 }
27.             }
28.         }
29.     }
30.     std::cout << "服务已关闭，不再提供任何服务！" << std::endl;
31.     isDispose = true;
32. }

复制代码

• 客户端连接 TcpServer::client_connect() 接受客户端连接并添加到 epoll 监控。
  

1. void TcpServer::client_connect() {
2.     struct sockaddr_in client_addr;
3.     socklen_t addr_len = sizeof(client_addr);
4.     int client_fd = accept(socket_fd, (struct sockaddr *)&client_addr, &addr_len);
5.     std::cout << "accept:" << client_fd << " : " << strerror(errno) << std::endl;
6.     if (client_fd <= 0)
7.         return;
9.     TcpClient *client = new TcpClient;
10.     client->running = true;
11.     client->connected = true;
12.     client->client_fd = client_fd;
13.     client->local_addr = client_addr;
14.     int ret = set_epoll_mode(client_fd, O_NONBLOCK);
15.     if (ret == -1) {
16.         std::cout << "服务器接受客户端-set_epoll_mode failed:" << strerror(errno) << std::endl;
17.         client->Close();
18.         return;
19.     }
20.     client->add_epoll_event(client_fd, epoll_fd, EPOLLIN | EPOLLET);
22.     client->DataReceived = [this](void *sender, DataReceiveEventArgs *e)
23.     {
24.         DataReceived.Invoke(this, e);
25.     };
27.     client->recv_data = new char[client->recv_data_length];
29.     clients.push_back(client);
30.     std::cout << "新的客户端已接入:" << inet_ntoa(client_addr.sin_addr) << ":" << htons(client_addr.sin_port) << std::endl;
31. }

复制代码

7. epoll 事件处置惩罚

• 启动 epoll TcpServer::epoll_start() 创建 epoll 实例并添加监听套接字。
  

1. void TcpServer::epoll_start() {
2.     epoll_fd = epoll_create1(0);
3.     if (epoll_fd == -1) {
4.         std::cout << "poll_create1 failed:" << epoll_fd << std::endl;
5.         close(socket_fd);
6.         return;
7.     }
9.     socket_event.events = EPOLLIN;
10.     socket_event.data.fd = socket_fd;
11.     int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_fd, &socket_event);
12.     if (ret == -1) {
13.         std::cout << "epoll_ctl failed:" << ret << std::endl;
14.         close(epoll_fd);
15.         return;
16.     }
18.     running = true;
19.     std::thread th = std::thread(&TcpServer::client_accept_thread, this);
20.     th.detach();
21. }

复制代码

完整的代码:
TcpServer.h 头文件

1. #pragma once
3. #include <iostream>
4. #include <vector>
5. #include <list>
6. #include <string>
7. #include <sys/socket.h>
8. #include <netinet/in.h>
9. #include <sys/epoll.h>
10. #include <sys/fcntl.h>
11. #include <arpa/inet.h>
12. #include <algorithm>
13. #include <unistd.h>
14. #include <thread>
15. #include "DataReceiveEventArgs.h"
16. #include "TcpClient.h"
18. class TcpServer
19. {
20. public:
21.     TcpServer(int _port);
22.     TcpServer(std::string _host, int _port);
23.     ~TcpServer();
25. public:
26.     EventHandler<DataReceiveEventArgs> DataReceived;
28. public:
29.     void Start();
30.     void Stop();
31.     void Close();
32.     bool IsDispose();
34. private:
35.     void epoll_start();                        // epoll初始化（创建epoll）
36.     int set_epoll_mode(int sock_fd, int mode); // epoll模式--创建socket时，为非阻塞模式
37.     void client_accept_thread();
38.     void client_connect();
40.     sockaddr_in get_remote_addr(int sock);
42. private:
43.     int socket_fd;
44.     int epoll_fd;
45.     std::string host = "0.0.0.0";
46.     int port = 0;
47.     bool running = false;
48.     bool isCreate = false;
49.     int send_buff_size = 1024 * 1024;
50.     int recv_buff_size = 1024 * 1024;
51.     struct sockaddr_in server_addr;
52.     std::list<TcpClient *> clients;
53.     // 将监听套接字添加到 epoll 中，监控 EPOLLIN （表示有数据可读）事件
54.     struct epoll_event socket_event;
55.     bool isDispose = false;
56. };

复制代码

TcpServer.cpp

1. #include "TcpServer.h"
3. TcpServer::TcpServer(int _port) : TcpServer("0.0.0.0", _port)
4. {
5. }
7. TcpServer::TcpServer(std::string _host, int _port) : host(_host), port(_port)
8. {
9.     std::cout << "create tcp server start." << std::endl;
10.     // AF_INET 表示使用 IPv4 协议
11.     // SOCK_STREAM 表示套接字的类型，表示 面向连接的流式套接字
12.     socket_fd = socket(AF_INET, SOCK_STREAM, 0);
13.     // std::cout << "create tcp server socket_fd:" << socket_fd << std::endl;
14.     if (socket_fd == -1)
15.     {
16.         std::cout << "socket ceate error!";
17.         return;
18.     }
19.     // 文件描述符为非阻塞模式
20.     int ret = set_epoll_mode(socket_fd, O_NONBLOCK);
21.     if (ret < 0)
22.     {
23.         std::cout << "epoll_mode failed:" << ret << std::endl;
24.         close(socket_fd);
25.         return;
26.     }
28.     server_addr.sin_family = AF_INET;
30.     // ip字符串转int
31.     inet_pton(AF_INET, host.c_str(), &server_addr.sin_addr);
32.     //server_addr.sin_addr.s_addr = ntohl(server_addr.sin_addr.s_addr);
33.     server_addr.sin_port = htons(port);
35.     // 以下设置表示当调用close关闭客户端时，立即释放端口，不等待
36.     // 在TCP服务端，客户端调用 close(client_fd) 关闭连接后，如果你尝试重新连接时出现端口没有完全释放的情况，通常是由于 TCP 连接的 TIME_WAIT 状态没有及时清理。这是 TCP 协议的正常行为。
37.     // 在TCP连接关闭后，端口会进入 TIME_WAIT 状态。这个状态的目的是确保最后的数据包能够正确到达。如果新的连接尝试在该端口上进行，而该端口仍然处于 TIME_WAIT 状态，就会出现端口被占用的情况。
38.     // TIME_WAIT 状态通常会持续一段时间（默认是4分钟，即240秒），这可以通过操作系统的内核参数来修改。
40.     // struct linger linger_opt;
41.     // linger_opt.l_onoff = 1;  // 启用
42.     // linger_opt.l_linger = 1; // 立即关闭
43.     // // 此方法亲测无效
44.     // // setsockopt(socket_fd, SOL_SOCKET, SO_LINGER, &linger_opt, sizeof(linger_opt));
46.     int opt = 1;
47.     setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
48.     isCreate = true;
49.     std::cout << "create tcp server ok." << std::endl;
50. }
52. TcpServer::~TcpServer()
53. {
54. }
56. void TcpServer::Start()
57. {
58.     if (running || !isCreate)
59.     {
60.         std::cout << "TcpServer start failed!" << "running=" << running << ", port=" << port << std::endl;
61.         // close(socket_fd);
62.         return;
63.     }
64.     // 绑定套接字到指定端口
65.     auto ret = bind(socket_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
66.     if (ret == -1)
67.     {
68.         std::cout << "bind faild:" << ret << std::endl;
69.         close(socket_fd);
70.         return;
71.     }
73.     // 开始监听
74.     ret = listen(socket_fd, SOMAXCONN);
75.     if (ret == -1)
76.     {
77.         std::cout << "Listen failed:" << ret << std::endl;
78.         close(socket_fd);
79.         return;
80.     }
81.     std::cout << "server open: " << host << ":" << port << std::endl;
83.     epoll_start();
84. }
86. void TcpServer::Stop()
87. {
88.     this->Close();
89. }
91. void TcpServer::Close()
92. {
93.     isCreate = false;
94.     running = false;
96.     // 1. 删除socket_fd的epoll事件
97.     socket_event.data.fd = socket_fd;
98.     int ret = epoll_ctl(epoll_fd, EPOLL_CTL_DEL, socket_fd, &socket_event);
100.     // 2. 关闭监听套接字
101.     ret = close(socket_fd);
102.     std::cout << "socket_fd已关闭:" << ret << std::endl;
104.     // 3. 从 epoll 中移除所有连接的客户端文件描述符
105.     for (TcpClient *client : clients)
106.         client->Close();
107.     // 4. 关闭 epoll 文件描述符
108.     ret = close(epoll_fd);
109.     std::cout << "TcpServer epoll_fd已关闭:" << ret << std::endl;
110. }
112. bool TcpServer::IsDispose()
113. {
114.     return isDispose;
115. }
117. int TcpServer::set_epoll_mode(int sock_fd, int mode)
118. {
119.     /*
120.     O_NONBLOCK（非阻塞模式）：如果设置了这个标志，表示该套接字（或文件）是非阻塞的，执行读写操作时不会阻塞调用进程或线程。
121.     套接字在没有数据可读或可写时不会让程序等待，而是立即返回。
122.     O_RDWR、O_WRONLY、O_RDONLY（访问模式）：表示套接字的打开方式。
123.     O_APPEND（追加模式）：指示文件或套接字在写操作时会追加数据。
124.     */
125.     int flags = fcntl(sock_fd, F_GETFL, 0); // 获取当前套接字的文件状态标志
126.     if (flags == -1)
127.     {
128.         std::cout << "epoll_mode failed:" << sock_fd << std::endl;
129.         return -1;
130.     }
131.     // 设置套接字为非阻塞模式
132.     return fcntl(sock_fd, F_SETFL, flags | mode);
133. }
135. void TcpServer::client_accept_thread()
136. {
137.     struct epoll_event client_events[1024];
138.     while (running)
139.     {
140.         // 阻塞等待事件
141.         int ret = epoll_wait(epoll_fd, client_events, 1024, -1);
142.         if (ret < 0)
143.         {
144.             if (errno == EAGAIN || errno == EWOULDBLOCK)
145.                 continue;
146.             else
147.             {
148.                 std::cerr << "epoll_wait failed: " << ret << " : " << errno << " : " << strerror(errno) << std::endl;
149.                 break;
150.             }
151.         }
152.         // 处理返回的事件
153.         for (int n = 0; n < ret; ++n)
154.         {
155.             if (client_events[n].data.fd == socket_fd)
156.             {
157.                 // 如果是监听套接字的事件,有新的客户端连接
158.                 client_connect();
159.             }
160.             else
161.             {
162.                 struct epoll_event client_event = client_events[n];
163.                 auto client = std::find_if(clients.begin(), clients.end(), [&client_event](const TcpClient *_client)
164.                                            { return (_client->client_fd == client_event.data.fd); });
165.                 if (client == clients.end())
166.                     continue;
167.                 // 客户端有数据
168.                 int ret = (*client)->data_receive(*client);
169.                 if (ret == 0)
170.                 {
171.                     clients.erase(client);
172.                     delete *client;
173.                 }
174.             }
175.         }
176.     }
177.     std::cout << "服务已关闭，不再提供任何服务！" << std::endl;
178.     isDispose = true;
179. }
181. void TcpServer::client_connect()
182. {
183.     struct sockaddr_in client_addr;
184.     socklen_t addr_len = sizeof(client_addr);
185.     int client_fd = accept(socket_fd, (struct sockaddr *)&client_addr, &addr_len); // 接受连接
186.     std::cout << "accept:" << client_fd << " : " << strerror(errno) << std::endl;
187.     if (client_fd <= 0)
188.         return;
190.     TcpClient *client = new TcpClient;
191.     client->running = true;
192.     client->connected = true;
193.     client->client_fd = client_fd;
194.     client->local_addr = client_addr;
195.     // 设置客户端套接字为非阻塞模式
196.     int ret = set_epoll_mode(client_fd, O_NONBLOCK);
197.     if (ret == -1)
198.     {
199.         std::cout << "服务器接受客户端-set_epoll_mode failed:" << strerror(errno) << std::endl;
200.         client->Close();
201.         return;
202.     }
203.     // client.SetSendBuffSize(send_buff_size);
204.     // client.SetRecvBuffSize(recv_buff_size);
205.     //  将新客户端套接字添加到 epoll 中，监听可读事件
207.     // client->create_epoll();
208.     client->add_epoll_event(client_fd, epoll_fd, EPOLLIN | EPOLLET);
210.     client->DataReceived = [this](void *sender, DataReceiveEventArgs *e)
211.     {
212.         DataReceived.Invoke(this, e);
213.     };
215.     // client->start_receive();
216.     client->recv_data = new char[client->recv_data_length];
218.     clients.push_back(client);
219.     std::cout << "新的客户端已接入:" << inet_ntoa(client_addr.sin_addr) << ":" << htons(client_addr.sin_port) << std::endl;
220. }
222. void TcpServer::epoll_start()
223. {
224.     // 创建epoll
225.     epoll_fd = epoll_create1(0);
226.     if (epoll_fd == -1)
227.     {
228.         std::cout << "poll_create1 failed:" << epoll_fd << std::endl;
229.         close(socket_fd);
230.         return;
231.     }
233.     // 监听可读事件
234.     socket_event.events = EPOLLIN;
235.     // 将监听套接字的文件描述符传给 epoll
236.     socket_event.data.fd = socket_fd;
237.     // 将监听套接字添加到 epoll 中，监控 EPOLLIN 事件（表示有数据可读）
238.     int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_fd, &socket_event);
239.     if (ret == -1)
240.     {
241.         std::cout << "epoll_ctl failed:" << ret << std::endl;
242.         close(epoll_fd);
243.         return;
244.     }
246.     running = true;
247.     std::thread th = std::thread(&TcpServer::client_accept_thread, this);
248.     th.detach();
249. }

复制代码

8. 总结

本文具体介绍了 TcpServer 类的计划与实现，包括构造与析构、服务器启动与停止、资源管理、非阻塞模式设置、客户端连接处置惩罚以及 epoll 事件处置惩罚。通过这个类，我们可以更轻易地理解和实现 TCP 通信的细节。这个类提供了一个简洁的接口来管理 TCP 服务器，使得网络编程更加高效和易于维护。
TcpServer 类的计划注重模块化和可扩展性，允许开辟者根据具体需求进行定制和扩展。通过使用 epoll 事件模型，TcpServer 类能够支持高并发的客户端连接，适用于需要处置惩罚大量并发连接的网络应用。此外，类中的非阻塞模式设置和资源管理机制确保了服务器的稳定性和高效性。
总的来说，TcpServer 类为构建高性能的 TCP 服务器提供了一个强大的底子。通过这个类，开辟者可以快速构建和部署 TCP 服务器，满足各种网络应用的需求。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。