网络（TCP）-EW帮帮网

可以理解为我们所要的那个套接字他是属于什么AF_INET，将来是使用IPv4还是IPv6网络通信的，还是有叫本地通信也叫作域间通信，第二个参数是socket对应的类型，udp是面向用户数据报（SOCK_DGRAM），tcp是面向字节流的，第三个参数不用填，协议类型，创建一个套接字的本质就是打开一个文件，必须要告诉服务器，端口号，然后再绑定套接字端口号

不同类型（第一个参数的）

第二个：定义的套接字的类型

第三个写0就可以

下面介绍程序中用到的socket API,这些函数都在sys/socket.h中。socket():

socket()打开一个网络通讯端口,如果成功的话,就像open()一样返回一个文件描述符;

应用程序可以像读写文件一样用read/write在网络上收发数据;

如果socket()调用出错则返回-1;

对于IPv4, family参数指定为AF_INET;

对于TCP协议,type参数指定为SOCK_STREAM, 表示面向字节流的传输协议

protocol参数的介绍从略,指定为0即可。

bind():

服务器程序所监听的网络地址和端口号通常是固定不变的,客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接; 服务器需要调用bind绑定一个固定的网络地址和端口号;

bind()成功返回0,失败返回-1。

bind()的作用是将参数sockfd和myaddr绑定在一起, 使sockfd这个用于网络通讯的文件描述符监听myaddr所描述的地址和端口号;

前面讲过,struct sockaddr *是一个通用指针类型,myaddr参数实际上可以接受多种协议的sockaddr结构体,而它们的长度各不相同,所以需要第三个参数addrlen指定结构体的长度;

我们的程序中对myaddr参数是这样初始化的:

1. 将整个结构体清零;

2. 设置地址类型为AF_INET;

3. 网络地址为INADDR_ANY, 这个宏表示本地的任意IP地址,因为服务器可能有多个网卡,每个网卡也可能绑定多个IP 地址, 这样设置可以在所有的IP地址上监听,直到与某个客户端建立了连接时才确定下来到底用哪个IP 地址;

4. 端口号为SERV_PORT, 我们定义为9999

listen():

isten()声明sockfd处于监听状态, 并且最多允许有backlog个客户端处于连接等待状态, 如果接收到更多的连接请求就忽略, 这里设置不会太大(一般是5), 具体细节同学们课后深入研究;

listen()成功返回0,失败返回-1;

accept():

三次握手完成后, 服务器调用accept()接受连接;

如果服务器调用accept()时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来;

addr是一个传出参数,accept()返回时传出客户端的地址和端口号;

如果给addr 参数传NULL,表示不关心客户端的地址;

addrlen参数是一个传入传出参数(value-result argument), 传入的是调用者提供的, 缓冲区addr的长度以避免缓冲区溢出问题, 传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区);

我们的服务器程序结构是这样的:

理解accecpt的返回值: 饭店拉客例子

connect

客户端需要调用connect()连接服务器;

connect和bind的参数形式一致, 区别在于bind的参数是自己的地址, 而connect的参数是对方的地址;

connect()成功返回0,出错返回-1;

区别

tcp服务器和udp类似的部分代码

#pragma once
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;

const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
enum
{
    SocketError = 2,
    BindError
};

class TcpServer
{
public:
    TcpServer(const uint16_t &port, const string &ip = defaultip) : sockfd_(defaultfd), port_(port), ip_(ip)
    {
    }
    void InitServer()
    {
        sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd_ < 0)
        {
            FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
            exit(SocketError);
        }
        INFO("create socket,success,sockfd:%d", sockfd_);
        // 本地信息，这里只是栈里定义的变量
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 初始化清零
        // 填充网络信息
        local.sin_family = AF_INET;
        // 端口号是要发进网络里的，要主机序列转网络序列
        local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
        /*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
        但有风险        */
        inet_aton(ip_.c_str(), &(local.sin_addr));
        // 开始绑定
        int k = bind(sockfd_, (struct sockaddr *)(&local), sizeof(local));
        if (k < 0)
        {
            FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(BindError);
        }
    }
    void Start()
    {
    }

    ~TcpServer()
    {
    }

private:
    // IP和端口号需要用户构建服务器时就要告诉我了，
    int sockfd_;    // 网络文件描述符
    uint16_t port_; // 端口号
    string ip_;     // 字符串风格的ip
};

把套接字设置为监听状态（listen）

第二个参数一般不要设置太大

#pragma once
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;

const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10;//listen的第二个参数
enum
{
    UsageError = 1,
    SocketError,
    BindError,
    ListenError
};

class TcpServer
{
public:
    TcpServer(const uint16_t &port, const string &ip = defaultip) : sockfd_(defaultfd), port_(port), ip_(ip)
    {
    }
    void InitServer()
    {
        //                          字节流
        sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd_ < 0)
        {
            FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
            exit(SocketError);
        }
        INFO("create socket,success,sockfd:%d", sockfd_);
        // 本地信息，这里只是栈里定义的变量
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 初始化清零
        // 填充网络信息
        local.sin_family = AF_INET;
        // 端口号是要发进网络里的，要主机序列转网络序列
        local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
        /*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
        但有风险        */
        inet_aton(ip_.c_str(), &(local.sin_addr));
        // 开始绑定
        int k = bind(sockfd_, (struct sockaddr *)(&local), sizeof(local));
        if (k < 0)
        {
            FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(BindError);
        }
        INFO("bind socket,success,sockfd:%d", sockfd_);

        //TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
        int ls = listen(sockfd_, backlog);
        if(ls < 0)
        {
            FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(ListenError);
        }
        INFO("listen socket,success,sockfd:%d", sockfd_);

    }
    void Start()
    {
        for(; ;)
        {
            sleep(1);
            INFO("tcpServer success.....");
        }
    }

    ~TcpServer()
    {
    }

private:
    // IP和端口号需要用户构建服务器时就要告诉我了，
    int sockfd_;    // 网络文件描述符
    uint16_t port_; // 端口号
    string ip_;     // 字符串风格的ip
};

#include"TcpServer.hpp"
#include<iostream>
#include<memory>
using namespace std;

void Usage(string proc)
{
    cout<< "\n\rUsage:" << proc << "port[1024+]\n" << endl; 
}

//./tcpserver 8888
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(UsageError);
    }
    uint16_t port = stoi(argv[1]);
    unique_ptr<TcpServer> server(new TcpServer(port));
    server->InitServer();
    server->Start();




    return 0;
}

测试

查看端口号和IP地址（netstat -naup）

accept代码实现

都可以帮助我们知道是哪个客户端在连接我们

返回值：

成功返回一个文件描述符

sockfd是真正的服务者，sockfd_是"拉客的" 。

把所有的sockfd_改为listensock_

获取失败了不会直接结束，会继续获取，就像拉客，有的人拒绝了，直接去拉别的客户就好了

阻塞状态没有顾客就没有accept到

测试：

#pragma once
#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;

const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10;//listen的第二个参数
enum
{
    UsageError = 1,
    SocketError,
    BindError,
    ListenError
};

class TcpServer
{
public:
    TcpServer(const uint16_t &port, const string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
    {
    }
    void InitServer()
    {
        //                          字节流
        listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensockfd_ < 0)
        {
            FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
            exit(SocketError);
        }
        INFO("create socket,success,listensockfd_:%d", listensockfd_);
        // 本地信息，这里只是栈里定义的变量
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 初始化清零
        // 填充网络信息
        local.sin_family = AF_INET;
        // 端口号是要发进网络里的，要主机序列转网络序列
        local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
        /*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
        但有风险        */
        inet_aton(ip_.c_str(), &(local.sin_addr));
        // 开始绑定
        int k = bind(listensockfd_, (struct sockaddr *)(&local), sizeof(local));
        if (k < 0)
        {
            FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(BindError);
        }
        INFO("bind socket,success,listensockfd_:%d", listensockfd_);

        //TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
        int ls = listen(listensockfd_, backlog);
        if(ls < 0)
        {
            FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(ListenError);
        }
        INFO("listen socket,success,listensockfd_:%d", listensockfd_);

    }
    void Start()
    {
        INFO("tcpserver is running");
        for(; ;)
        {
            //1.重新获取
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            //阻塞状态
            int sockfd = accept(listensockfd_, (struct sockaddr*)(&client), &len);
            if(sockfd < 0)
            {
                WARN("accept errno,error:%d,errstring:%s", errno, strerror(errno));
                continue;
            }
            //2.根据新连接来进行通信
            INFO("get a new link..., sockfd:%d\n", sockfd);
        }
    }

    ~TcpServer()
    {
    }

private:
    // IP和端口号需要用户构建服务器时就要告诉我了，
    int listensockfd_;    // 网络文件描述符
    uint16_t port_; // 端口号
    string ip_;     // 字符串风格的ip
};

现在没有创建客户端，如何测试服务器呢

telnet

输入ctrl + ] 就可以了再回车就可以发信息了 quit是退出，要想退出再ctrl ] quit就可以了

tcp和udp都不能绑定自己云服务器的公网IP

127.0.0.1可以

tcp中使用的网络转主机函数

inet_ntop

inet_aton

inet_pton

服务测试代码read write

写一个客户端

tcp客户端要绑定，但不用显示的绑定

客户端端口号是随机的，但是唯一的

udp端口那里随机绑定是首次发送数据的时候，那么你的端口号就随之确定了

tcp这里是面向连接的，客户端连接成功了，我才想让你进行通信

没有bind 也就没有listen了

向服务器发起连接的接口 connect

客户端发起connect的时候,系统进行自动随机bind

连接时服务器的IP和端口必须知道，要不然往哪连接

#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;

void Usage(string proc)
{
    cout<< "\n\rUsage:" << proc << "serverip serverport\n" << endl; 
}


//./tcpclient serverip serverport
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip = argv[1];
    uint16_t serverport = stoi(argv[2]);

    //tcp是面向连接的，客户端连接成功了，我才想让你进行通信
    //没有bind 也就没有listen了

    //网络文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        cerr << "socket error" << endl;   
        return 1;
    }
    
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));

    //向服务器发起连接的接口 connect
    //客户端发起connect的时候,系统进行自动随机bind
    int n = connect(sockfd, (struct sockaddr*)&server, sizeof(server));
    if(n < 0)
    {
        cerr<< "connect error" <<endl;
        return 2;
    }
    //连接成功了
    //给对方发消息
    string message;
    while(true)
    {
        cout<< "Please Enter#" ;
        getline(cin, message);

        //把数据写给对方
        write(sockfd, message.c_str(), message.size());

        //对方服务器又会给写回来
        char inbuffer[4096];
        int n = read(sockfd, inbuffer, sizeof(inbuffer));//写进inbuffer
        if(n > 0)//读成功了
        {
            inbuffer[n] = 0;//字符串以0结尾
            cout<< inbuffer << endl;//返回什么就打印什么
        }

    }

    close(sockfd);
    return 0;
}

测试：

tcp基本代码基本完成了已经

TcpClient.cc

#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;

void Usage(string proc)
{
    cout<< "\n\rUsage:" << proc << "serverip serverport\n" << endl; 
}


//./tcpclient serverip serverport
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip = argv[1];
    uint16_t serverport = stoi(argv[2]);

    //tcp是面向连接的，客户端连接成功了，我才想让你进行通信
    //没有bind 也就没有listen了

    //网络文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        cerr << "socket error" << endl;   
        return 1;
    }
    
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));

    //向服务器发起连接的接口 connect
    //客户端发起connect的时候,系统进行自动随机bind
    int n = connect(sockfd, (struct sockaddr*)&server, sizeof(server));
    if(n < 0)
    {
        cerr<< "connect error" <<endl;
        return 2;
    }
    //连接成功了
    //给对方发消息
    string message;
    while(true)
    {
        cout<< "Please Enter#" ;
        getline(cin, message);

        //把数据写给对方
        write(sockfd, message.c_str(), message.size());

        //对方服务器又会给写回来
        char inbuffer[4096];
        int n = read(sockfd, inbuffer, sizeof(inbuffer));//写进inbuffer
        if(n > 0)//读成功了
        {
            inbuffer[n] = 0;//字符串以0结尾
            cout<< inbuffer << endl;//返回什么就打印什么
        }

    }

    close(sockfd);
    return 0;
}

main.cc

#include"TcpServer.hpp"
#include<iostream>
#include<memory>
using namespace std;

void Usage(string proc)
{
    cout<< "\n\rUsage:" << proc << "port[1024+]\n" << endl; 
}

//./tcpserver 8888
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(UsageError);
    }
    uint16_t port = stoi(argv[1]);
    unique_ptr<TcpServer> server(new TcpServer(port));
    server->InitServer();
    server->Start();




    return 0;
}

tcpServer.hpp

#pragma once
#include <iostream>
#include <sys/types.h> 
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;

const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10;//listen的第二个参数
enum
{
    UsageError = 1,
    SocketError,
    BindError,
    ListenError
};

class TcpServer
{
public:
    TcpServer(const uint16_t &port, const string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
    {
    }
    void InitServer()
    {
        //                          字节流
        listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensockfd_ < 0)
        {
            FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
            exit(SocketError);
        }
        INFO("create socket,success,listensockfd_:%d", listensockfd_);
        // 本地信息，这里只是栈里定义的变量
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 初始化清零
        // 填充网络信息
        local.sin_family = AF_INET;
        // 端口号是要发进网络里的，要主机序列转网络序列
        local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
        /*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
        但有风险        */
        inet_aton(ip_.c_str(), &(local.sin_addr));
        // 开始绑定
        int k = bind(listensockfd_, (struct sockaddr *)(&local), sizeof(local));
        if (k < 0)
        {
            FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(BindError);
        }
        INFO("bind socket,success,listensockfd_:%d", listensockfd_);

        //TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
        int ls = listen(listensockfd_, backlog);
        if(ls < 0)
        {
            FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(ListenError);
        }
        INFO("listen socket,success,listensockfd_:%d", listensockfd_);

    }
    void Start()
    {
        INFO("tcpserver is running");
        for(; ;)
        {
            //1.重新获取
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            //阻塞状态
            int sockfd = accept(listensockfd_, (struct sockaddr*)(&client), &len);
            if(sockfd < 0)
            {
                WARN("accept errno,error:%d,errstring:%s", errno, strerror(errno));
                continue;
            }

            //进行服务  传客户端的IP和端口号
            //网络转主机
            uint16_t clientport = ntohs(client.sin_port);
            char clientip[32];
            inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));

            //2.根据新连接来进行通信
            INFO("get a new link..., sockfd:%d, client ip:%s, client port:%d", sockfd, clientip, clientport);

            //进行服务
            Service(sockfd, clientip, clientport);
            
        }
    }
    //服务 发什么就相应回去
    void Service(int sockfd, const string &clientip, const uint16_t &clientport)
    {
        //测试代码
        char buffer[4096];
        while(true)
        {
            //从网络文件描述符中读取
            ssize_t n = read(sockfd, buffer, sizeof(buffer));
            if(n > 0) 
            {
                buffer[n] = 0;
                cout<< "client say# " << buffer << endl;
                //发回
                string echo_string = "tcpserver echo# ";
                echo_string += buffer;
                //发回
                write(sockfd, echo_string.c_str(), echo_string.size());
            }

        }
    
    }

    ~TcpServer()
    {
    }

private:
    // IP和端口号需要用户构建服务器时就要告诉我了，
    int listensockfd_;    // 网络文件描述符
    uint16_t port_; // 端口号
    string ip_;     // 字符串风格的ip
};

客户端如果自己退了，服务器会怎么办

会读到0

但这样是单进程的只允许一个用户在线

多进程版本

但太消耗资源了成本太高了

多线程版本

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
using namespace std;

const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10;             // listen的第二个参数
enum
{
    UsageError = 1,
    SocketError,
    BindError,
    ListenError
};
class TcpServer;
class ThreadData
{
public:
    ThreadData(int fd, const string& ip, const uint16_t& port, TcpServer*td):sockfd(fd), clientip(ip), clientport(port), td_(td)
    {}
public:
    int sockfd;
    string clientip;
    uint16_t clientport;
    TcpServer* td_;
};
class TcpServer
{
public:
    TcpServer(const uint16_t &port, const string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
    {
    }
    void InitServer()
    {
        //                          字节流
        listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensockfd_ < 0)
        {
            FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
            exit(SocketError);
        }
        INFO("create socket,success,listensockfd_:%d", listensockfd_);
        // 本地信息，这里只是栈里定义的变量
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 初始化清零
        // 填充网络信息
        local.sin_family = AF_INET;
        // 端口号是要发进网络里的，要主机序列转网络序列
        local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
        /*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
        但有风险        */
        inet_aton(ip_.c_str(), &(local.sin_addr));
        // 开始绑定
        int k = bind(listensockfd_, (struct sockaddr *)(&local), sizeof(local));
        if (k < 0)
        {
            FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(BindError);
        }
        INFO("bind socket,success,listensockfd_:%d", listensockfd_);

        // TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
        int ls = listen(listensockfd_, backlog);
        if (ls < 0)
        {
            FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(ListenError);
        }
        INFO("listen socket,success,listensockfd_:%d", listensockfd_);
    }
    void Start()
    {
        INFO("tcpserver is running");
        for (;;)
        {
            // 1.重新获取
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            // 阻塞状态
            int sockfd = accept(listensockfd_, (struct sockaddr *)(&client), &len);
            if (sockfd < 0)
            {
                WARN("accept errno,error:%d,errstring:%s", errno, strerror(errno));
                continue;
            }

            // 进行服务  传客户端的IP和端口号
            // 网络转主机
            uint16_t clientport = ntohs(client.sin_port);
            char clientip[32];
            inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));

            // 2.根据新连接来进行通信
            INFO("get a new link..., sockfd:%d, client ip:%s, client port:%d", sockfd, clientip, clientport);

            // 单进程版本
            // 进行服务
            //  Service(sockfd, clientip, clientport);
            //  //如果读到了0，就回来了，然后关闭文件描述符
            //  close(sockfd);

            // 多进程版本
            // pid_t id = fork();
            // if (id == 0)
            // {
            //     // child  可以看到父进程所对应的sockfd
            //     close(listensockfd_);
            //     pid_t id = fork();
            //     if(id > 0) exit(0);//子进程直接退出，退出后，父进程就不用等待了，直接获取新的链接了
            //     if (id == 0)//让孙子进程处理，孙子进程是直接由系统处理的,被系统领养，被自动回收
            //     {
            //         Service(sockfd, clientip, clientport);
            //         close(sockfd);
            //         exit(0);
            //     }   
            // }
            // // sockfd已经被子进程继承下去了，所以父进程不需要了
            // close(sockfd);
            // // 父进程等待
            // pid_t rid = waitpid(id, nullptr, 0);
            // (void)rid;

            //多线程版本                                        这里的this，因为ThreadData里有TcpServer这个类了
            ThreadData *td = new ThreadData(sockfd, clientip, clientport, this);
            pthread_t tid;
            pthread_create(&tid, nullptr, Routine, td);
            //如果要继续等待，那么就还是只处理一个用户了，所以要线程分离pthread_detach
            //这样主线程就一直在获取新链接，新线程进行任务处理
            //线程要不要关闭文件描述符，不用，因为不像进程一样有多余的文件描述符
            //线程只有一个   大部分都是共享的         
        }
    }
    //成员函数内部有this指针，要加static
    //static方法无法使用类内非静态成员方法,也不能访问类内成员
    static void* Routine(void* args)
    {
        //线程要不要关闭文件描述符，不用，因为不像进程一样有多余的文件描述符
        //线程只有一个  大部分都是共享的  
        pthread_detach(pthread_self());
        ThreadData *td = static_cast<ThreadData*>(args);
        td->td_->Service(td->sockfd, td->clientip, td->clientport); 
        delete td;
        return nullptr;
    }

    // 服务 发什么就相应回去
    void Service(int sockfd, const string &clientip, const uint16_t &clientport)
    {
        // 测试代码
        char buffer[4096];
        while (true)
        {
            // 从网络文件描述符中读取
            ssize_t n = read(sockfd, buffer, sizeof(buffer));
            if (n > 0)
            {
                buffer[n] = 0;
                cout << "client say# " << buffer << endl;
                // 发回
                string echo_string = "tcpserver echo# ";
                echo_string += buffer;
                // 发回
                write(sockfd, echo_string.c_str(), echo_string.size());
            }
            else if (n == 0) // 说明客户端已经退出了
            {
                INFO("[%s %d] client quit,server close sockfd:%d", clientip, clientport, sockfd);
                break;
            }
            else // 说明读取已经出问题了
            {
                WARN("读取出问题了");
            }
        }
    }

    ~TcpServer()
    {
    }

private:
    // IP和端口号需要用户构建服务器时就要告诉我了，
    int listensockfd_; // 网络文件描述符
    uint16_t port_;    // 端口号
    string ip_;        // 字符串风格的ip
};

线程池版本

修改一下任务

这个注释一下

任务改成这样

代码

dict.txt

apple:苹果
banana:香蕉
yellow:黄色
apple:苹果
banana:香蕉
cat:猫
dog:狗
book:书
computer:电脑
car:汽车
house:房子
tree:树
water:水
food:食物
love:爱
friend:朋友
family:家庭
school:学校
sun:太阳
。。。。。。

Task.hpp

#pragma once
#include <iostream>
#include <string>
#include "./logs/ljwlog.h"
using namespace std;

string opers = "+-*/%";
enum
{
    Div_zero = 1,
    Mod_zero,
    Unknown
};

class Task
{
public:
    Task(int sockfd, const string &clientip, const uint16_t &clientport)
        : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
    {
    }
    void run()
    {
        // 服务代码
        // 测试代码
        char buffer[4096];

        // 从网络文件描述符中读取
        ssize_t n = read(sockfd_, buffer, sizeof(buffer));
        if (n > 0)
        {
            buffer[n] = 0;
            cout << "client say# " << buffer << endl;
            // 发回
            string echo_string = "tcpserver echo# ";
            echo_string += buffer;
            // 发回
            write(sockfd_, echo_string.c_str(), echo_string.size());
        }
        else if (n == 0) // 说明客户端已经退出了
        {
            INFO("[%s %d] client quit,server close sockfd:%d", clientip_, clientport_, sockfd_);
        }
        else // 说明读取已经出问题了
        {
            WARN("读取出问题了");
        }
        close(sockfd_);
    }
    void operator()()
    {
        run();
    }

    ~Task()
    {
    }

private:
    int sockfd_; // 网络文件描述符
    string clientip_;
    uint16_t clientport_; // 端口号
};

TcpClient.cc

#include <iostream>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;

void Usage(string proc)
{
    cout<< "\n\rUsage:" << proc << "serverip serverport\n" << endl; 
}


//./tcpclient serverip serverport
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip = argv[1];
    uint16_t serverport = stoi(argv[2]);

    //tcp是面向连接的，客户端连接成功了，我才想让你进行通信
    //没有bind 也就没有listen了

    //网络文件描述符
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        cerr << "socket error" << endl;   
        return 1;
    }
    
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));

    //向服务器发起连接的接口 connect
    //客户端发起connect的时候,系统进行自动随机bind
    int n = connect(sockfd, (struct sockaddr*)&server, sizeof(server));
    if(n < 0)
    {
        cerr<< "connect error" <<endl;
        return 2;
    }
    //连接成功了
    //给对方发消息
    string message;
    while(true)
    {
        cout<< "Please Enter#" ;
        getline(cin, message);

        //把数据写给对方
        write(sockfd, message.c_str(), message.size());

        //对方服务器又会给写回来
        char inbuffer[4096];
        int n = read(sockfd, inbuffer, sizeof(inbuffer));//写进inbuffer
        if(n > 0)//读成功了
        {
            inbuffer[n] = 0;//字符串以0结尾
            cout<< inbuffer << endl;//返回什么就打印什么
        }

    }

    close(sockfd);
    return 0;
}

TcpServer.hpp

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include "./logs/ljwlog.h"
#include "ThreadPool.hpp"
#include "Task.hpp"
using namespace std;

const int defaultfd = -1;
const string defaultip = "0.0.0.0"; // 缺省IP任意ip
const int backlog = 10;             // listen的第二个参数
enum
{
    UsageError = 1,
    SocketError,
    BindError,
    ListenError
};
class TcpServer;
class ThreadData
{
public:
    ThreadData(int fd, const string& ip, const uint16_t& port, TcpServer*td):sockfd(fd), clientip(ip), clientport(port), td_(td)
    {}
public:
    int sockfd;
    string clientip;
    uint16_t clientport;
    TcpServer* td_;
};
class TcpServer
{
public:
    TcpServer(const uint16_t &port, const string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
    {
    }
    void InitServer()
    {
        //                          字节流
        listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensockfd_ < 0)
        {
            FATAL("create socket,error:%d,errstring:%s", errno, strerror(errno));
            exit(SocketError);
        }
        INFO("create socket,success,listensockfd_:%d", listensockfd_);
        // 本地信息，这里只是栈里定义的变量
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 初始化清零
        // 填充网络信息
        local.sin_family = AF_INET;
        // 端口号是要发进网络里的，要主机序列转网络序列
        local.sin_port = htons(port_); // 任何一款服务器都有自己对应的端口号
        /*ip地址要把字符串风格的转换成4字节IP，之前udp用的是inet_addr是最简单的
        但有风险        */
        inet_aton(ip_.c_str(), &(local.sin_addr));
        // 开始绑定
        int k = bind(listensockfd_, (struct sockaddr *)(&local), sizeof(local));
        if (k < 0)
        {
            FATAL("bind errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(BindError);
        }
        INFO("bind socket,success,listensockfd_:%d", listensockfd_);

        // TCP是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
        int ls = listen(listensockfd_, backlog);
        if (ls < 0)
        {
            FATAL("listen errno,error:%d,errstring:%s", errno, strerror(errno));
            exit(ListenError);
        }
        INFO("listen socket,success,listensockfd_:%d", listensockfd_);
    }
    void Start()
    {
        //先启动线程池
        ThreadPool<Task>::GetInstance()->Start();

        INFO("tcpserver is running");
        for (;;)
        {
            // 1.重新获取
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            // 阻塞状态
            int sockfd = accept(listensockfd_, (struct sockaddr *)(&client), &len);
            if (sockfd < 0)
            {
                WARN("accept errno,error:%d,errstring:%s", errno, strerror(errno));
                continue;
            }

            // 进行服务  传客户端的IP和端口号
            // 网络转主机
            uint16_t clientport = ntohs(client.sin_port);
            char clientip[32];
            inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));

            // 2.根据新连接来进行通信
            INFO("get a new link..., sockfd:%d, client ip:%s, client port:%d", sockfd, clientip, clientport);

            //1. 单进程版本
            // 进行服务
            //  Service(sockfd, clientip, clientport);
            //  //如果读到了0，就回来了，然后关闭文件描述符
            //  close(sockfd);

            //2. 多进程版本
            // pid_t id = fork();
            // if (id == 0)
            // {
            //     // child  可以看到父进程所对应的sockfd
            //     close(listensockfd_);
            //     pid_t id = fork();
            //     if(id > 0) exit(0);//子进程直接退出，退出后，父进程就不用等待了，直接获取新的链接了
            //     if (id == 0)//让孙子进程处理，孙子进程是直接由系统处理的,被系统领养，被自动回收
            //     {
            //         Service(sockfd, clientip, clientport);
            //         close(sockfd);
            //         exit(0);
            //     }   
            // }
            // // sockfd已经被子进程继承下去了，所以父进程不需要了
            // close(sockfd);
            // // 父进程等待
            // pid_t rid = waitpid(id, nullptr, 0);
            // (void)rid;

            //3.多线程版本                                        这里的this，因为ThreadData里有TcpServer这个类了
            // ThreadData *td = new ThreadData(sockfd, clientip, clientport, this);
            // pthread_t tid;
            // pthread_create(&tid, nullptr, Routine, td);
            //如果要继续等待，那么就还是只处理一个用户了，所以要线程分离pthread_detach
            //这样主线程就一直在获取新链接，新线程进行任务处理
            //线程要不要关闭文件描述符，不用，因为不像进程一样有多余的文件描述符
            //线程只有一个   大部分都是共享的     

            //4.线程池版本    
            Task t(sockfd, clientip, clientport);//构建任务
            ThreadPool<Task>::GetInstance()->Push(t);//把任务push进线程池里
        }
    }
    
    // //成员函数内部有this指针，要加static
    // //static方法无法使用类内非静态成员方法,也不能访问类内成员
    // static void* Routine(void* args)
    // {
    //     //线程要不要关闭文件描述符，不用，因为不像进程一样有多余的文件描述符
    //     //线程只有一个  大部分都是共享的  
    //     pthread_detach(pthread_self());
    //     ThreadData *td = static_cast<ThreadData*>(args);
    //     td->td_->Service(td->sockfd, td->clientip, td->clientport); 
    //     delete td;
    //     return nullptr;
    // }

    // // 服务 发什么就相应回去
    // void Service(int sockfd, const string &clientip, const uint16_t &clientport)
    // {
    //     // 测试代码
    //     char buffer[4096];
    //     while (true)
    //     {
    //         // 从网络文件描述符中读取
    //         ssize_t n = read(sockfd, buffer, sizeof(buffer));
    //         if (n > 0)
    //         {
    //             buffer[n] = 0;
    //             cout << "client say# " << buffer << endl;
    //             // 发回
    //             string echo_string = "tcpserver echo# ";
    //             echo_string += buffer;
    //             // 发回
    //             write(sockfd, echo_string.c_str(), echo_string.size());
    //         }
    //         else if (n == 0) // 说明客户端已经退出了
    //         {
    //             INFO("[%s %d] client quit,server close sockfd:%d", clientip, clientport, sockfd);
    //             break;
    //         }
    //         else // 说明读取已经出问题了
    //         {
    //             WARN("读取出问题了");
    //         }
    //     }
    // }

    ~TcpServer()
    {
    }

private:
    // IP和端口号需要用户构建服务器时就要告诉我了，
    int listensockfd_; // 网络文件描述符
    uint16_t port_;    // 端口号
    string ip_;        // 字符串风格的ip
};

ThreadPool.hpp

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <pthread.h>

#include <vector>
#include <queue>
using namespace std;

struct ThreadInfo
{
    pthread_t tid;
    string name;
};

static const int defalutnum = 5; // 线程池有几个线程

template <class T>
class ThreadPool
{
public:
    void Lock()
    {
        pthread_mutex_lock(&mutex_);
    }
    void Unlock()
    {
        pthread_mutex_unlock(&mutex_);
    }
    void Weakup()
    {
        pthread_cond_signal(&cond_);
    }
    // 指定条件变量休眠，检测到队列中没有任务（也就是检测临界资源）
    void ThreadSleep()
    {
        pthread_cond_wait(&cond_, &mutex_);
    }

    void Push(const T &t)
    {
        Lock();
        tasks_.push(t);
        Weakup();//唤醒
        Unlock();
    }
    void Pop(T *out)
    {
        Lock();
        tasks_.pop();
        Unlock();
    }
    string GerThreadName(pthread_t tid)
    {
        for (const auto &t : threads_)
        {
            if (t.tid == tid)
                return t.name;
        }
        return "None";
    }
    static void *HandlerTask(void *args)
    {
        ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
        string name = tp->GerThreadName(pthread_self());
        while (true)
        {
            tp->Lock();
            while (tp->IsQueueEmpty())
            {
                tp->ThreadSleep();
            }
            T t = tp->Pop();
            tp->Unlock();
            t();
        }
    }
    T Pop()
    {
        T t = tasks_.front();
        tasks_.pop();
        return t;
    }
    void Start()
    {
        int num = threads_.size();
        for (int i = 0; i < num; i++)
        {
            threads_[i].name = "thread-" + to_string(i + 1);
            pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);
        }
    }

    static ThreadPool<T> *GetInstance()
    {
        if (nullptr == tp_)
        {
            pthread_mutex_lock(&lock_);
            if (nullptr == tp_)
            {
                tp_ = new ThreadPool<T>();
            }
            pthread_mutex_unlock(&lock_);
        }

        return tp_;
    }

private:
    bool IsQueueEmpty()
    {
        return tasks_.empty();
    }

private:
    // 构造单例
    ~ThreadPool()
    {
        pthread_mutex_destroy(&mutex_);
        pthread_cond_destroy(&cond_);
    }

    ThreadPool(int num = defalutnum) : threads_(num)
    {
        pthread_mutex_init(&mutex_, nullptr);
        pthread_cond_init(&cond_, nullptr);
    }
    ThreadPool(const ThreadPool<T> &) = delete;
    const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete;

private:
    vector<ThreadInfo> threads_;
    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;

main.cc

#include"TcpServer.hpp"
#include<iostream>
#include<memory>
using namespace std;

void Usage(string proc)
{
    cout<< "\n\rUsage:" << proc << "port[1024+]\n" << endl; 
}

//./tcpserver 8888
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(UsageError);
    }
    uint16_t port = stoi(argv[1]);
    unique_ptr<TcpServer> server(new TcpServer(port));
    server->InitServer();
    server->Start();




    return 0;
}

makefile

.PHONY:all
all:tcpserver tcpclient
tcpserver:main.cc
	g++ -o $@ $^ -lpthread -std=c++11
tcpclient:TcpClient.cc
	g++ -o $@ $^ -lpthread -std=c++11
.PHONT:clean
clean:
	rm -f tcpclient tcpserver

测试结果

像服务器发起请求，服务器把结果给你，链接关闭，此时可以理解为有线程池给同意处理我们的任务

简单的翻译器字典

补充一个知识点

.getline 从文件读取一整行

getline 是 C++ 中一个用于从输入流中读取一整行的函数，通常用于读取带有空格的字符串。它属于 <iostream> 头文件，并且有两个主要的用法：

1. 从 cin 读取输入：

getline 函数能够读取输入流直到遇到换行符（\n），并将其存储到一个字符串中，换行符会被丢弃。

函数原型：

istream& getline(istream& is, string& str);

is：输入流（如 cin 或文件流）。
str：存储读取结果的字符串。

示例：

#include <iostream>
#include <string>
using namespace std;

int main() {
    string line;
    cout << "Enter a line: ";
    getline(cin, line);  // 读取一行输入并存储到 line 中
    cout << "You entered: " << line << endl;
    return 0;
}

2. 从文件读取一整行：

getline 也可以用来从文件读取数据。此时，传入的流对象通常是 ifstream。

示例：

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main() {
    ifstream file("example.txt");  // 打开文件
    string line;
    
    if (file.is_open()) {
        while (getline(file, line)) {  // 逐行读取文件
            cout << line << endl;  // 输出每一行
        }
        file.close();
    } else {
        cout << "Unable to open file" << endl;
    }
    return 0;
}

注意事项：

getline 会删除输入中的换行符（\n），因此字符串末尾没有换行符。
如果输入流已经到达文件或流的末尾，getline 会返回 false，并且读取的字符串会为空。

总的来说，getline 在处理用户输入或文件数据时非常有用，特别是当输入中包含空格时。

init.hpp

#pragma once
#include<iostream>
#include<fstream>
#include<string>
#include<unordered_map>
#include "./logs/ljwlog.h"

using namespace std;
const string dictname = "./dict.txt";//字典名
const string sep = ":";//分隔符

//yellow:黄色
static bool Split(string &s, string *part1, string* part2)
{
    auto pos = s.find(sep);
    if(pos == std::string::npos)
    {
        return false;
    }
    *part1 = s.substr(0, pos);
    *part2 = s.substr(pos+1);
    return true;
}

//yellow:黄色
class Init
{
public:

    Init()
    {
        ifstream in(dictname);
        if(!in.is_open())
        {
            FATAL("ifstream open %s error", dictname.c_str());
            exit(1);
        }
        string s;
        while(getline(in, s))
        {
            string part1, part2;
            Split(s, &part1, &part2);
            dict.insert({part1, part2});
        }
        in.close();
    }
    string translation(const string& key)
    {
        auto iter = dict.find(key);
        if(iter == dict.end()) return "Unkonw";
        else return iter->second;
    }

private:
    unordered_map<string, string> dict;
};

Task.hpp

研究一下write

没有发回客户端

这里会出现一种偶发性的情况，当我们写一个文件描述符时，如果这个sockfd_的底层链接，被双方已经释放掉了，再像这个释放掉的写入时，就会出现问题

两个继承向管道写入，把读端给关闭了，写端继续写的话，进程就会收到SIGPIPE信号

给屏蔽掉

补充知识点常见的信号

常见的信号：

**SIGINT**：中断信号，通常由键盘的 Ctrl+C 触发。

**SIGTERM**：终止信号，用于请求进程正常退出。

**SIGSEGV**：段错误信号，进程访问非法内存时触发。

**SIGKILL**：杀死信号，强制终止进程，不可被捕获或屏蔽。

**SIGALRM**：定时器到期信号，通常由 alarm() 函数触发。

**SIGUSR1、SIGUSR2**：用户定义信号，用于用户自定义的应用程序通信。

**SIGPIPE**：管道破裂信号，通常由写入关闭管道的进程触发。

常见的信号忽略

在 C/C++ 中，信号忽略是一种控制信号行为的机制，允许进程对某些信号采取不处理的方式，即忽略这些信号。信号忽略的常见方法是通过 signal() 或 sigaction() 函数设置信号的处理行为为 SIG_IGN（即忽略信号）。下面介绍一些常见的信号及其忽略方式。

常见的信号及其忽略方法

**SIGPIPE**：当进程尝试向一个已关闭的管道或套接字写入数据时，系统会向进程发送 SIGPIPE 信号。默认情况下，进程会因接收到 SIGPIPE 信号而终止程序。在一些应用程序中（如网络编程），你可能希望忽略这个信号，避免进程崩溃。

忽略方法：
```
signal(SIGPIPE, SIG_IGN);
```
这行代码会让程序在遇到 SIGPIPE 信号时不做任何处理，程序将继续运行，而不是因为尝试写入关闭的管道而崩溃。
**SIGCHLD**：当子进程终止时，操作系统会向父进程发送 SIGCHLD 信号。默认情况下，父进程会接收到这个信号并需要调用 wait() 或 waitpid() 来回收子进程的退出状态。如果不想处理这个信号，可以通过忽略它来避免父进程被中断。

忽略方法：
```
signal(SIGCHLD, SIG_IGN);
```
这将使得父进程忽略 SIGCHLD 信号，而不需要显式地等待子进程的结束。
**SIGUSR1 和 SIGUSR2**：这两个信号是用户定义的信号，可以用于应用程序自定义的行为。在某些情况下，你可能不希望进程响应这些信号，通常在进程不需要使用这些信号时会选择忽略。

忽略方法：
```
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
```
**SIGINT**：当用户按下 Ctrl+C 时，通常会向进程发送 SIGINT 信号，默认情况下进程会终止。如果你希望在某些情况下忽略 SIGINT 信号（例如，防止用户终止正在运行的程序），可以使用以下方法：

忽略方法：
```
signal(SIGINT, SIG_IGN);
```
这将让程序忽略 Ctrl+C 产生的中断信号，程序将继续运行。
**SIGTERM**：SIGTERM 是一个请求终止进程的信号，通常用来请求程序优雅退出。如果你希望程序在收到 SIGTERM 信号时不退出，可以选择忽略它。

忽略方法：
```
signal(SIGTERM, SIG_IGN);
```
这将让程序忽略 SIGTERM 信号，程序不会因为外部终止请求而退出。

使用 signal() 函数忽略信号

signal() 函数可以用于设置信号的处理程序，以下是常用的忽略信号的语法：

signal(signal_number, SIG_IGN);

signal_number：表示要忽略的信号编号（如 SIGPIPE, SIGINT, SIGTERM 等）。
SIG_IGN：表示忽略信号。

使用 sigaction() 函数忽略信号

sigaction() 是一种更为强大和灵活的信号处理机制，可以提供更精细的控制，包括设置信号屏蔽、信号处理程序等。通过 sigaction() 忽略信号的方式如下：

#include <signal.h>

struct sigaction sa;
sa.sa_handler = SIG_IGN;   // 设置为忽略信号
sigemptyset(&sa.sa_mask);   // 清空信号掩码
sa.sa_flags = 0;            // 不使用特殊标志

sigaction(SIGINT, &sa, NULL);  // 忽略 SIGINT 信号

常见信号的忽略示例

以下是一些常见信号的忽略示例：

#include <iostream>
#include <signal.h>
#include <unistd.h>

using namespace std;

int main() {
    // 忽略 SIGINT 信号（Ctrl+C）
    signal(SIGINT, SIG_IGN);

    // 忽略 SIGPIPE 信号（写入关闭的管道时）
    signal(SIGPIPE, SIG_IGN);

    // 忽略 SIGTERM 信号（终止进程请求）
    signal(SIGTERM, SIG_IGN);

    cout << "Signal handling example: ignoring SIGINT, SIGPIPE, and SIGTERM" << endl;

    // 程序继续执行，等待信号
    while (true) {
        sleep(1); // 程序保持运行，等待信号
    }

    return 0;
}

在上述示例中，程序会忽略 SIGINT（Ctrl+C）、SIGPIPE（写入关闭管道）和 SIGTERM（请求终止进程）信号。如果用户按下 Ctrl+C 或尝试向关闭的管道写数据时，程序不会被终止，而是继续运行。

总结

忽略信号：使用 signal(signal_number, SIG_IGN) 或 sigaction() 可以让进程忽略特定的信号，避免因信号导致程序异常终止或干扰。
常见信号忽略：常见需要忽略的信号包括 SIGPIPE、SIGINT、SIGTERM 和 SIGCHLD 等。
**signal() 与 sigaction()**：signal() 是一种简单的信号处理方式，sigaction() 提供了更强大的功能和更高的可移植性，适用于更复杂的信号处理需求。

通过适当的信号忽略和处理，可以提升程序的稳定性和鲁棒性，尤其是在网络编程或需要长时间运行的后台进程中。

TcpClient.cc 修改成多次可以使用服务的

连续输入

读写出错进行重连

守护进程

前台进程后台进程

后台进程不能标准输入

3个后台进程了

把2号任务提到前台进程

ctrl c终止前台进程

把任务提到前台进程，后悔了，再重新放回后台

ctrl z就可以暂停，然后系统自动把bash提到前台

bg 3再把3号进程启动起来

session（进程会话）

在Linux中，session（会话）通常指的是与用户交互的一个环境，它是系统中与某个用户交互的一系列活动的集合。会话在Linux系统中有多种用途，下面是几种常见的会话类型及其相关概念：

当用户通过登录界面（如终端或图形界面）登录到系统时，系统会为该用户创建一个会话。登录会话包括：

用户身份验证（通过用户名和密码等方式）。
运行用户的默认Shell（例如bash）。
用户环境变量的设置（例如$PATH、$HOME等）。

这种会话通常由登录管理器（如login、sshd或gdm等）管理。当用户退出登录时，该会话会结束。

2. 进程会话（Process Session）

在Linux中，每个进程都有一个会话（Session），这个会话由session leader（会话领导进程）控制。进程会话的特征包括：

每个进程在启动时都会被分配一个会话ID。
会话通常由一个进程创建，称为会话领导进程。
会话通常用于进程组管理，特别是在控制终端和后台进程之间的交互。

会话的管理由setsid()系统调用进行，当进程调用setsid()时，它会创建一个新的会话，并成为该会话的领导进程

前台任务和后台任务比较好

本质

任务里有多个进程组

每多建一个就多一个

绘画和终端都关掉了，那些任务仍然在

bash也退了，然后就托孤了

受到了用户登录和退出的影响

守护进程化---不想受到任何用户登陆和注销的影响

如何做到（setsid）(创建新会话)

怎么保证自己不是组长

守护进程本质（孤儿进程）

守护进程忽略的几个信号和含义

在 C/C++ 中，守护进程通常会忽略一些信号，确保其在后台继续运行，而不被用户的操作或其他系统事件干扰。除了常见的信号外，SIGPIPE 也是一个重要的信号，守护进程通常会忽略它。以下是几个常见的守护进程忽略的信号及其作用，包括 SIGPIPE：

1. SIGHUP (Hangup signal)

作用：最初用于通知进程，终端连接已经断开。对于守护进程来说，接收到 SIGHUP 信号通常意味着该进程应重新加载其配置文件。
守护进程行为：守护进程通常会忽略 SIGHUP 信号，这样即使终端连接断开，进程也会继续运行。

2. SIGINT (Interrupt signal)

作用：通常由用户通过键盘操作（Ctrl+C）发送，用来中断进程的执行。
守护进程行为：守护进程会忽略 SIGINT 信号，避免被用户的键盘中断。

3. SIGTERM (Termination signal)

作用：请求进程终止的信号。系统或其他进程通常会发送此信号来请求进程优雅地结束。
守护进程行为：尽管守护进程有时会捕获 SIGTERM 信号并优雅地退出，但它也可能选择忽略该信号，或者采取一些特定的清理操作后继续运行。

4. SIGQUIT (Quit signal)

作用：通常由用户通过 Ctrl+\ 发送，用来终止进程并生成核心转储文件。
守护进程行为：守护进程通常会忽略 SIGQUIT 信号，以避免被意外终止并生成不必要的核心转储文件。

5. SIGCHLD (Child terminated signal)

作用：当子进程结束时，父进程会收到 SIGCHLD 信号，通常用于处理子进程的退出状态。
守护进程行为：守护进程可能会忽略 SIGCHLD 信号，特别是当它不需要对子进程的退出状态进行处理时。

6. SIGPIPE (Broken pipe signal)

作用：当一个进程向一个已经关闭的管道或套接字写入数据时，操作系统会发送 SIGPIPE 信号给该进程。
守护进程行为：守护进程通常会忽略 SIGPIPE 信号。这是因为如果进程尝试向一个已经关闭的管道或套接字写入数据，默认情况下会导致进程终止。通过忽略 SIGPIPE 信号，守护进程可以避免因意外的关闭管道而终止，通常这种情况下进程会返回一个错误代码，而不是被强制终止。

为什么守护进程忽略这些信号？

守护进程的设计目标是长时间稳定地在后台运行，因此它们通常需要避免因为用户的操作（如 Ctrl+C）、系统的请求（如终止信号）或其他不必要的信号而中断。忽略这些信号有助于确保进程不被意外终止，可以持续运行。

如何在 C/C++ 中忽略信号？

在 C/C++ 中，您可以使用 signal() 函数来捕获或忽略信号。若要忽略一个信号，可以将信号处理程序设置为 SIG_IGN。例如：

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    // 忽略 SIGHUP, SIGINT, SIGPIPE
    signal(SIGHUP, SIG_IGN);  // 忽略 SIGHUP
    signal(SIGINT, SIG_IGN);  // 忽略 SIGINT
    signal(SIGPIPE, SIG_IGN); // 忽略 SIGPIPE

    // 守护进程的逻辑
    while (1) {
        // 模拟工作
        sleep(1);
    }

    return 0;
}

总结：

SIGHUP: 通常用于通知终端连接断开，守护进程会忽略它。
SIGINT: 用户通过 Ctrl+C 发送的中断信号，守护进程会忽略它。
SIGTERM: 请求进程终止，守护进程有时会忽略它，或者捕获后进行清理操作。
SIGQUIT: 用户通过 Ctrl+\ 发送的信号，守护进程会忽略它。
SIGCHLD: 子进程退出时发送的信号，守护进程可能会忽略它。
SIGPIPE: 管道或套接字关闭时发送的信号，守护进程会忽略它，避免进程被意外终止。

通过忽略这些信号，守护进程能够在后台稳定运行，避免不必要的中断或退出。

代码

先忽略几个常见信号

#pragma once
#include<iostream>
#include<cstdlib>
#include<unistd.h>
#include<signal.h>
#include<string>

using namespace std;

void Daemon(const string &cwd = "")
{
    //1.忽略其他异常信号
    signal(SIGCLD, SIG_IGN);
    signal(SIGPIPE, SIG_IGN);
    signal(SIGSTOP, SIG_IGN);

    //2.将自己变成独立的会话
    if(fork() > 0)
    {
        exit(0);
    }
    setsid();

    //3.g更改当前目录
    if(!cwd.empty())
    {
        chdir(cwd.c_str());//更改当前目录
    }


}

网络服务器以守护进程运行

/dev/null,垃圾桶

dup2重定向到/dev/null

Daemon.hpp

#pragma once
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
using namespace std;

const string nullfile = "/dev/null";

void Daemon(const string &cwd = "")
{
    // 1.忽略其他异常信号
    signal(SIGCLD, SIG_IGN);
    signal(SIGPIPE, SIG_IGN);
    signal(SIGSTOP, SIG_IGN);

    // 2.将自己变成独立的会话
    if (fork() > 0)
    {
        exit(0);
    }
    setsid();

    // 3.g更改当前目录
    if (!cwd.empty())
    {
        chdir(cwd.c_str()); // 更改当前目录
    }

    // 4.有打印的，标准输出标准输入的，所以要把表示输入，标准输出，标准错误重定向至/dev/null
    // 标准错误一般要打印到日志文件，不要打印到屏幕
    int fd = open(nullfile.c_str(), O_RDWR);//读写方式打开
    if(fd > 0)
    {
        dup2(fd, 0);
        dup2(fd, 1);
        dup2(fd, 2);
        close(fd);
    }

}

测试：启动后直接终止了，变成后台了

检查是否起来了netstat -nltp

ps ajx |head -1 && ps ajx |grep tcpserver

自成进程组，自成会话

查看工作目录ls /proc/644717 -l

还在当前目录

ls /proc/644717/fd -l

把xshell关闭了，服务仍然在

再打开一个xshell就等于重新启动一个会话，还能看到tcpserver进程在运行

把服务器进程关闭掉kill -9 PID

把打印的放进日志文件

守护进程函数daemon,上面的是模拟

在 C/C++ 中，daemon() 函数用于创建守护进程（daemon）。守护进程通常是系统后台运行的进程，通常没有控制终端，并且可以在系统启动时自动启动或在用户退出登录时保持运行。守护进程会与控制终端断开连接，通常用于执行长期运行的任务。

`daemon()` 函数的定义

daemon() 函数通常在 <unistd.h> 中声明，原型如下：

#include <unistd.h>

int daemon(int nochdir, int noclose);

参数：

nochdir: 如果设置为 0，守护进程将在启动时改变当前工作目录为根目录（/）。这是因为守护进程一般不希望占用当前工作目录，并防止在程序退出时当前工作目录被锁定。如果设置为 1，则守护进程的当前工作目录不会改变。
noclose: 如果设置为 0，守护进程会关闭标准输入、标准输出和标准错误输出（stdin, stdout, stderr）。通常这是守护进程的行为，以防它继续与终端交互。如果设置为 1，守护进程将不会关闭这些文件描述符。