网络套接字编程(二)

网络套接字编程(二)

文章目录

  • 网络套接字编程(二)
    • 简易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);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.hqwc.cn/news/156396.html

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

相关文章

Windows 开启 Kerberos 的火狐 Firefox 浏览器访问yarn、hdfs

Windows 开启 Kerberos 的火狐 Firefox 浏览器访问yarn、hdfs

背景&#xff1a;类型为IPA或者MIT KDC&#xff0c;windows目前只支持 firefoxMIT Kerberos客户端的形式&#xff0c;其他windows端浏览器IE、chrome、edge&#xff0c;没有办法去调用MIT Kerberos Windows客户端的GSSAPI验证方式&#xff0c;所以均无法使用 Windows 开启 Kerb…
阅读更多...
Spring底层原理(四)

Spring底层原理(四)

Spring底层原理(四) 本章内容 模拟实现Spring中的几个常见BeanFactory后置处理器 常见的BeanFactory后置处理器 GenericApplicationContext context new GenericApplicationContext(); context.registerBean("config",Config.class); context.registerBean(Conf…
阅读更多...
树结构及其算法-二叉树节点的插入

树结构及其算法-二叉树节点的插入

目录 树结构及其算法-二叉树节点的插入 C代码 树结构及其算法-二叉树节点的插入 二叉树节点插入的情况和查找相似&#xff0c;重点是插入后仍要保持二叉查找树的特性。如果插入的节点已经在二叉树中&#xff0c;就没有插入的必要了&#xff0c;如果插入的值不在二叉树中&…
阅读更多...
新工业革命？基于机器视觉技术分拣机器人的未来与发展

新工业革命？基于机器视觉技术分拣机器人的未来与发展

原创 | 文 BFT机器人 01 分拣机器人的应用 基于机器视觉技术的分拣机器人可以将工人从繁重的劳动中解放出来&#xff0c;大大提高了分拣的效率&#xff0c;因此被广泛地应用于食品、物流以及煤矿等多个行业。 1.1 分拣机器人在水果分拣中的应用 随着农业科技的发展和人民生活…
阅读更多...
ES 8.x新特性一览(完整版)

ES 8.x新特性一览(完整版)

一、看点 在 2022 年 2 月 11 日&#xff0c;Elasticsearch&#xff08;ES&#xff09;正式发布了 8.0 版本&#xff0c;而截止到 2023 年 10 月&#xff0c;历经一年半时间&#xff0c;ES官方已经连续发布了多个版本&#xff0c;最新版本为 8.10.4。这一系列的更新引入了众多引…
阅读更多...
【虹科分享】Domo可视化——一份硬核的国庆出游攻略

【虹科分享】Domo可视化——一份硬核的国庆出游攻略

国庆黄金周&#xff0c;正是游览祖国大好河山的好时机。然而&#xff0c;众所周知&#xff0c;“当灿烂的太阳跳出东海的碧波&#xff0c;帕米尔高原依然是群星闪烁&#xff1b;当北国还是银装素裹的世界&#xff0c;南疆早已洋溢着盎然的春色。”面对如此广阔的大地&#xff0…
阅读更多...
NI‑9237国产化50 kS/s/ch，桥模拟输入，4通道C系列应变/桥输入模块

NI‑9237国产化50 kS/s/ch，桥模拟输入，4通道C系列应变/桥输入模块

50 kS/s/ch&#xff0c;桥模拟输入&#xff0c;4通道C系列应变/桥输入模块 NI‑9237提供了所有的信号调理功能来实现多达四个基于桥的传感器的供电和测量。该模块提供通道间零相位延迟的应变或负载测量。它还具有60 VDC隔离和1&#xff0c;000 Vrms瞬态隔离&#xff0c;提供高…
阅读更多...
SpringCloud 微服务全栈体系（九）

SpringCloud 微服务全栈体系（九）

第九章 Docker 三、Dockerfile 自定义镜像 常见的镜像在 DockerHub 就能找到&#xff0c;但是我们自己写的项目就必须自己构建镜像了。 而要自定义镜像&#xff0c;就必须先了解镜像的结构才行。 1. 镜像结构 镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而…
阅读更多...
ArcGIS制作土地利用现状图

ArcGIS制作土地利用现状图

一、现状图成果 土地利用现状图是规划制图中一种基本的图件，基于ArcGIS制作的现状图如下所示： 二、现状图制作 1. 数据准备 （1）土地利用数据 （2）地形图 （3）影像地图 （4）其他数据 2. 符号化 加载现状地块数据。 双击地块图层，切换到符号系统，选择类别下的唯…
阅读更多...
实现右键出现菜单选项功能

实现右键出现菜单选项功能

文章目录 需求分析需求 实现鼠标右键显示菜单的功能 分析 分析该需求，流程如下 写一个 div 作为右键弹出的菜单选项——> 监听鼠标右键事件——> 得到坐标位置——> 在该位置对写好的 菜单选项 进行展示——> 选择完毕后关闭菜单——> 鼠标左键其他位置 点…
阅读更多...
C# OpenCvSharp DNN 部署L2CS-Net人脸朝向估计

C# OpenCvSharp DNN 部署L2CS-Net人脸朝向估计

效果 项目 代码 using OpenCvSharp; using OpenCvSharp.Dnn; using System; using System.Collections.Generic; using System.Drawing; using System.Drawing.Drawing2D; using System.Linq; using System.Text; using System.Windows.Forms;namespace OpenCvSharp_DNN_Demo …
阅读更多...
成集云 | 英克ERP对接批发销售门店 | 解决方案

成集云 | 英克ERP对接批发销售门店 | 解决方案

方案介绍 批发连锁门店是一种以批发销售为主&#xff0c;通过连锁经营方式进行管理的商业组织形态。它通常由一个总店或总公司负责管理和运营&#xff0c;下面拥有多个分店或加盟店&#xff0c;形成一个连锁经营网络。主要业务是向下游零售商或消费者销售商品&#xff0c;因此…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023