网络套接字编程(二)

网络套接字编程(二)

文章目录

  • 网络套接字编程(二)
    • 简易TCP网络程序
      • 服务端创建套接字
      • 服务端绑定IP地址和端口号
      • 服务端监听
      • 服务端运行
      • 服务端网络服务
      • 服务端启动
      • 客户端创建套接字
      • 客户端的绑定和监听问题
      • 客户端建立连接并通信
      • 客户端启动
      • 程序测试
      • 单执行流服务器的弊端
    • 多进程版TCP网络程序
      • 捕捉SIGCHLD信号
      • 孙子进程提供网络服务
    • 多线程版TCP网络服务
    • 线程池版TCP网络程序

在上一篇博客 网络套接字编程(一)-CSDN博客中利用套接字编程编写了简易的UDP网络程序，本文我们再编写一个简易的TCP网络程序。

简易TCP网络程序

和上一篇博客中编写的UDP网络程序一样，将TCP网络程序分为服务端和客户端，分别封装成类，然后定义类并调用类内函数进行TCP网络程序的初始化和启动，完成简易的网络通信。本文编写的TCP网络程序的功能同样是客户端发送数据给服务端，服务端将接收的数据回传给客户端。

服务端创建套接字

使用套接字编程进行网络通信第一步就是要创建套接字，因此在服务端类内的初始化函数内部进行套接字的创建：

enum
{SOCKET_ERROR=1
};
class TcpServer
{public:void InitServer() {// 创建套接字_listensock = socket(AF_INET, SOCK_STREAM, 0);if (_listensock < 0){std::cerr << "create socket error:" << strerror(errno) << std::endl;exit(SOCKET_ERROR);}}private:int _listensock;
};

socket函数的参数

TCP协议采用的是有连接的可靠的数据传输方式，因此socket的类型应该为SOCK_STREAM这种有连接的可靠的流式数据。

服务端绑定IP地址和端口号

套接字编程进行网络通信时确定唯一主机的方式就是利用IP地址和端口号，服务端必须要让众多客户端一定能找到，因此服务端要进行IP地址和端口号的绑定。（云服务同样不需要绑定指定IP地址）在服务端类内的初始化函数内部进行绑定：

enum
{SOCKET_ERROR=1,BIND_ERROR
};
static const uint16_t default_port = 8081;//端口号缺省值
class TcpServer
{public:TcpServer(uint16_t port = default_port):_port(port) {}void InitServer() {// 创建套接字_listensock = socket(AF_INET, SOCK_STREAM, 0);if (_listensock < 0){std::cerr << "create socket error:" << strerror(errno) << std::endl;exit(SOCKET_ERROR);}// 绑定IP地址和端口号struct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_addr.s_addr = INADDR_ANY;local.sin_port = htons(_port);if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0){std::cerr << "bind socket error" << strerror(errno) << std::endl;exit(BIND_ERROR);}}   private:uint16_t _port;int _listensock;
};

云服务不需要绑定指定IP地址的原因

云服务不同于普通的主机，可能存在许多张网卡，因此云服务所使用的IP地址可能有许多个，数据接收的IP地址不确定，如果绑定云服务器某一指定IP地址，进程就可能接收不到其他IP地址收到的数据。INADDR_ANY对应的常量值是0.0.0.0，它表示绑定到所有可用的网络接口上，即可以通过任何可用的IP地址进行通信，云服务会把所有IP地址的得到的数据接收，然后根据端口号传输给指定进程。

服务端监听

TCP协议是需要建立连接的，由于建立连接的时机是不确定，因此要让服务端处于准备建立连接的状态，也就是然服务端进行监听，让服务端监听需要用到listen函数：

listen函数

//listen函数所在的头文件和函数声明#include <sys/types.h>        
#include <sys/socket.h>int listen(int sockfd, int backlog);
  • 该函数的功能是将指定的套接字设置为监听状态，以便接受客户端的连接请求。（用于TCP协议的服务端）
  • sockfd参数： 套接字描述符，用于标识一个已经打开的套接字。
  • backlog参数： 指定连接请求队列的最大长度。该参数决定了在调用accept函数之前，能够排队等待处理的未完成连接请求的数量。
  • 返回值： 成功时，返回0表示操作成功。失败时，返回-1，并设置errno变量以指示具体的错误原因。

由于TCP协议需要在建立连接后进行网络通信，而监听需要在建立连接前进行，因此在服务端类内的初始化函数内部进行监听：

enum
{SOCKET_ERROR=1,BIND_ERROR,LISTEN_ERROR
};
static const uint16_t default_port = 8081;//端口号缺省值
static const int backlog = 32;
class TcpServer
{public:TcpServer(uint16_t port = default_port):_port(port) {}void InitServer() {// 创建套接字_listensock = socket(AF_INET, SOCK_STREAM, 0);if (_listensock < 0){std::cerr << "create socket error:" << strerror(errno) << std::endl;exit(SOCKET_ERROR);}// 绑定IP地址和端口号struct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_addr.s_addr = INADDR_ANY;local.sin_port = htons(_port);if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0){std::cerr << "bind socket error" << strerror(errno) << std::endl;exit(BIND_ERROR);}// 监听if (listen(_listensock, backlog) < 0){std::cerr << "listen socket error" << strerror(errno) << std::endl;exit(LISTEN_ERROR);}}   private:uint16_t _port;int _listensock;
};

服务端运行

服务端运行后，第一步要做的就是获取和客户端的连接，通过通过建立的连接进行网络通信，获取连接需要使用accept函数：

//accept函数所在的头文件和函数声明#include <sys/types.h>        
#include <sys/socket.h>int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
  • 该函数的功能是用于接受连接请求并建立连接。（用于TCP协议的服务端）
  • sockfd参数： 套接字描述符，用于标识一个已经处于监听状态的套接字。
  • addr参数： 指向一个sockaddr结构体的指针，用于存储客户端的地址信息。
  • addrlen参数： 指向一个整数的指针，表示addr结构体的长度。
  • 返回值： 成功时，返回一个新的套接字的文件描述符，用于与客户端进行通信。失败时，返回-1，并设置errno变量以指示具体的错误原因。

在服务端类内的启动函数内部进行连接的获取：

class TcpServer
{public:void StartServer()//服务端运行函数 {while (true){// 获取连接struct sockaddr_in peer;socklen_t len = sizeof(peer);int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){std::cerr << "accept error" << std::endl;continue;}std::string clientip = inet_ntoa(peer.sin_addr);uint16_t clientport = ntohs(peer.sin_port);std::cout << "获取连接成功:" << sock << "from" << _listensock << "," << clientip << "-" << clientport << std::endl;// 网络服务service(sock, clientip, clientport);}}private:uint16_t _port;int _listensock;
};

accept函数返回值

accept函数的返回值仍然是一个新的文件描述符，该文件描述符指向的文件不同于创建套接字时的文件描述符指向的文件，因为在TCP协议的套接字编程中，创建套接字时的返回的文件是专门用于监听的，而获取连接时返回的文件是用于和对应的建立连接的客户端通信的。

服务端网络服务

服务端运行起来后，首先要建立连接，然后要做的就是进行网络服务，也就是进行数据的接收、数据的处理、数据的发送的任务，因此在服务端类内的实现一个网络服务函数：

static const uint16_t default_port = 8081;
using func_t = std::function<std::string(const std::string &)>;
class TcpServer
{public:TcpServer(func_t func, uint16_t port = default_port):_func(func), _port(port) {}void service(int sock, std::string &clientip, uint16_t clientport){std::string who = clientip + "-" + std::to_string(clientport);char buffer[128];while (true){ssize_t n = read(sock, buffer, sizeof(buffer) - 1); // 数据接收if (n > 0){buffer[n] = 0;std::string res = _func(buffer);std::cout << who << ">>>" << res << std::endl;write(sock, res.c_str(), res.size()); // 发送数据}else if (n == 0){close(sock);std::cout << "client quit,me too" << std::endl;break;}else{close(sock);std::cout << "read error" << std::endl;break;}}}private:uint16_t _port;int _listensock;func_t _func;//数据处理方法
};

网络服务中数据处理的方法由定义类对象的外部来进行传入。

使用read和write的原因

由于TCP协议采用的是流式数据传输，因此可以使用read和write函数进行流式数据写入文件的缓冲区中，然后操作系统会让调用驱动提供的读取和写入函数将数据从网卡中读取和写入，然后网卡设备会将数据接收和发送。

服务端启动

调用服务端类内部的函数进行服务端的初始化，并运行服务端。为了给错误运行服务端纠错，引入了命令行参数，在运行服务端时做纠错提示：

enum
{SOCKET_ERROR=1,BIND_ERROR,LISTEN_ERROR,USAGE_ERROR
};void Usage(const char *proc)
{std::cout << "Usage:\n\t" << proc << " port\n" << std::endl; 
}std::string echo(const std::string& message)//数据处理方法
{return message;
}int main(int argc, char* argv[])
{if (argc != 2){Usage(argv[0]);exit(USAGE_ERROR);}uint16_t port = atoi(argv[1]);std::unique_ptr<TcpServer> tsvr(new TcpServer(echo, port));tsvr->InitServer();tsvr->StartServer();return 0;
}

数据处理方法的实现

由于本文实现的简易TCP网络程序中服务端的功能是将从客户端接收的数据回传给客户端，因此数据处理方法的实现只是简单的将传入的数据返回即可。

客户端创建套接字

同样的，将客户端封装成类，在使用客户端时，只需要创建类对象，然后调用对应的函数即可使用客户端。在创建客户端类对象后的第一步就是初始化客户端，在初始化客户端时，首先就需要创建套接字：

enum
{SOCKET_ERROR=1,BIND_ERROR,LISTEN_ERROR,USAGE_ERROR,CONNECT_ERROR
};
class TcpClient
{public: TcpClient(std::string serverip, uint16_t serverport):_serverip(serverip), _serverport(serverport) {}void InitClient(){//创建套接字_sock = socket(AF_INET, SOCK_STREAM, 0);if (_sock < 0){std::cerr << "create socket error:" << strerror(errno) << std::endl;exit(SOCKET_ERROR);}}private:int _sock;std::string _serverip;uint16_t _serverport;
};

客户端的绑定和监听问题

同上一篇博客中所讲的一样，为了避免端口号的冲突，因此客户端无需自主绑定IP地址和端口号。

客户端是发起连接的一方，建立连接的时机由客户端决定，因此无需监听。

客户端建立连接并通信

由于使用TCP协议的网络通信前需要建立连接，因此客户端也需要建立连接，客户端需要使用connect函数：

//connect函数所在的头文件和函数声明
#include <sys/types.h>
#include <sys/socket.h>int connect(int sockfd, const struct sockaddr *addr,  socklen_t addrlen);
  • 该函数的功能是发起连接请求并与服务器建立连接。（用于TCP协议的客户端）
  • sockfd参数： 套接字描述符，用于标识一个已经打开的套接字。
  • addr参数： 指向一个sockaddr结构体的指针，包含了服务器的地址信息。
  • addrlen参数： 表示addr结构体的长度。
  • 返回值： 成功时，返回0，表示连接建立成功。失败时，返回-1，并设置errno变量以指示具体的错误原因。

客户端要想和服务端进行网络通信，首先要建立连接，然后进行网络通信，因此在客户端类内部的运行函数中实现建立连接和网络通信：

enum
{SOCKET_ERROR=1,BIND_ERROR,LISTEN_ERROR,USAGE_ERROR,CONNECT_ERROR
};
class TcpClient
{public: TcpClient(std::string serverip, uint16_t serverport):_serverip(serverip), _serverport(serverport) {}void StartClient(){//建立连接struct sockaddr_in peer;peer.sin_family = AF_INET;peer.sin_addr.s_addr = inet_addr(_serverip.c_str());peer.sin_port = htons(_serverport);if (connect(_sock, (struct sockaddr*)&peer, sizeof(peer)) < 0){std::cerr << "connect socket error" << strerror(errno) << std::endl;exit(CONNECT_ERROR);}std::string message;char buffer[128];while(true){std::cout << "Please enter>";getline(std::cin, message);write(_sock, message.c_str(), message.size());int n = read(_sock, buffer, sizeof(buffer)-1);if (n > 0){std::cout << "server echo#" << message << std::endl;}else if (n == 0)//服务端关闭{std::cout << "server quit" << std::endl;break;}else{std::cout << "write error" << std::endl;break;}}}private:int _sock;std::string _serverip;uint16_t _serverport;
};

客户端启动

同样的，调用客户端类内部的函数进行客户端的初始化，并运行客户端。为了给错误运行客户端纠错，引入了命令行参数，在运行客户端时做纠错提示：

void Usage(const char *proc)
{std::cout << "Usage:\n\t" << proc << " serverip serverport\n" << std::endl; 
}int main(int argc, char *argv[])
{if (argc != 3){Usage(argv[0]);exit(USAGE_ERROR);}std::string serverip = argv[1];uint16_t serverport = atoi(argv[2]);std::unique_ptr<TcpClient> tpcr(new TcpClient(serverip, serverport));tpcr->InitClient();tpcr->StartClient();return 0;
}

程序测试

本地测试

在命令行输入指令启动服务端并加上要指定端口号，使用netstat -natp指令查看服务端的状态：

image-20231031181621496

服务端现处于监听状态，等待客户端的连接然后进行网络服务。

启动客户端时输入IP地址127.0.0.1和端口号8081：

image-20231031182507882

服务端获取到了连接，知晓了客户端的IP地址和端口号，客户端建立了连接可以开始发送消息。

使用客户端发送数据：

image-20231031182700386

服务端能够将接受的数据回传给客户端。

关闭客户端：

image-20231031182746236

关闭客户端后，read函数返回值为0，服务端会断开与该客户端的服务，但是服务端并没有停止运行。

网络测试

网络测试主要查看能否成功建立网络连接即可，其余现象和本地测试现象相同，在启动客户端时输入服务端所处的IP地址：

image-20231031183156269

单执行流服务器的弊端

使用两个客户端连接服务器后，两个客户端都显示了连接成功等待输入数据，但是服务端只获取了一个客户端的连接信息：

image-20231031183422798

两个客户端都向服务端发送数据，只有一个客户端能得到服务端的网络服务，得到回传的数据：

image-20231031183644649

关闭正在接收网络服务的客户端后，客户端才能获取另一个客户端的连接，并且给该客户端提供网络服务：

image-20231031183804756

单执行流的服务器

通过测试可以看到，这服务端只有服务完一个客户端后才会服务另一个客户端。这个服务器一次只能为一个客户端提供服务，是一个单执行流的服务端。

服务端需要获取连接，才能够给对应的客户端提供网络服务，因此正在接收网络服务的客户端关闭，其他客户端才能接收网络服务。

客户端为什么会显示连接成功？

服务端处于监听状态后，客户端调用connect函数就可以与服务端建立连接，不受服务端是否获取连接的影响。

解决方法

单执行流的服务器一次只能给一个客户端提供服务，但是这样的服务端利用率是极低的，要解决这个问题就需要将服务器改为多执行流的，此时就要引入多进程或多线程。

多进程版TCP网络程序

多进程版与单执行流的服务端的区别在于当服务端获取连接后，将执行网络服务的任务交给子进程或孙子进程去处理，父进程依旧保持监听并获取连接，这样可以有多个客户端都可以接收网络服务。根据对回收子进程的策略不同分为捕捉SIGCHLD信号版的和孙子进程提供网络服务版的。

捕捉SIGCHLD信号

至于捕捉SIGCHLD信号的多进程版的代码改动相对简单，只需要在服务端运行函数中添加创建子进程，让子进程进行网络服务的部分：

class TcpServer
{public:void StartServer(){signal(SIGCHLD, SIG_IGN);//修改信号处理动作while (true){// 获取连接struct sockaddr_in peer;socklen_t len = sizeof(peer);int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){std::cerr << "accept error" << std::endl;continue;}std::string clientip = inet_ntoa(peer.sin_addr);uint16_t clientport = ntohs(peer.sin_port);std::cout << "获取连接成功:" << sock << "from" << _listensock << "," << clientip << "-" << clientport << std::endl;// 网络服务pid_t id = fork();//创建子进程if (id < 0) // 服务器过载{close(sock); // 无法承担任务，因此关闭文件continue;}else if (id == 0){close(_listensock);//避免错误写入service(sock, clientip, clientport);exit(0);}close(sock);}}private:uint16_t _port;int _listensock;func_t _func; // 数据处理方法
};

子进程能够完成网络服务的原理

父进程的文件描述符表会被子进程所继承，也就是拷贝父进程的文件描述符表，因此父进程打开的文件，子进程也能够访问。子进程执行网络服务代码时，可以对执行网络通信的文件进行读写操作，即可完成网络服务的任务。

文件描述符表的关闭操作

执行网络服务的子进程关闭用于监听的文件描述符的原因是避免错误的读写操作。

父进程关闭获取连接所得的文件描述符的原因是父进程不进行网络服务不需要使用该文件描述符，而文件描述符是有限的，必须关闭，避免文件描述符泄露。

子进程回收策略

父进程调用signal函数将SIGCHLD的处理动作置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不会产生僵尸进程,也不会通知父进程。

程序测试

使用两个客户端连接服务端：

image-20231031201721051

两个客户端现在可以同时接收网络服务了。

可以看到服务端为这个两个客户端都创建了子进程进行网络服务：

image-20231031201926442

客户端关闭后，系统自动回收了进入僵尸状态的子进程：

image-20231031202448615

孙子进程提供网络服务

孙子进程提供网络服务和捕捉SIGCHLD信号在代码层面上，改动如下：

class TcpServer
{public:void StartServer(){while (true){struct sockaddr_in peer;socklen_t len = sizeof(peer);int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){std::cerr << "accept error" << std::endl;continue;}std::string clientip = inet_ntoa(peer.sin_addr);uint16_t clientport = ntohs(peer.sin_port);std::cout << "获取连接成功:" << sock << "from" << _listensock << "," << clientip << "-" << clientport << std::endl;pid_t id = fork();if (id < 0) {close(sock); continue;}else if (id == 0){close(_listensock);if (fork() > 0) exit(0);//修改语句service(sock, clientip, clientport);exit(0);}close(sock);waitpid(id, nullptr, 0);//修改语句std::cout << id << "子进程等待成功" << std::endl;//修改语句}}private:uint16_t _port;int _listensock;func_t _func; 
};

孙子进程完成网络服务的原理

孙子进程完成网络服务的原理和子进程完成网络服务的原理相同，孙子进程会拷贝子进程的文件描述符表，孙子进程能够访问获取连接时得到的文件，因此孙子进程具有完成网络服务的能力。

子进程和孙子进程的回收机制

子进程在创建完孙子进程后就会退出，此时父进程立刻就能回收子进程，并接着完成接下来的监听和获取连接的任务。

孙子进程会在子进程死后变成孤儿进程，由系统回收。

程序测试

启动两个客户端连接服务端：

image-20231031204656315

可以看到客户端连接服务端成功后，服务端立刻回收了子进程，并且网络服务交给了孙子进程进行处理，孙子进程由于父进程终止，孙子进程的父进程ID变成为1，也就是被操作系统接管了。

将客户端都退出后，孙子进程由于执行结束也被操作系统回收了：

image-20231031204948288

多线程版TCP网络服务

相比单执行流服务端，多线程版TCP网络服务中服务端会在获取连接后，让其他线程完成网络服务任务，只需要在服务端运行函数中添加创建线程执行网路服务任务即可：

class TcpServer;
class ThreadData//线程执行所需数据
{public:ThreadData(int sock, const std::string& clientip, uint16_t clientport, TcpServer *ts):_sock(sock), _clientip(clientip), _clientport(clientport), _ts(ts) {}int _sock;std::string _clientip;uint16_t _clientport;TcpServer *_ts;
};class TcpServer
{public:void StartServer(){while (true){// 获取连接struct sockaddr_in peer;socklen_t len = sizeof(peer);int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){std::cerr << "accept error" << std::endl;continue;}std::string clientip = inet_ntoa(peer.sin_addr);uint16_t clientport = ntohs(peer.sin_port);std::cout << "获取连接成功:" << sock << "from" << _listensock << "," << clientip << "-" << clientport << std::endl;// 网络服务pthread_t tid;ThreadData *td = new ThreadData(sock, clientip, clientport, this);pthread_create(&tid, nullptr, threadRoutine, td);}}static void *threadRoutine(void *args)//线程执行函数{pthread_detach(pthread_self());ThreadData *td = static_cast<ThreadData*>(args);td->_ts->service(td->_sock, td->_clientip, td->_clientport);delete td;return nullptr;}private:uint16_t _port;int _listensock;func_t _func;
};

线程是否需要关闭监听套接字的文件描述符？

子进程会拷贝父进程的文件描述符表，因此子进程关闭任一文件描述符不影响父进程，但线程不同于进程，一个进程内部的多个线程共享同一份数据，包括文件描述符表，线程关闭监听套接字的文件描述符会影响主线程监听，因此线程无需关闭监听套接字的文件描述符。

线程回收机制

默认情况下，新创建的线程退出后，需要对其主动进行回收操作，否则无法释放资源，从而造成系统泄漏。但我们将线程分离，当线程退出时，自动释放线程资源。

程序测试

启动两个客户端连接服务端：

image-20231031212451966

可以看到服务端为两个客户端分别创建一个线程分别为它们执行网络服务。

关闭客户端，系统会自动回收终止的线程：

image-20231031213239324

线程池版TCP网络程序

引入线程池

引入线程池的作用是为了减少创建线程的开销，提高主机的效率。线程池的编写主播在另一边博客Linux]线程池-CSDN博客中有更详细的说明。

在线程池里面有一个任务队列，当有新的任务到来的时候，就可以将任务Push到线程池当中，在线程池当中我们默认创建了5个线程，这些线程不断检测任务队列当中是否有任务，如果有任务就拿出任务，然后调用该任务对应的Run函数对该任务进行处理，如果线程池当中没有任务那么当前线程就会进入休眠状态。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <vector>
#include <queue>const int N = 5; // 线程池内线程数量template <class T>
class ThreadPool
{
public:ThreadPool(int num = N) : _num(num){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_cond, nullptr);}void LockQueue(){pthread_mutex_lock(&_mutex);}void UnLockQueue(){pthread_mutex_unlock(&_mutex);}void threadWait(){pthread_cond_wait(&_cond, &_mutex);}void threadWakeUP(){pthread_cond_signal(&_cond);}T getTask(){T t = _tasks.front();_tasks.pop();return t;}bool isEmpty(){return _tasks.empty();}static void *threadRoutine(void *args){pthread_detach(pthread_self());ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);while (true){tp->LockQueue();while (tp->isEmpty()){tp->threadWait();}T t = tp->getTask();tp->UnLockQueue();t.Run();}}void Start(){pthread_t tid;for (int i = 0; i < _num; i++){pthread_create(&tid, nullptr, threadRoutine, this);}}void PushTask(T &task) // 添加任务{LockQueue();_tasks.push(task);threadWakeUP();UnLockQueue();}~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}private:int _num;                        // 线程数std::queue<T> _tasks;            // 任务队列pthread_mutex_t _mutex; // 保证互斥访问任务队列这一共享资源pthread_cond_t _cond;   // 根据任务队列中的任务数量控制线程的等待和运行
};

引入任务类

由于线程池是用模板类编写的，因此可以编写一个任务类传入线程池，任务类中需要有获取连接得到的文件描述符、客户端IP、客户端端口号用于完成网络服务，并且任务类需要实现Run函数供线程池调用，另外还实现了service函数实现网络服务的具体实现：

#include <iostream>
#include <unistd.h>void service(int sock, std::string &clientip, uint16_t clientport)//网络服务
{std::string who = clientip + "-" + std::to_string(clientport);char buffer[128];while (true){ssize_t n = read(sock, buffer, sizeof(buffer) - 1); // 数据接收if (n > 0){buffer[n] = 0;std::cout << who << ">>>" << buffer << std::endl;write(sock, buffer, n); // 发送数据}else if (n == 0){close(sock);std::cout << "client quit,me too" << std::endl;break;}else{close(sock);std::cout << "read error" << std::endl;break;}}
}class Task
{
public:Task(int sock, std::string &clientip, uint16_t clientport):_sock(sock), _clientip(clientip), _clientport(clientport){}void Run()//提供给线程池调用{service(_sock , _clientip, _clientport);}private:int _sock;std::string _clientip;uint16_t _clientport;
};

服务端实现

服务端类实现中需要将任务类引入并使用，具体代码如下：

enum
{SOCKET_ERROR = 1,BIND_ERROR,LISTEN_ERROR,USAGE_ERROR
};
static const uint16_t default_port = 8081;
static const int backlog = 32;
class TcpServer
{public:TcpServer(uint16_t port = default_port) : _port(port) {}void InitServer(){// 创建套接字_listensock = socket(AF_INET, SOCK_STREAM, 0);if (_listensock < 0){std::cerr << "create socket error:" << strerror(errno) << std::endl;exit(SOCKET_ERROR);}// 绑定IP地址和端口号struct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_addr.s_addr = INADDR_ANY;local.sin_port = htons(_port);if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0){std::cerr << "bind socket error" << strerror(errno) << std::endl;exit(BIND_ERROR);}// 监听if (listen(_listensock, backlog) < 0){std::cerr << "listen socket error" << strerror(errno) << std::endl;exit(LISTEN_ERROR);}}void StartServer(){ThreadPool<Task> tp;tp.Start();while (true){// 获取连接struct sockaddr_in peer;socklen_t len = sizeof(peer);int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){std::cerr << "accept error" << std::endl;continue;}std::string clientip = inet_ntoa(peer.sin_addr);uint16_t clientport = ntohs(peer.sin_port);std::cout << "获取连接成功:" << sock << "from" << _listensock << "," << clientip << "-" << clientport << std::endl;// 网络服务Task t(sock, clientip, clientport);tp.PushTask(t);}}private:uint16_t _port;int _listensock;
};

程序测试

启动服务端，并且启动一个任务监视窗口输入指令while :; do ps -aL | head -1 && ps -aL | grep tcp_server; sleep 1; done不断监视线程：

image-20231101161056222

可以看出在启动服务端后，立刻就为线程池创建了5个线程等待任务。

启动客户端连接服务端进行网络通信：

image-20231101161329316

值得注意的是，无论现在有多少客户端发来请求，在服务端都只会有线程池当中的5个线程为之提供服务，线程池当中的线程个数不会随着客户端连接的增多而增多，这些线程也不会因为客户端的退出而退出。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/127919.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

CCF_A 计算机视觉顶会CVPR2024投稿指南以及论文模板

CCF_A 计算机视觉顶会CVPR2024投稿指南以及论文模板

目录 CVPR2024官网&#xff1a; CVPR2024投稿链接&#xff1a; CVPR2024 重要时间节点&#xff1a; CVPR2024投稿模板: WORD: LATEX : CVPR2024_AuthorGuidelines CVPR2024投稿Topics&#xff1a; CVPR2024官网&#xff1a; https://cvpr.thecvf.com/Conferences/2024CV…
阅读更多...
【Linux】常见指令以及具体其使用场景

【Linux】常见指令以及具体其使用场景

君兮_的个人主页 即使走的再远&#xff0c;也勿忘启程时的初心 C/C 游戏开发 Hello,米娜桑们&#xff0c;这里是君兮_&#xff0c;随着博主的学习&#xff0c;博主掌握的技能也越来越多&#xff0c;今天又根据最近的学习开设一个新的专栏——Linux&#xff0c;相信Linux操作系…
阅读更多...
【嵌入式开发学习02】esp32cam烧录human_face_detect实现人脸识别

【嵌入式开发学习02】esp32cam烧录human_face_detect实现人脸识别

Ubuntu20.04系统为esp32cam烧录human_face_detect 1. 下载esp-dl2. 安装esp-idf3. 烧录human_face_detect 如果使用ubuntu 16.04在后续的步骤中会报错如下&#xff0c;因为ubuntu 16.04不支持glibc2.23以上的版本&#xff08;可使用strings /lib/x86_64-linux-gnu/libc.so.6 | …
阅读更多...
服务号改订阅号怎么弄

服务号改订阅号怎么弄

服务号和订阅号有什么区别&#xff1f;服务号转为订阅号有哪些作用&#xff1f;很多小伙伴想把服务号改为订阅号&#xff0c;但是不知道改了之后具体有什么作用&#xff0c;今天跟大家具体讲解一下。首先我们知道服务号一个月只能发四次文章&#xff0c;但是订阅号每天都可以发…
阅读更多...
JVM——类的生命周期（加载阶段，连接阶段，初始化阶段）

JVM——类的生命周期（加载阶段，连接阶段，初始化阶段）

目录 1.加载阶段2.连接阶段1.验证2.准备3.解析 3.初始化阶段4.总结 类的生命周期 1.加载阶段 ⚫ 1、加载(Loading)阶段第一步是类加载器根据类的全限定名通过不同的渠道以二进制流的方式获取字节码信息。 程序员可以使用Java代码拓展的不同的渠道。 ⚫ 2、类加载器在加载完类…
阅读更多...
C++和 C 混合编程处理

C++和 C 混合编程处理

原因是因为有很多功能是用 C 语言开发的&#xff0c;而 C是兼容 C 的&#xff0c;C应该能直接使用这些功能&#xff0c;那么我们把 C调用 C 实现的功能的这个做法&#xff0c;称为混合编程 但是用 C 开发的功能&#xff0c;很可能已经用 C 编译器编程成目标文件(或打包成库了)…
阅读更多...
3.16每日一题（区间在现求定积分）

3.16每日一题（区间在现求定积分）

解法一&#xff1a; 1、二倍角化简&#xff0c;为了使用公式把x消去&#xff0c;令t2x&#xff0c;跟换区间 2、因为三角函数的几何性质&#xff0c;即sinx在0到Π上时对称区间&#xff0c;所以可以只计算[ 0 , Π/2 ]上的面积&#xff0c;最后乘2即可。 注&#xff1a;换元后记…
阅读更多...
【服务器】Redis的安装及使用命令（Linux、Windows版）

【服务器】Redis的安装及使用命令（Linux、Windows版）

目录 一、Redis简介 二、Redis安装 1、Linux版 1.1、下载 1.2、导入 1.3、解压 1.4、安装 1.5、修改文件 1.6、启动redis 1.7、测试 1.8、结束进程 1.9、修改密码访问 1.10、安装客户端工具&连接 2、Windows版 2.1、下载 2.2、安装 2.3、修改 2.4、连接 …
阅读更多...
卷麻了，00后测试用例写的比我还好，简直无地自容......

卷麻了，00后测试用例写的比我还好，简直无地自容......

经常看到无论是刚入职场的新人&#xff0c;还是工作了一段时间的老人&#xff0c;都会对编写测试用例感到困扰&#xff1f;例如&#xff1a; 如何编写测试用例&#xff1f; 作为一个测试新人&#xff0c;刚开始接触测试&#xff0c;对于怎么写测试用例很是头疼&#xff0c;无法…
阅读更多...
【从删库到跑路】详解MySQL数据库的视图以及相关操作

【从删库到跑路】详解MySQL数据库的视图以及相关操作

&#x1f38a;专栏【MySQL】 &#x1f354;喜欢的诗句&#xff1a;更喜岷山千里雪 三军过后尽开颜。 &#x1f386;音乐分享【如愿】 &#x1f970;欢迎并且感谢大家指出小吉的问题 文章目录 &#x1f384;视图介绍&#x1f384;视图特点&#x1f33a;基本操作⭐创建视图⭐查询…
阅读更多...
MIT6.5830 Lab1-GoDB实验记录（二）

MIT6.5830 Lab1-GoDB实验记录（二）

MIT6.5830 Lab1-GoDB实验记录&#xff08;二&#xff09; – WhiteNights Site 标签&#xff1a;Golang, 数据库 接下来我们将完成tuple.go的缺失代码&#xff0c;并通过tuple_test.go的测试。 实验步骤 观察tuple.go 观察肯定是第一步&#xff0c;先打开tuple.go。 快300行代…
阅读更多...
requires SDK version ＞=3.0.1 ＜4.0.0, version solving failed

requires SDK version ＞=3.0.1 ＜4.0.0, version solving failed

这个很明显是FLUTTER SDK不匹配的问题&#xff0c;需要更新flutter SDK&#xff0c;最简单的办法&#xff0c;在flutter官网的页面直接下载最新的&#xff0c;然后替换之前旧版本的flutter 官网&#xff1a; 在 Windows 操作系统上安装和配置 Flutter 开发环境 - Flutter 中文…
阅读更多...
基于GPIO子系统的LED驱动程序

基于GPIO子系统的LED驱动程序

这两个系统属于软件层&#xff0c;让我们不用直接对硬件配置&#xff0c;一般由芯片出产商写好&#xff0c;我们只要基于它们改就行。 设备树操作 1.使用官方的工具来编写pinctrl设置gpio的设备树代码。 如图&#xff0c;生成代码 ![在这里插入图片描述](https://img-blog.cs…
阅读更多...
比亚迪今年的薪资。。

比亚迪今年的薪资。。

大家或许已经对比亚迪在西安的宣讲会有所耳闻&#xff0c;那场面真的是座无虚席。如果你稍微迟到了一些&#xff0c;那么你可能只能在门外或是走廊听了。 事实上&#xff0c;许多人早早地抵达了&#xff0c;只要稍微晚到&#xff0c;就可能错过了室内的位置。 更令人震惊的是&…
阅读更多...
HCIA数据通信——静态路由

HCIA数据通信——静态路由

之前的文章中我提到过静态路由&#xff1a; 数据通信——网络层&#xff08;路由器以及数据转发流程&#xff09;_路由器如何转发数据_咕噜跳的博客-CSDN博客这里只做一些简单描述。 路由器关注的是网络之间的通信。路由器以自身为中心&#xff0c;考虑的是如何将数据发送到目…
阅读更多...
优维产品最佳实践第13期：如何避免拨测机自身网络问题？

优维产品最佳实践第13期：如何避免拨测机自身网络问题？

受限于拨测节点自身的环境&#xff0c;单一节点的拨测结果可能并不能反映出监控实例的真实运行状态 本期EasyOps产品使用最佳实践&#xff0c;我们将为您揭晓&#xff1a; 如何基于多点决策配置拨测监控&#xff0c;以避免拨测机自身网络问题而误告警&#xff1f; 如何对指标…
阅读更多...
Paddle炼丹炉炸了Unexpected BUS error encountered in DataLoader worker

Paddle炼丹炉炸了Unexpected BUS error encountered in DataLoader worker

Paddle训练报错&#xff0c;内存不足 python train.py -c config/ResNet_W18.yaml修改配置文件config/ResNet_W18.yaml # 原配置 loader:num_workers: 4use_shared_memory: True# 修改后 loader:num_workers: 2use_shared_memory: False
阅读更多...
基于GB28181-2022实现web无插件播放H265视频

基于GB28181-2022实现web无插件播放H265视频

目前发布的GB28181-2022增加了对前端设备视频H265编码格式的支持&#xff0c;所以实现国标平台通过浏览器对H265视频流的无插件的解码播放将是未来的趋势。 目前大多的方案都是通过平台端把H265转码为H264&#xff0c;再推送到web前端进行解码播放&#xff0c;这种方式因为需要…
阅读更多...
MAA连不上MUMU模拟器

MAA连不上MUMU模拟器

之前一直能正常用&#xff0c;最近突然连接不上&#xff0c;最终发现是adb版本不同造成的&#xff0c;我系统变量的adb版本如下&#xff1a; MUMU自带adb版本如下&#xff1a; 解决办法&#xff1a; 把mumu的adb复制到系统变量路径下&#xff0c;或者把adb的系统变量删除
阅读更多...
小红书协议算法最新版

小红书协议算法最新版

如果您想通过学习来了解小红书的点赞、关注、私信等功能的实现&#xff0c;以下是一些一般性的思路和示例代码&#xff0c;供您学习参考&#xff1a; 1. 点赞功能&#xff1a; - 后端实现&#xff1a;在后端&#xff0c;您可以创建一个用于存储用户点赞信息的数据库表。对于每…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023