🔭个人主页： 北 海🛜所属专栏： Linux学习之旅、神奇的网络世界💻操作环境： CentOS 7.6 阿里云远程服务器

文章目录

• 🌤️前言
• 🌦️正文
• TCP网络程序
• 1.字符串回响
• 1.1.核心功能
• 1.2.程序结构
• 服务器
• 1.3.初始化服务器
• 1.4.启动服务器
• 1.4.1.处理连接请求
• 1.4.2.业务处理
• 1.4.3.回调函数
• 1.5.服务器源文件
• 客户端
• 1.6.初始化客户端
• 1.7.启动客户端
• 1.7.1.尝试进行连接
• 1.7.2.业务处理
• 2.多进程版服务器
• 2.1.核心功能
• 2.2.创建子进程
• 2.3.设置非阻塞
• 3.多线程版服务器
• 3.1.核心功能
• 3.2.使用原生线程库
• 3.3.使用线程池
• 4.日志输出
• 4.1.日志的重要性
• 4.2.可变参数
• 4.3.日志器实现
• 4.4.应用于程序中
• 4.5.持久化存储
• 5.守护进程
• 5.1.会话、进程组、进程
• 5.2.守护进程化
• 6.完整代码
• 🌨️总结

🌤️前言

随着数字时代的来临，TCP网络程序已成为程序员不可或缺的技术领域。本博客将带领读者深入研究，从最基础的字符串回响开始，逐步探索至多进程、多线程服务器的高级实践。我们将详细探讨每个环节的核心功能和实现细节，致力于帮助读者深刻理解网络编程的本质。通过系统学习本博客内容，读者将获得构建稳健网络应用的重要技能，更加自信地应对日益复杂的软件开发挑战。这里将为你的编程旅程提供扎实的基础和深远的启示。

🌦️正文

TCP网络程序

接下来实现一批基于 TCP 协议的网络程序

1.字符串回响

1.1.核心功能

字符串回响程序类似于 echo 指令，客户端向服务器发送消息，服务器在收到消息后会将消息发送给客户端，该程序实现起来比较简单，同时能很好的体现 socket 套接字编程的流程

1.2.程序结构

这个程序我们已经基于 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>
#include "err.hpp"
 
namespace nt_server
{
    const uint16_t default_port = 8888; // 默认端口号
 
    class TcpServer
    {
    public:
        TcpServer(const uint16_t port = default_port)
            :port_(port)
        {}
 
        ~TcpServer()
        {}
 
        // 初始化服务器
        void InitServer()
        {}
 
        // 启动服务器
        void StartServer()
        {}
 
    private:
        int sock_; // 套接字（存疑）
        uint16_t port_; // 端口号
    };
}

注意： 这里的 sock_ 套接字成员后面需要修改

创建 server.cc 服务器源文件

复制
#include <memory> // 智能指针头文件
#include "server.hpp"
 
using namespace std;
using namespace nt_server;
 
int main()
{
    unique_ptr<TcpServer> usvr (new TcpServer());
 
    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
{
    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

最后为了方便判断程序错误，可以增加上一篇文章中的 err.hpp 头文件，里面包含错误码与简易错误信息

创建 err.hpp 错误码头文件

复制
#pragma once
 
enum
{
    USAGE_ERR = 1,
    SOCKET_ERR,
    BIND_ERR
};

接下来开始填充代码内容

服务器

1.3.初始化服务器

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

在使用 socket 函数创建套接字时，UDP 协议需要指定参数2为 SOCK_DGRAM，TCP 协议则是指定参数2为 SOCK_STREAM

注：关于 socket、bind、sockaddr 的细节，可以看看这篇文章《网络编程『socket套接字 ‖ 简易UDP网络程序』》

InitServer() 初始化服务器函数 — 位于 server.hpp 服务器头文件中的 TcpServer 类

复制
const uint16_t default_port = 8888; // 默认端口号
    
// 初始化服务器
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 = INADDR_ANY; // 绑定任意可用IP地址
    local.sin_port = htons(port_);
    
    if(bind(listensock_, (const sockaddr*)&local, sizeof(local)))
    {
        std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
        exit(BIND_ERR);
    }
            
    // 3.TODO
}

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

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

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

使用到的函数是 listen 函数

复制
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
 
int listen(int sockfd, int backlog);

参数解读：

• sockfd 通过该套接字进行监听
• backlog 全连接队列最大长度

返回值：监听成功返回 0，失败返回 -1

这里的参数2需要设置一个整数，通常为 16、32、64...，表示 全连接队列 的最大长度，关于 全连接队列 的详细知识放到后续博客中讲解，这里只需要直接使用

server.hpp 服务器头文件

复制
#pragma once
 
#include <iostream>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
 
namespace nt_server
{
    const uint16_t default_port = 8888; // 默认端口号
    const int backlog = 32; // 全连接队列的最大长度
 
    class TcpServer
    {
    public:
        TcpServer(const uint16_t port = default_port)
            :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 = INADDR_ANY; // 绑定任意可用IP地址
            local.sin_port = htons(port_);
 
            if(bind(listensock_, (const sockaddr*)&local, sizeof(local)))
            {
                std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
                exit(BIND_ERR);
            }
     
            // 3.监听
            if(listen(sock_, backlog) == -1)
            {
                std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
                exit(LISTEN_ERR);
            }
 
            std::cout << "Listen Success!" << std::endl;
        }
 
        // 启动服务器
        void StartServer()
        {}
 
    private:
        int sock_; // 套接字（存疑）
        uint16_t port_; // 端口号
    };
}

至此基于 TCP 协议实现的初始化服务器函数就填充完成了，编译并运行服务器，显示初始化服务器成功

1.4.启动服务器

1.4.1.处理连接请求

TCP 是面向连接，当有客户端发起连接请求时，TCP 服务器需要正确识别并尝试进行连接，当连接成功时，与其进行通信，可使用 accept 函数进行连接

复制
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
 
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

参数解读：

• sockfd 服务器用于处理连接请求的 socket 套接字
• addr 客户端的 sockaddr 结构体信息
• addrlen 客户端的 sockaddr 结构体大写

其中 addr 与 addrlen 是一个 输入输出型 参数，类似于 recvfrom 中的参数

返回值：连接成功返回一个用于通信的 socket 套接字（文件描述符），失败返回 -1

这也就意味着之前我们在 TcpServer 中创建的类内成员 sock_ 并非是用于通信，而是专注于处理连接请求，在 TCP 服务器中，这种套接字称为 监听套接字

使用 accept 函数处理连接请求

server.hpp 服务器头文件

复制
#pragma once
 
#include <iostream>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
 
namespace nt_server
{
    const uint16_t default_port = 8888; // 默认端口号
    const int backlog = 32; // 全连接队列的最大长度
 
    class TcpServer
    {
    public:
        TcpServer(const uint16_t port = default_port)
            :port_(port), quit_(false)
        {}
 
        ~TcpServer()
        {}
 
        // 初始化服务器
        void InitServer()
        {
            // 1.创建监听套接字
            listensock_ = socket(AF_INET, SOCK_STREAM, 0);
            if(listensock_ == -1)
            {
                std::cerr << "Create ListenSocket Fail!" << strerror(errno) << std::endl;
                exit(SOCKET_ERR);
            }
 
            std::cout << "Create ListenSocket Success! " << listensock_ << std::endl;
 
            // 2.绑定IP地址与端口号
            struct sockaddr_in local;
            memset(&local, 0, sizeof(local)); // 清零
            local.sin_family = AF_INET;
            local.sin_addr.s_addr = INADDR_ANY; // 绑定任意可用IP地址
            local.sin_port = htons(port_);
 
 
            if(bind(listensock_, (const sockaddr*)&local, sizeof(local)))
            {
                std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
                exit(BIND_ERR);
            }
     
            // 3.监听
            if(listen(listensock_, backlog) == -1)
            {
                std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
                exit(LISTEN_ERR);
            }
 
            std::cout << "Listen Success!" << std::endl;
        }
 
        // 启动服务器
        void StartServer()
        {
            while(!quit_)
            {
                // 1.处理连接请求
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
 
                int sock = accept(listensock_, (struct sockaddr*)&client, &len);
 
                // 2.如果连接失败，继续尝试连接
                if(sock == -1)
                {
                    std::cerr << "Accept Fail!" << strerror(errno) << std::endl;
                    continue;
                }
 
                // 连接成功，获取客户端信息
                std::string clientip = inet_ntoa(client.sin_addr);
                uint16_t clientport = ntohs(client.sin_port);
 
                std::cout << "Server accept " << clientip + "-" << clientport << " " << sock << " from " << listensock_ << " success!" << std::endl;
 
                // 3.根据 sock 套接字进行通信
                Service(sock, clientip, clientport);
            }
        }
 
    private:
        int listensock_; // 监听套接字
        uint16_t port_; // 端口号
        bool quit_; // 判断服务器是否结束运行
    };
}

1.4.2.业务处理

对于 TCP 服务器来说，它是面向字节流传输的，我们之前使用的文件相关操作也是面向字节流，凑巧的是在 Linux 中网络是以挂接在文件系统的方式实现的，种种迹象表明：可以通过文件相关接口进行通信

• read 从文件中读取信息（接收消息）
• write 向文件中写入信息（发送消息）

这两个系统调用的核心参数是 fd（文件描述符），即服务器与客户端在连接成功后，获取到的 socket 套接字，所以接下来可以按文件操作的套路，完成业务处理

Service() 业务处理函数 — 位于 server.hpp 服务器头文件中的 TcpServer 类

复制
// 业务处理
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;
        }
    }
}

1.4.3.回调函数

为了更好的实现功能解耦，这里将真正的业务处理函数交给上层处理，编写完成后传给 TcpServer 对象即可，当然，在 TcpServer 类中需要添加对应的类型

这里设置回调函数的返回值为 string，参数同样为 string

server.hpp 服务器头文件

复制
#pragma once
 
#include <iostream>
#include <string>
#include <functional>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
 
namespace nt_server
{
    const uint16_t default_port = 8888; // 默认端口号
    const int backlog = 32;             // 全连接队列的最大长度
 
    using func_t = std::function<std::string(std::string)>; // 回调函数类型
 
    class TcpServer
    {
    public:
        TcpServer(const func_t &func, const uint16_t port = default_port)
            : func_(func), port_(port), quit_(false)
        {
        }
 
        ~TcpServer()
        {
        }
 
        // 初始化服务器
        void InitServer()
        {
            // 1.创建监听套接字
            listensock_ = socket(AF_INET, SOCK_STREAM, 0);
            if (listensock_ == -1)
            {
                std::cerr << "Create ListenSocket Fail!" << strerror(errno) << std::endl;
                exit(SOCKET_ERR);
            }
 
            std::cout << "Create ListenSocket Success! " << listensock_ << std::endl;
 
            // 2.绑定IP地址与端口号
            struct sockaddr_in local;
            memset(&local, 0, sizeof(local)); // 清零
            local.sin_family = AF_INET;
            local.sin_addr.s_addr = INADDR_ANY; // 绑定任意可用IP地址
            local.sin_port = htons(port_);
 
            if (bind(listensock_, (const sockaddr *)&local, sizeof(local)))
            {
                std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
                exit(BIND_ERR);
            }
 
            // 3.监听
            if (listen(listensock_, backlog) == -1)
            {
                std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
                exit(LISTEN_ERR);
            }
 
            std::cout << "Listen Success!" << std::endl;
        }
 
        // 启动服务器
        void StartServer()
        {
            while (!quit_)
            {
                // 1.处理连接请求
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
 
                int sock = accept(listensock_, (struct sockaddr *)&client, &len);
 
                // 2.如果连接失败，继续尝试连接
                if (sock == -1)
                {
                    std::cerr << "Accept Fail!" << strerror(errno) << std::endl;
                    continue;
                }
 
                // 连接成功，获取客户端信息
                std::string clientip = inet_ntoa(client.sin_addr);
                uint16_t clientport = ntohs(client.sin_port);
 
                std::cout << "Server accept " << clientip + "-" << clientport << " " << sock << " from " << listensock_ << " success!" << std::endl;
 
                // 3.根据 sock 套接字进行通信
                Service(sock, clientip, 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 listensock_; // 监听套接字
        uint16_t port_;  // 端口号
        bool quit_;      // 判断服务器是否结束运行
        func_t func_;    // 回调函数
    };
}

服务器头文件准备完成，接下来就是填充 server.cc 服务器源文件

1.5.服务器源文件

对于当前的 TCP 网络程序（字符串回响）来说，业务处理函数逻辑非常简单，无非就是直接将客户端发送过来的消息，重新转发给客户端

server.cc 服务器源文件

复制
#include <memory> // 智能指针头文件
#include <string>
#include "server.hpp"
 
using namespace std;
using namespace nt_server;
 
// 业务处理回调函数（字符串回响）
string echo(string request)
{
    return request;
}
 
int main()
{
    unique_ptr<TcpServer> usvr (new TcpServer(echo)); // 将回调函数进行传递
 
    usvr->InitServer();
    usvr->StartServer();
    return 0;
}

尝试编译并运行服务器，可以看到当前 bash 已经被我们的服务器程序占用了，重新打开一个终端，并通过 netstat 命令查看网络使用情况（基于 TCP 协议）

复制
netstat -nltp

当前服务确实使用的是 8888 端口，并且采用的是 TCP 协议

客户端

1.6.初始化客户端

对于客户端来说，服务器的 IP 地址与端口号是两个不可或缺的元素，因此在客户端类中，server_ip 和 server_port 这两个成员是少不了的，当然得有 socket 套接字

初始化客户端只需要干一件事：创建套接字，客户端是主动发起连接请求的一方，也就意味着它不需要使用 listen 函数设置为监听状态

注意： 客户端也是需要 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>
#include "err.hpp"
 
namespace nt_client
{
    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_; // 服务器端口号
    };
}

编译并运行客户端，显示 socket 套接字创建成功

1.7.启动客户端

1.7.1.尝试进行连接

因为 TCP 协议是面向连接的，服务器已经处于处理连接请求的状态了，客户端现在需要做的就是尝试进行连接，使用 connect 函数进行连接

复制
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
 
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数解读：

• sockfd 需要进行连接的套接字
• addr 服务器的 sockaddr 结构体信息
• addrlen 服务器的 sockaddr 结构体大小

返回值：连接成功返回 0，连接失败返回 -1

在连接过程中，可能遇到很多问题，比如 网络传输失败、服务器未启动 等，这些问题的最终结果都是客户端连接失败，如果按照之前的逻辑（失败就退出），那么客户端的体验感会非常不好，因此在面对连接失败这种常见问题时，客户端应该尝试重连，如果重连数次后仍然失败，才考虑终止进程

注意： 在进行重连时，可以使用 sleep() 等函数使程序睡眠一会，给网络恢复留出时间

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;
 
    // 进行业务处理
    // Service();
}  

当然相应的错误码也得添加

err.hpp 错误码头文件

复制
#pragma once
 
enum
{
    USAGE_ERR = 1,
    SOCKET_ERR,
    BIND_ERR,
    LISTEN_ERR,
    CONNECT_ERR
};

现在先不启动服务器，编译并启动客户端，模拟连接失败的情况

如果在数秒之后启动再服务器，可以看到重连成功

这种重连机制在实际中非常常见，出现这种

1.7.2.业务处理

客户端在进行业务处理时，同样可以使用 read 和 write 进行网络通信

Service() 业务处理函数 — 位于 client.hpp 客户端头文件中的 TcpClient 类

复制
// 业务处理
void Service()
{
    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;
        }
    }
}

至此整个 基于 TCP 协议的字符串回响程序 就完成了，下面来看看效果

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

如果在通信过程中，服务器主动断开了连接，客户端也能感知到

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

2.多进程版服务器

2.1.核心功能

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

原因在于 服务器是一个单进程版本，处理连接请求 和 业务处理 是串行化执行的，如果想处理下一个连接请求，需要把当前的业务处理完成

具体表现为下面这种情况

为什么客户端B会显示当前已经连接成功？ 这是因为是客户端是主动发起连接请求的一方，在请求发出后，如果出现连接错误，客户端就认为已经连接成功了，但实际上服务器还没有处理这个连接请求

这显然是服务器的问题，处理连接请求 与 业务处理 应该交给两个不同的执行流完成，可以使用多进程或者多线程解决，这里先采用多进程的方案

所以当前需要实现的网络程序核心功能为：当服务器成功处理连接请求后，fork 新建一个子进程，用于进行业务处理，原来的进程专注于处理连接请求

2.2.创建子进程

注：当前的版本的修改只涉及 StartServer() 函数

创建子进程使用 fork() 函数，它的返回值含义如下

• ret == 0 表示创建子进程成功，接下来执行子进程的代码
• ret > 0 表示创建子进程成功，接下来执行父进程的代码
• ret < 0 表示创建子进程失败

子进程创建成功后，会继承父进程的文件描述符表，能轻而易举的获取客户端的 socket 套接字，从而进行网络通信

当然不止文件描述符表，得益于 写时拷贝 机制，子进程还会共享父进程的变量，当发生修改行为时，才会自己创建

注意： 当子进程取走客户端的 socket 套接字进行通信后，父进程需要将其关闭（因为它不需要了），避免文件描述符泄漏

StartServer() 服务器启动函数 — 位于 server.hpp 的 TcpServer 类

复制
// 进程创建、等待所需要的头文件
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
 
// 启动服务器
void StartServer()
{
    while (!quit_)
    {
        // 1.处理连接请求
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
 
        int sock = accept(listensock_, (struct sockaddr *)&client, &len);
 
        // 2.如果连接失败，继续尝试连接
        if (sock == -1)
        {
            std::cerr << "Accept Fail!" << strerror(errno) << std::endl;
            continue;
        }
 
        // 连接成功，获取客户端信息
        std::string clientip = inet_ntoa(client.sin_addr);
        uint16_t clientport = ntohs(client.sin_port);
 
        std::cout << "Server accept " << clientip + "-" << clientport << " " << sock << " from " << listensock_ << " success!" << std::endl;
 
        // 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); // 子进程退出
        }
        else
        {
            // 父进程需要等待子进程
            pid_t ret = waitpid(id, nullptr, 0); // 默认为阻塞式等待
 
            if(ret == id)
                std::cout << "Wait " << id << " success!";
        }
 
    }
}

虽然此时成功创建了子进程，但父进程（处理连接请求）仍然需要等待子进程退出后，才能继续运行，说白了就是 父进程现在处于阻塞等待状态，需要设置为 非阻塞等待

2.3.设置非阻塞

设置父进程为非阻塞的方式有很多，这里来一一列举

方式一：通过参数设置为非阻塞等待（不推荐）

可以直接给 waitpid() 函数的参数3传递 WNOHANG，表示当前为 非阻塞等待

详见 《Linux进程控制【创建、终止、等待】》

复制
pid_t ret = waitpid(id, nullptr, WNOHANG); // 设置为非阻塞式等待

这种方法可行，但不推荐，原因如下：虽然设置成了非阻塞式等待，但父进程终究是需要通过 waitpid() 函数来尝试等待子进程，倘若父进程一直卡在 accept() 函数处，会导致子进程退出后暂时无人收尸，进而导致资源泄漏

方式二：忽略 SIGCHLD 信号（推荐使用）

这是一个子进程在结束后发出的信号，默认动作是什么都不做；父进程需要检测并回收子进程，我们可以直接忽略该信号，这里的忽略是个特例，只是父进程不对其进行处理，转而由 操作系统 对其负责，自动清理资源并进行回收，不会产生 僵尸进程

详见 《Linux进程信号【信号处理】》

直接在 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); // 子进程退出
        }
 
    }
}

强烈推荐使用该方案，因为操作简单，并且没有后患之忧

方式三：设置 SIGCHLD 信号的处理动作为子进程回收（不是很推荐）

当子进程退出并发送该信号时，执行父进程回收子进程的操作

详见 《Linux进程信号【信号处理】》

设置 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(sock);
            std::cerr << "Fork Fail!" << std::endl;
        }
        else if(id == 0)
        {
            // 子进程内
            close(listensock_); // 子进程不需要监听（建议关闭）
 
            // 执行业务处理函数
            Service(sock, clientip, clientport);
 
            exit(0); // 子进程退出
        }
 
    }
}

为什么不是很推荐这种方法？因为这种方法实现起来比较麻烦，不如直接忽略 SIGCHLD 信号

方式四：设置孙子进程（不是很推荐）

众所周知，父进程只需要对子进程负责，至于孙子进程交给子进程负责，如果某个子进程的父进程终止运行了，那么它就会变成 孤儿进程，父进程会变成 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 信号

至此我们的 字符串回响程序 可以支持多客户端了

细节补充：当子进程取走 sock 套接字进行网络通信后，父进程就不需要使用 sock 套接字了，可以将其进行关闭，下次连接时继续使用，避免文件描述符不断增长

StartServer() 服务器启动函数 — 位于 server.hpp 服务器头文件中的 TcpServer 类

复制
// 启动服务器
void StartServer()
{
    // 忽略 SIGCHLD 信号
    signal(SIGCHLD, SIG_IGN);
 
    while (!quit_)
    {
        // 1.处理连接请求
        // ...
 
        // 2.如果连接失败，继续尝试连接
        // ...
 
        // 连接成功，获取客户端信息
        // ...
 
        // 3.创建子进程
        // ...
 
        close(sock); // 父进程不再需要资源（建议关闭）
    }
}

这个补丁可以减少资源消耗，建议加上，前面是忘记加了，并且不太好修改，server.hpp 服务器头文件完整代码如下

复制
#pragma once
 
#include <iostream>
#include <string>
#include <functional>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <signal.h> // 信号处理相关头文件
#include <sys/wait.h> // 进程等待时需要包含该头文件
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
 
namespace nt_server
{
    const uint16_t default_port = 8888; // 默认端口号
    const int backlog = 32;             // 全连接队列的最大长度
 
    using func_t = std::function<std::string(std::string)>; // 回调函数类型
 
    class TcpServer
    {
    public:
        TcpServer(const func_t &func, const uint16_t port = default_port)
            : func_(func), port_(port), quit_(false)
        {
        }
 
        ~TcpServer()
        {
        }
 
        // 初始化服务器
        void InitServer()
        {
            // 1.创建监听套接字
            listensock_ = socket(AF_INET, SOCK_STREAM, 0);
            if (listensock_ == -1)
            {
                std::cerr << "Create ListenSocket Fail!" << strerror(errno) << std::endl;
                exit(SOCKET_ERR);
            }
 
            std::cout << "Create ListenSocket Success! " << listensock_ << std::endl;
 
            // 2.绑定IP地址与端口号
            struct sockaddr_in local;
            memset(&local, 0, sizeof(local)); // 清零
            local.sin_family = AF_INET;
            local.sin_addr.s_addr = INADDR_ANY; // 绑定任意可用IP地址
            local.sin_port = htons(port_);
 
            if (bind(listensock_, (const sockaddr *)&local, sizeof(local)))
            {
                std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
                exit(BIND_ERR);
            }
 
            // 3.监听
            if (listen(listensock_, backlog) == -1)
            {
                std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
                exit(LISTEN_ERR);
            }
 
            std::cout << "Listen Success!" << std::endl;
        }
 
        // 启动服务器
        void StartServer()
        {
            // 忽略 SIGCHLD 信号
            signal(SIGCHLD, SIG_IGN);
 
            while (!quit_)
            {
                // 1.处理连接请求
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
 
                int sock = accept(listensock_, (struct sockaddr *)&client, &len);
 
                // 2.如果连接失败，继续尝试连接
                if (sock == -1)
                {
                    std::cerr << "Accept Fail!" << strerror(errno) << std::endl;
                    continue;
                }
 
                // 连接成功，获取客户端信息
                std::string clientip = inet_ntoa(client.sin_addr);
                uint16_t clientport = ntohs(client.sin_port);
 
                std::cout << "Server accept " << clientip + "-" << clientport << " " << sock << " from " << listensock_ << " success!" << std::endl;
 
                // 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); // 子进程退出
                }
 
                close(sock); // 父进程不再需要资源（必须关闭）
            }
        }
 
        // 业务处理
        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 listensock_; // 监听套接字
        uint16_t port_;  // 端口号
        bool quit_;      // 判断服务器是否结束运行
        func_t func_;    // 回调函数
    };
}

3.多线程版服务器

3.1.核心功能

通过多线程，实现支持多客户端同时通信的服务器

核心功能：服务器与客户端成功连接后，创建一个线程，服务于客户端的业务处理

这里先通过 原生线程库 模拟实现

3.2.使用原生线程库

关于 原生线程库 中对于线程的操作可以看看这篇文章《Linux多线程【线程控制】》

线程的回调函数中需要 Service() 业务处理函数中的所有参数，同时也需要具备访问 Service() 业务处理函数的能力，单凭一个 void* 的参数是无法解决的，为此可以创建一个类，里面可以包含我们所需要的参数

ThreadData 类 — 位于 server.hpp 服务器头文件中

复制
// 包含我们所需参数的类型
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 <string>
#include <functional>
#include <cerrno>
#include <cstring>
#include <pthread.h> // 原生线程库
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
 
namespace nt_server
{
    const uint16_t default_port = 8888; // 默认端口号
    const int backlog = 32;             // 全连接队列的最大长度
 
    using func_t = std::function<std::string(std::string)>; // 回调函数类型
 
    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 对象的指针
    };
 
    class TcpServer
    {
    public:
        TcpServer(const func_t &func, const uint16_t port = default_port)
            : func_(func), port_(port), quit_(false)
        {
        }
 
        ~TcpServer()
        {
        }
 
        // 初始化服务器
        void InitServer()
        {
            // 1.创建监听套接字
            listensock_ = socket(AF_INET, SOCK_STREAM, 0);
            if (listensock_ == -1)
            {
                std::cerr << "Create ListenSocket Fail!" << strerror(errno) << std::endl;
                exit(SOCKET_ERR);
            }
 
            std::cout << "Create ListenSocket Success! " << listensock_ << std::endl;
 
            // 2.绑定IP地址与端口号
            struct sockaddr_in local;
            memset(&local, 0, sizeof(local)); // 清零
            local.sin_family = AF_INET;
            local.sin_addr.s_addr = INADDR_ANY; // 绑定任意可用IP地址
            local.sin_port = htons(port_);
 
            if (bind(listensock_, (const sockaddr *)&local, sizeof(local)))
            {
                std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
                exit(BIND_ERR);
            }
 
            // 3.监听
            if (listen(listensock_, backlog) == -1)
            {
                std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
                exit(LISTEN_ERR);
            }
 
            std::cout << "Listen Success!" << std::endl;
        }
 
        // 启动服务器
        void StartServer()
        {
            while (!quit_)
            {
                // 1.处理连接请求
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
 
                int sock = accept(listensock_, (struct sockaddr *)&client, &len);
 
                // 2.如果连接失败，继续尝试连接
                if (sock == -1)
                {
                    std::cerr << "Accept Fail!" << strerror(errno) << std::endl;
                    continue;
                }
 
                // 连接成功，获取客户端信息
                std::string clientip = inet_ntoa(client.sin_addr);
                uint16_t clientport = ntohs(client.sin_port);
 
                std::cout << "Server accept " << clientip + "-" << clientport << " " << sock << " from " << listensock_ << " success!" << std::endl;
 
                // 3.创建线程及所需要的线程信息类
                ThreadData* td = new ThreadData(sock, 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;
        }
 
        // 业务处理
        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 listensock_; // 监听套接字
        uint16_t port_;  // 端口号
        bool quit_;      // 判断服务器是否结束运行
        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

接下来就是编译并运行程序，可以看到 当前只有一个进程，同时有五个线程在运行

使用 原生线程库 过于单薄了，并且这种方式存在问题：连接都准备好了，才创建线程，如果创建线程所需要的资源较多，会拖慢服务器整体连接效率

为此可以改用之前实现的 线程池

3.3.使用线程池

之前在 《Linux多线程【线程池】》一文中实现了多个版本的线程池，这里我们直接使用最终版，也就是 单例模式版线程池

部分组件不需要修改，代码如下：

ThreadPool.hpp 线程池头文件

复制
#pragma once
 
#include <vector>
#include <string>
#include <memory>
#include <functional>
#include <unistd.h>
#include <pthread.h>
#include "Task.hpp"
#include "Thread.hpp"
#include "BlockingQueue.hpp" // CP模型
 
namespace Yohifo
{
#define THREAD_NUM 10
 
    template<class T>
    class ThreadPool
    {
    private:
        ThreadPool(int num = THREAD_NUM)
            :_num(num)
        {
        }
 
        ~ThreadPool()
        {
            // 等待线程退出
            for(auto &t : _threads)
                t.join();
        }
 
        // 删除拷贝构造
        ThreadPool(const ThreadPool<T> &) = delete;
 
    public:
        static ThreadPool<T>* getInstance()
        {
            // 双检查
            if(_inst == nullptr)
            {
                // 加锁
                LockGuard lock(&_mtx);
                if(_inst == nullptr)
                {
                    // 创建对象
                    _inst = new ThreadPool<T>();
 
                    // 初始化及启动服务
                    _inst->init();
                    _inst->start();
                }
            }
 
            return _inst;
        }
 
    public:
        void init()
        {
            // 创建一批线程
            for(int i = 0; i < _num; i++)
                _threads.push_back(Thread(i, threadRoutine, this));
        }
 
        void start()
        {
            // 启动线程
            for(auto &t : _threads)
                t.run();
        }
 
        // 提供给线程的回调函数（已修改返回类型为 void）
        static void threadRoutine(void *args)
        {
            // 避免等待线程，直接剥离
            pthread_detach(pthread_self());
 
            auto ptr = static_cast<ThreadPool<T>*>(args);
 
            while (true)
            {
                // 从CP模型中获取任务
                T task = ptr->popTask();
 
                task(); // 回调函数
            }
        }
 
        // 装载任务
        void pushTask(const T& task)
        {
            _blockqueue.Push(task);
        }
    
    protected:
        T popTask()
        {
            T task;
            _blockqueue.Pop(&task);
 
            return task;
        }
 
    private:
        std::vector<Thread> _threads;
        int _num; // 线程数量
        BlockQueue<T> _blockqueue; // 阻塞队列
 
        // 创建静态单例对象指针及互斥锁
        static ThreadPool<T> *_inst;
        static pthread_mutex_t _mtx;
    };
 
    // 初始化指针
    template<class T>
    ThreadPool<T>* ThreadPool<T>::_inst = nullptr;
 
    // 初始化互斥锁
    template<class T>
    pthread_mutex_t ThreadPool<T>::_mtx = PTHREAD_MUTEX_INITIALIZER;
}