0
0

网络（TCP）

TCP socket API 详解

socket()函数用法详解：创建套接字 - C语言中文网 (biancheng.net)

套接字有哪些类型？socket有哪些类型？

套接字有哪些类型？socket有哪些类型？ - C语言中文网 (biancheng.net)

图解TCP四次握手断开连接

图解TCP四次握手断开连接 - C语言中文网 (biancheng.net)

图解TCP数据报结构以及三次握手（非常详细）

图解TCP数据报结构以及三次握手（非常详细） - C语言中文网 (biancheng.net)

socket缓冲区以及阻塞模式详解

socket缓冲区以及阻塞模式详解 - C语言中文网 (biancheng.net)

再谈UDP和TCP

再谈UDP和TCP - C语言中文网 (biancheng.net)

第一个参数：创建一个套接字的域，什么叫做域呢（协议家族）

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

8d653c031bf046d5aa810558107d2b7f.png

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

8716260b5598498d938bbcbd53f4783a.png

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

30f91d16c7da430a8bff696543150763.png

第三个写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;
}
  1. 从文件读取一整行：
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

（即忽略信号）。下面介绍一些常见的信号及其忽略方式。

常见的信号及其忽略方法

  1. SIGPIPE：当进程尝试向一个已关闭的管道或套接字写入数据时，系统会向进程发送 SIGPIPE 信号。默认情况下，进程会因接收到 SIGPIPE 信号而终止程序。在一些应用程序中（如网络编程），你可能希望忽略这个信号，避免进程崩溃。忽略方法：signal(SIGPIPE, SIG_IGN);这行代码会让程序在遇到 SIGPIPE 信号时不做任何处理，程序将继续运行，而不是因为尝试写入关闭的管道而崩溃。
  2. SIGCHLD：当子进程终止时，操作系统会向父进程发送 SIGCHLD 信号。默认情况下，父进程会接收到这个信号并需要调用 wait() 或 waitpid() 来回收子进程的退出状态。如果不想处理这个信号，可以通过忽略它来避免父进程被中断。忽略方法：signal(SIGCHLD, SIG_IGN);这将使得父进程忽略 SIGCHLD 信号，而不需要显式地等待子进程的结束。
  3. SIGUSR1 和 SIGUSR2：这两个信号是用户定义的信号，可以用于应用程序自定义的行为。在某些情况下，你可能不希望进程响应这些信号，通常在进程不需要使用这些信号时会选择忽略。忽略方法：signal(SIGUSR1, SIG_IGN);signal(SIGUSR2, SIG_IGN);
  4. SIGINT：当用户按下 Ctrl+C 时，通常会向进程发送 SIGINT 信号，默认情况下进程会终止。如果你希望在某些情况下忽略 SIGINT 信号（例如，防止用户终止正在运行的程序），可以使用以下方法：忽略方法：signal(SIGINT, SIG_IGN);这将让程序忽略 Ctrl+C 产生的中断信号，程序将继续运行。
  5. 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系统中有多种用途，下面是几种常见的会话类型及其相关概念：

  1. 登录会话（Login Session）

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

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

这种会话通常由登录管理器（如

login

、

sshd

或

gdm

等）管理。当用户退出登录时，该会话会结束。

  1. 进程会话（Process Session）

在Linux中，每个进程都有一个会话（Session），这个会话由

session leader

（会话领导进程）控制。进程会话的特征包括：

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

会话的管理由

setsid()

系统调用进行，当进程调用

setsid()

时，它会创建一个新的会话，并成为该会话的领导进程

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

本质

任务里有多个进程组

每多建一个就多一个

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

bash也退了，然后就托孤了

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

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

如何做到（setsid）

怎么保证自己不是组长

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

代码

先忽略几个常见信号

#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,上面的是模拟

tcp通信时全双工的

read/write相当于拷贝到缓冲区

标签： 网络 tcp/ip 服务器
本文转载自: https://blog.csdn.net/2401_83427936/article/details/143813676
版权归原作者 Ljw... 所有， 如有侵权，请联系我们删除。
登录后发布评论

“网络（TCP）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

基于网络安全下 第二章 数据通信安全模块

DDoS高防服务器：保障业务安全和稳定的抗攻击利器

【Linux】如何快速查看 linux 服务器有几个cpu

【网络】子网掩码

【Linux探索学习】第十四弹——进程优先级：深入理解操作系统中的进程优先级

【测试工具篇一】全网最强保姆级教程抓包工具Fiddler（1）

网络爬虫框架应用 使用 Selenium进行网页爬虫

文章导航