【网络】套接字(socket)编程—

接着上一篇文章：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.h>

namespace nt_server
{
    const uint16_t default_port = 8877; // 默认端口号
    const std::string default_ip ="0.0.0.0";//默认IP
   
   enum
    {
        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.hpp"

using 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_ptr<TcpServer> 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.hpp"

namespace 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_; // 服务器IP
        uint16_t server_port_; // 服务器端口号
    };
}

创建 client.cc 客户端源文件

#include <memory>
#include "client.hpp"

using 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_ptr<TcpClient> usvr(new TcpClient(ip, port));

    usvr->InitClient();
    usvr->StartClient();
    return 0;
}

同时需要一个 Makefile 文件，用于快速编译和清理可执行程序

创建 Makefile 文件

.PHONY:all
all:server client

server:server.cc
	g++ -o $@ $^ -std=c++11

	
client:client.cc
	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -rf server client

1.2.服务端设计

1.2.1.初始化服务端——socket和bind函数

基于 TCP 协议实现的网络程序也需要创建套接字、绑定 IP 和端口号，

注意：在使用 socket 函数创建套接字时，UDP 协议需要指定参数2为 SOCK_DGRAM，TCP 协议则是指定参数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_);      // 我设置为默认是8877

            
            if(bind(sock_,(const sockaddr *)&local, sizeof(local))<0)
            {
                std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
                exit(BIND_ERR);
            }

            // 3.TODO
        }

注意： 在绑定端口号时，一定需要把主机序列转换为网络序列

为什么在绑定端口号阶段需要手动转换为网络序列，而在发送信息阶段则不需要？

这是因为在发送信息阶段，recvfrom / sendto 等函数会自动将需要发送的信息转换为网络序列，接收信息时同样会将其转换为主机序列，所以不需要手动转换

这个代码和UDP版本的差不多！！！

如果使用的 UDP 协议，那么初始化服务器到此就结束了，但我们本文中使用的是 TCP 协议，这是一个面向连接的传输层协议，意味着在初始化服务器时，需要设置服务器为监听状态

TCP是面向连接的，服务器一般是比较被动的，没人访问，这个服务器只能干等着，而且也不能退出。就像你是一家餐馆的老板，你只能在餐馆里被动的等待顾客的到来，顾客什么时候来你也不知道。服务器要一直要处于等待链接到来的状态——也就是监听状态。

1.2.2.监听状态——listen函数

对于服务器，它是被动连接的。举一个生活中的例子，通常的情况下，移动的客服（相当于服务器）是等待着客户（相当于客户端）电话的到来。而这个过程，需要调用listen()函数。

#include<sys/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>
#include<cstring>

namespace nt_server
{
    const uint16_t default_port = 8877;       // 默认端口号
    const std::string default_ip = "0.0.0.0"; // 默认IP
    const int backlog=5;//请求队列的最大长度

    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_);      // 我设置为默认是8877

            
            if(bind(sock_,(const sockaddr *)&local, sizeof(local))<0)
            {
                std::cout << "Bind IP&&Port 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::cout<<"TCP 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>
#include<cstring>
#include<unistd.h>

namespace nt_server
{
    const uint16_t default_port = 8877;       // 默认端口号
    const std::string default_ip = "0.0.0.0"; // 默认IP
    const int backlog=5;//请求队列的最大长度

    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_);      // 我设置为默认是8877

            
            if(bind(listen_sock_,(const sockaddr *)&local, sizeof(local))<0)
            {
                std::cout << "Bind IP&&Port 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 len=sizeof(client);
                int accept_socket=accept(listen_sock_,(struct sockaddr*)&client,&len);
                if(accept_socket<0)
                {
                    std::cout<<"accept failed"<<std::endl;
                    continue;
                }
                std::cout<<"get a new link...,sockfd:"<<accept_socket<<std::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>
#include<cstring>
#include<unistd.h>
#include<functional>

namespace nt_server
{
    const uint16_t default_port = 8877;       // 默认端口号
    const std::string default_ip = "0.0.0.0"; // 默认IP
    const int backlog=5;//请求队列的最大长度

    using func_t = std::function<std::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_);      // 我设置为默认是8877

            
            if(bind(listen_sock_,(const sockaddr *)&local, sizeof(local))<0)
            {
                std::cout << "Bind IP&&Port 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 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 iptr[32];
                inet_ntop(AF_INET,&(client.sin_addr),iptr,sizeof(iptr));//客户端IP

                std::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.hpp"

using 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_ptr<TcpServer> usvr (new TcpServer(echo,port));
    usvr->InitServer();
    usvr->StartServer();

    return 0;
}

好了，我们来测试

很完美啊，服务器收到了我们发的，对方也能收到

可是这个不是我们写的客户端，我们得自己去实现一下自己的客户端

1.3.客户端设计

话不多说，先看原理图

可以看到啊这个客户端的实现可比服务端简单的多。

client.cc

#include <iostream>
#include <memory>
#include "client.hpp"

using 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 ip=argv[1];
  uint16_t port = stoi(argv[2]);//将字符串转换成端口号

  unique_ptr<TcpClient> 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.h>

namespace 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_; // 服务器IP
        uint16_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>
#include<unistd.h>
#include<sys/wait.h>

namespace 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_; // 服务器IP
        uint16_t server_port_; // 服务器端口号
    };
}

client.cc

#include <iostream>
#include <memory>
#include "client.hpp"

using 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 ip=argv[1];
  uint16_t port = stoi(argv[2]);//将字符串转换成端口号

  unique_ptr<TcpClient> usvr (new TcpClient(ip,port));
    usvr->InitClient();
    usvr->StartClient();

    return 0;
}

1.4.测试

可以看到，当客户端向服务器发起连接请求时，服务器可以识别并接受连接，双方建立连接关系后，可以正常进行通信；当客户端主动退出（断开连接），服务器也能感知到，并判断出是谁断开了连接

当客户端已经和服务端成功连接上了，但是这个时候终止了服务端，我们此时立马重启服务器，会发现短期内无法再次启动服务（显示端口正在被占用），这是由于 TCP 协议断开连接时的特性导致的（正在处于 TIME_WAIT 状态），详细原因将会在后续博客中讲解

服务端关闭的时候，客户端还是存在连接的，但是发出消息之后，就会自动退出。

到目前为止我们的程序都是运行的挺好的，接下来我们再加入一个客户端看看

对于之前编写的字符串回响程序来说，如果只有一个客户端进行连接并通信，是没有问题的，但如果有多个客户端发起连接请求，并尝试进行通信，服务器是无法应对的

我们可以看看server.hpp的

  // 启动服务器
        void StartServer()
        {
            for(;;)
            {
                //1.获取新连接
               。。。。。。
                int accept_socket=accept(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)); // 客户端IP

                std::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);
        else
            break;
    }
    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"; // 默认IP
    const int backlog = 5;                    // 请求队列的最大长度

    using func_t = std::function<std::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_);                         // 我设置为默认是8877

            if (bind(listen_sock_, (const sockaddr *)&local, sizeof(local)) < 0)
            {
                std::cout << "Bind IP&&Port 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)); // 客户端IP

                std::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> // 信号处理相关头文件
#include<pthread.h>

namespace nt_server
{
    const uint16_t default_port = 8877;       // 默认端口号
    const std::string default_ip = "0.0.0.0"; // 默认IP
    const 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::function<std::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_);                         // 我设置为默认是8877

            if (bind(listen_sock_, (const sockaddr *)&local, sizeof(local)) < 0)
            {
                std::cout << "Bind IP&&Port 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)); // 客户端IP

                std::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_cast<ThreadData*>(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 client

server:server.cc
	g++ -o $@ $^ -std=c++11 -lpthread

	
client:client.cc
	g++ -o $@ $^ -std=c++11 -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; // 线程ID
    std::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)
    {
        ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(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 ThreadPool<T> *GetInstance()
    {
        if (nullptr == tp_) // 如果线程池对象不存在，则创建一个新的线程池对象
        {
            pthread_mutex_lock(&lock_); // 加锁保证线程安全
            if (nullptr == tp_) // 再次检查是否已经创建了线程池对象，防止多线程环境下的竞争条件
            {
                std::cout << "log: singleton create done first!" << std::endl;
                tp_ = new ThreadPool<T>(); // 创建线程池对象
            }
            pthread_mutex_unlock(&lock_); // 解锁
        }
 
        return tp_; // 返回线程池对象指针
    }
 
private:
    // 构造函数，初始化线程池，可以指定线程数量，默认为defalutnum
    ThreadPool(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 ThreadPool<T> &) = delete;
    const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
private:
    // 线程信息列表
    std::vector<ThreadInfo> threads_;
    // 任务队列
    std::queue<T> tasks_;
 
    // 互斥锁和条件变量用于同步和通信
    pthread_mutex_t mutex_;
    pthread_cond_t cond_;
 
    // 线程池单例对象指针和互斥锁静态成员变量
    static ThreadPool<T> *tp_;
    static pthread_mutex_t lock_;
};
 
// 初始化线程池单例对象指针和互斥锁静态成员变量
template <class T>
ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;
template <class T>
pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;

为了使用上面这个线程池，我们很快就能写出下面这些代码

 // 启动服务器
        void StartServer()
        {
            .......
            //线程池的设计--》使用之前必须先启动
                ThreadPool<Task>::GetInstance()->Start();
            
            for (;;)
            {
                ......
                 // 3.把任务交给线程池
                 Task task1(accept_socket,clientip,clientport);
                 ThreadPool<Task>::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>
#include<pthread.h>

using func_t = std::function<std::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_;//用户IP
    uint16_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>
#include<pthread.h>
#include"Threadpool.hpp"
#include"Task.hpp"

namespace nt_server
{
    const uint16_t default_port = 8877;       // 默认端口号
    const std::string default_ip = "0.0.0.0"; // 默认IP
    const 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::function<std::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_);                         // 我设置为默认是8877

            if (bind(listen_sock_, (const sockaddr *)&local, sizeof(local)) < 0)
            {
                std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
                exit(BIND_ERR);
            }

            if (listen(listen_sock_, backlog) < 0)
            {
                perror("Listen fail");
                exit(LIS_ERR);
            }
        }

        // 启动服务器
        void StartServer()
        {
            
            for (;;)
            {
                //线程池的设计--》使用之前必须先启动
                ThreadPool<Task>::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)); // 客户端IP

                std::cout << "Server accept " << clientip << " - " << clientport << " " << accept_socket << " from " << listen_sock_ << " success!" << std::endl;

                 
                 // 3.把任务交给线程池
                 Task task1(accept_socket,clientip,clientport,func_1);//和原来Server函数的参数差不多，这里还多传了一个回调函数
                 ThreadPool<Task>::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.hpp"

using 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_ptr<TcpServer> usvr (new TcpServer(echo,port));
    usvr->InitServer();
    usvr->StartServer();

    return 0;
}

我们可以检测一下

 ps -aL | head -1 &&ps -aL | grep server

可以看到一启动就有6个线程——一个主线程，5个是线程池里面的

我们连接看看

我们发现我们发送第一条信息是正常的，但是发第二条信息的时候没有成功，直接告诉我说断开连接了。

这个其实是正常的。因为我们也没有提供常服务，因为资源是有有限的。