TCP网络程序

上一章我们基于UDP实现了几个网络程序,这一章我们开始使用TCP。

先简单复习一下TCP和UDP的特点:

  • TCP特点
  1. 传输层协议
  2. 有连接
  3. 可靠传输
  4. 面向字节流
  • UDP特点
  1. 传输层协议
  2. 无连接
  3. 不可靠传输
  4. 面向数据报

可以看到TCP是有链接的,而UDP是无连接的,有无连接体现在接口上面(listen,connect),话不多说,直接开始。

1.服务器的实现

 1.1socket(创建套接字)

#include <sys/types.h>     
#include <sys/socket.h>

int socket(int domain, int type, int protocol);

参数说明:

  • domain:域,标识了这个套接字的通信类型(网络通信/本地通信),这个就是sockaddr结构体的前16个bit位。如果是本地通信就是AF_UNIX,如果是网络通信就是AF_INET。 
  • type:套接字提供的服务类型,常见的就是SOCK_STREAM和SOCK_DGRAM,如果我们是基于TCP协议的通信,就使用SOCK_STREAM,表示的是流式服务。如果我们是基于UDP协议通信的,就使用SOCK_DGRAM,表示的是数据包服务。
  • protocol:创建套接字的类型(TCP/UDP),但是这个参数可以由前两个参数决定。所以通常设置为0

返回值:

成功会返回一个文件描述符,失败返回-1,错误码被设置

在系统的文件操作中,也会返回文件描述符,与socket返回的文件描述符不同的是,普通文件的文件缓冲区对应的是磁盘,而socket返回的文件描述符的文件缓冲区对应的是网卡。用户将数据写到缓冲区,由操作系统自动将缓冲区中的数据刷新到网卡中,网卡会负责将这个数据发送到对端主机上。

class TcpServer
{
public:
    TcpServer(uint16_t &port, std::string ip = "")
    {
        // 创建套接字
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensock < 0)
        {
            std::cout << "create socket error" << std::endl;
            exit(1);
        }
        std::cout << "create socket success, socket: " << _listensock << std::endl;
    }

    ~TcpServer()
    {
        close(_listensock);
    }

private:
    int _listensock;
};

调用socket函数,就能创建一个套接字了,第一个参数我们填AF_INET,表示的是我们是网络通信。第二个参数我们填SOCK_STREAM,表示我们是TCP服务(字节流)。由于一个进程启动时,默认会打开标准输入,标准输出,标准错误这三个文件描述符,而文件描述符的创建规则就是从0开始,向上找到第一个没有使用的,所以我们可以猜测以下_sock的值为3.

这一步和UDP非常类似,但是在socket的时候,第二个参数要更改成SOCK_STREAM表示我们要的是TCP服务。


1.2bind(绑定IP和Port)

我们创建完套接字以后,也只是打开了一个文件。还没有将这个文件和网络关联起来,所以我们需要使用bind函数,将IP+port和文件绑定

#include <sys/types.h>     
#include <sys/socket.h>

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数介绍:

  • sockfd:socket函数的返回值。
  • addr:通用结构体,包括协议家族,IP地址,端口号port
  • addrlen:addr的长度

返回值介绍:

成功返回0,错误返回-1

sockaddr_in结构体

struct sockaddr_in
  {
    short int sin_family;
    in_port_t sin_port;			
    struct in_addr sin_addr;	

    unsigned char sin_zero[8];
  };
  • sin_family:协议家族,表示通信类型(AF_INET网络通信,PF_INET本地通信)
  • sin_port:端口号(网络字节序)
  • sin_addr:IP地址。
  • sin_zero:填充字段,让sizeof(sockaddr_in) = 16

既然第二步需要添加IP和端口号,所以我们要对代码修改一下,给构造函数添加port和str(IP的点分十进制表示形式)

class TcpServer
{
public:
    TcpServer(uint16_t &port, std::string ip = "")
    {
        // 创建套接字
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensock < 0)
        {
            std::cout << "create socket error" << std::endl;
            exit(1);
        }
        std::cout << "create socket success, socket: " << _listensock << std::endl;

        // 绑定IP和端口
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = ip.empty() ? INADDR_ANY : inet_addr(ip.c_str());
        if (bind(_listensock, (sockaddr *)&addr, sizeof(addr)) < 0)
        {
            std::cout << "bind error" << std::endl;
            exit(2);
        }
        std::cout << "bind success" << std::endl;
    }

    ~TcpServer()
    {
        close(_listensock);
    }

private:
    int _listensock;
};

需要注意的是在填写sockaddr_in的参数的时候,

  • sin_family需要和socket套接字创建时的domain相同。
  • 由于端口号和IP将来是要发送到网络的,而网络数据流统一采用大端的形式,所以为了代码的可移植性,我们不管自己是大端还是小端,统一调用函数hton转化成大端。
  • 对于IP来说,如果直接发送的是点分十进制形式如(192.168.12.80)的形式,则需要占用过多的字节数,对网络传输无疑是一种很大的消耗,所以我们采用一个32位的整数来表示IP,在网络传输中,要将点分十进制的IP转化成整数,再进行传输。

前两步和UDP基本上一样,不过UDP做完这两步之后就可以开始接受用户的信息了,因为UDP是无连接的。但是TCP还需要一个监听的动作(监听客户端发来的连接请求)。

我们需要把socket套接字设置为监听状态,获取客户端发来的连接请求。例如:假设有这样一个手机,默认的工作模式就是拦截所有的电话,用户无法知道,但是用户可以更改工作模式为监听模式,不再拦截电话,只要有人给我打电话我就知道。这种监听模式就是类似于listen函数的功能。

1.3listen(设置监听状态)

#include <sys/types.h>       
#include <sys/socket.h>

int listen(int sockfd, int backlog);

参数说明:

  • sockfd:要设置为监听状态的文件描述符
  • backlog:等待队列的最大长度。如果有多个客户端同时发来连接请求,此时未被服务器处理的连接就会放入连接队列。它并不限制可以建立的总连接数,而是限制了在任何给定时间等待接受的连接数。一旦一个连接被接受,它就从队列中移除,并为新的连接请求腾出空间。一般不要设置太大,设置为5或10即可。

重要的是要注意,listen 函数本身并不接受任何连接。它只是将套接字设置为监听模式,并设置等待队列的大小。实际的连接接受是通过 accept 函数来完成的。


1.4accept(接受新连接)

前面的工作都做完了,我们就可以使用accept来接受新连接了。

#include <sys/types.h>   
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

参数介绍:

  • sockfd:表示从该监听套接字中获取新连接
  • addr:通用结构体,包括协议家族,IP地址,端口号port
  • addrlen:输出型参数,调用时传入期望读取的addr结构体的长度,返回时代表实际读取到的addr结构体的长度。

返回值:

成功返回一个文件描述符,失败返回-1

accept返回的文件描述符

先举个例子:当我们去吃饭时,门口会有个服务员张三正在揽客,当他找到客人就把客人交给了新的服务员李四/王五/赵六,负责后续为我们点菜,上菜等服务。在这个例子中,张三的职责就是将客人招到店内就可以,店内的服务他不参与。而李四/王五/赵六才是为我们真正提供服务的员工。

而我们之前所说的使用socket返回的文件描述符就是张三,他的任务就是接收到新连接就可以了。真正提供服务的其实是accept返回的文件描述符

最后别忘了关闭文件描述符,如果不关会导致可用的文件描述符越来越少

void Start()
{
    while (true)
    {
        struct sockaddr_in addr;
        socklen_t addrlen = sizeof(addr);
        memset(&addr, 0, sizeof(addr));
        int serverSocket = accept(_listensock, (sockaddr *)&addr, &addrlen);

        //业务逻辑

        close(serverSocket);
    }
}

1.5recvfrom(获取消息)

#include <sys/types.h>
#include <sys/socket.h>

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);

参数介绍:

  • sockfd:从哪个套接字中读取
  • buf:读到的数据存放的缓冲区
  • len:读len个字节
  • flags:读取方式,0表示阻塞读取
  • src_addr:发送端的信息
  • addrlen:输出型参数,表示src_addr的长度(必须初始化为sizeof(src_addr))

返回值说明:

  • 返回值>0:读取成功
  • 返回值=0:对端关闭连接了
  • 返回值<0:读取失败

由于recvfrom的参数较多,使用比较麻烦,所以我们可以对recvfrom简单封装成一个函数。

int Recvfrom(int sockfd, std::string& buffer)
{
    char temp[1024];
    sockaddr_in addr;
    socklen_t addrlen = sizeof(addr);
    int n = recvfrom(sockfd, temp, sizeof(temp) - 1, 0, (sockaddr *)&addr, &addrlen);
    if (n > 0)
    {
        temp[n] = 0;
        buffer = temp;
    }
    else if (n == 0)
    {
        std::cout << "you close the connect, me too" << std::endl;
    }
    else
    {
        std::cout << "recvfrom error" << std::endl;
    }
    return n;
}

你只需要告诉recvfrom从哪个文件描述符当中读,并且给他一个buffer用于保存读取的消息。


1.6sendto(发送消息)

#include <sys/types.h>
#include <sys/socket.h>

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);

参数介绍:

  • sockfd:从哪个套接字中读取
  • buf:将缓冲区中的数据发给对端
  • len:要发送多少个字节
  • flags:写入方式,0表示阻塞写入
  • src_addr:对端主机的信息(包括协议家族,IP,port)
  • addrlen:表示src_addr的长度

参数和recvfrom类似。

while (true)
{
    std::string buffer;
    std::cout << "Please enter# " << std::endl;
    getline(std::cin, buffer);
    sendto(sockfd, buffer.c_str(), buffer.size(), 0, (sockaddr *)&addr, addrlen);
}

当我们接受到了客户端发来的消息后,就可以将这个消息经过处理后,还给客户端。


1.7服务端源码

到这里一个简单的服务器就可以正常启动了。

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <functional>
#include <unordered_map>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <pthread.h>

class TcpServer
{
    const int backlog = 10;

public:
    TcpServer(uint16_t &port, std::string ip = "")
    {
        // 创建套接字
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensock < 0)
        {
            std::cout << "create socket error" << std::endl;
            exit(1);
        }
        std::cout << "create socket success, socket: " << _listensock << std::endl;

        // 绑定IP和端口
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = ip.empty() ? INADDR_ANY : inet_addr(ip.c_str());
        if (bind(_listensock, (sockaddr *)&addr, sizeof(addr)) < 0)
        {
            std::cout << "bind error" << std::endl;
            exit(2);
        }
        std::cout << "bind success" << std::endl;

        // 监听listen
        if (listen(_listensock, backlog) < 0)
        {
            std::cout << "listen error" << std::endl;

            exit(3);
        }
        std::cout << "listen success" << std::endl;
    }

    ~TcpServer()
    {
        close(_listensock);
    }

    void Start()
    {
        while (true)
        {
            struct sockaddr_in addr;
            socklen_t addrlen = sizeof(addr);
            memset(&addr, 0, sizeof(addr));
            int serverSocket = accept(_listensock, (sockaddr *)&addr, &addrlen);

            while (true)
            {
                std::string buffer;
                int n = Recvfrom(serverSocket, buffer);
                if (n > 0)
                    std::cout << buffer << std::endl;
                else 
                    break;

                sendto(serverSocket, buffer.c_str(), buffer.size(), 0, (sockaddr*)&addr, sizeof(addr));
            }

            close(serverSocket);
        }
    }

    int Recvfrom(int sockfd, std::string& buffer)
    {
        char temp[1024];
        sockaddr_in addr;
        socklen_t addrlen = sizeof(addr);
        int n = recvfrom(sockfd, temp, sizeof(temp) - 1, 0, (sockaddr *)&addr, &addrlen);
        if (n > 0)
        {
            temp[n] = 0;
            buffer = temp;
        }
        else if (n == 0)
        {
            std::cout << "you close the connect, me too" << std::endl;
        }
        else
        {
            std::cout << "recvfrom error" << std::endl;
        }
        return n;
    }

private:
    int _listensock;
};

2.客户端实现

2.1socket(创建套接字)

和服务端一样,我们也要创建套接字

void Usage()
{
    std::cout << "Please enter: ./Client ip port" << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage();
        return 4;
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        std::cout << "create socket error" << std::endl;
        exit(1);
    }
    std::cout << "create socket success, socket: " << sockfd << std::endl;

    return 0;
}

2.2connect(发起连接)

客户端既不需要绑定bind,也不需要监听listen,直接向服务端发起connect即可。

  • 服务端需要绑定一个固定IP和端口,防止用户找不到,但是客户端如果绑定固定端口,可能会导致多个不同应用的客户端绑定的是同一个端口的,系统会在connect之后为客户端分配一个未使用的端口号。
  • 客户端也不需要listen,listen函数是用于接受来自其他方的连接的,而客户端都是主动发起连接的一方,例如:都是你主动打开抖音(向服务端发起连接)。
#include <sys/types.h>   
#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数介绍:

  • sockfd:用于标识即将发起连接请求的客户端套接字
  • addr:用于标识即将发起连接请求的客户端套接字
  • addrlen:addr的大小

返回值说明:

成功返回0,失败返回-1

sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip.c_str());
if (connect(sockfd, (sockaddr *)&addr, addrlen) < 0)
{
    std::cout << "connect error" << std::endl;

    exit(2);
}
std::cout << "connect success" << std::endl;

2.3sendto(发送消息)

发送给服务端你要处理的消息

while (true)
{
    std::string buffer;
    std::cout << "Please enter# " << std::endl;
    getline(std::cin, buffer);
    sendto(sockfd, buffer.c_str(), buffer.size(), 0, (sockaddr *)&addr, addrlen);
}

因为前面使用connect已经填写了addr。所以我们可以直接使用。


2.4recvfrom(接受消息)

接受客户端已经处理好的消息

//接受服务端的消息
char temp[128];
sockaddr_in raddr;
socklen_t raddrlen = sizeof(addr);
int n = recvfrom(sockfd, temp, sizeof(temp) - 1, 0, (sockaddr *)&raddr, &raddrlen);
if (n <= 0)
{
    std::cout << "recvfrom error" << std::endl;
    exit(3);
}
temp[n] = 0;
std::cout << "echo# " << temp << std::endl;

2.5客户端源码

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "LogMessage.hpp"

void Usage()
{
    std::cout << "Please enter: ./Client ip port" << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage();
        return 4;
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        std::cout << "create socket error" << std::endl;
        exit(1);
    }
    std::cout << "create socket success, socket: " << sockfd << std::endl;

    sockaddr_in addr;
    socklen_t addrlen = sizeof(addr);
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip.c_str());
    if (connect(sockfd, (sockaddr *)&addr, addrlen) < 0)
    {
        std::cout << "connect error" << std::endl;

        exit(2);
    }
    std::cout << "connect success" << std::endl;

    while (true)
    {
        std::string buffer;
        std::cout << "Please enter# " << std::endl;
        getline(std::cin, buffer);
        sendto(sockfd, buffer.c_str(), buffer.size(), 0, (sockaddr *)&addr, addrlen);

        // 接受服务端的消息
        char temp[128];
        sockaddr_in raddr;
        socklen_t raddrlen = sizeof(addr);
        int n = recvfrom(sockfd, temp, sizeof(temp) - 1, 0, (sockaddr *)&raddr, &raddrlen);
        if (n <= 0)
        {
            std::cout << "recvfrom error" << std::endl;
            exit(3);
        }
        temp[n] = 0;
        std::cout << "echo# " << temp << std::endl;
    }

    return 0;
}

3.运行程序

简单测试一下:

可以运行,这样一个简单TCP服务就写好了。那这段代码有问题吗?有,而且很大。

如果现在有两个用户想要访问这个服务端,上面那个用户可以正常运行,但是下面那个不行,消息并不会回显。左边的服务端也没有接受到客户端发送的消息。为什么呢?

void Start()
{
    while (true)
    {
        struct sockaddr_in addr;
        socklen_t addrlen = sizeof(addr);
        memset(&addr, 0, sizeof(addr));
        int serverSocket = accept(_listensock, (sockaddr *)&addr, &addrlen);

        while (true)
        {
            std::string buffer;
            int n = Recvfrom(serverSocket, buffer);
            if (n > 0)
                std::cout << buffer << std::endl;
            else 
                break;

            sendto(serverSocket, buffer.c_str(), buffer.size(), 0, (sockaddr*)&addr, sizeof(addr));
        }

        close(serverSocket);
    }
}

注意看服务端的代码,他是单进程的,并且在接收到用户发起的新连接之后,会进入下面的死循环,从此往后,他只能接受到来自第一个用户发送的消息了,只有在第一个用户断开连接之后,才会接受来自其他用户的连接。

客户为什么会显示连接成功

按照刚才的思路,服务端的执行流一直在执行下面接受第一个用户的消息,没有再次调用accept函数,但是为什么客户端会显示connect成功呢?

客户端connect成功,说明请求连接是成功的,但是服务端暂时没有调用accept获取该连接,底层会帮我们维护一个连接队列(listen的第二个参数)。将没有accept的新连接放到这个队列当中。虽然服务端还没有获取该连接,但是connect不关心服务端有没有获取,只关心有没有将新连接成功交给服务端,所以客户端显示连接成功。

将用户1关闭之后,用户而就可以正常的进行服务了

如何解决这个问题?

我们上面的问题基本上都是单执行流导致的,所以我们需要将我们的服务端改成多执行流即可。

4.多执行流

主要分为多进程版本和多线程版本。我们先将前面的服务(读取用户信息,经过处理再发给用户)封装一下

void Start()
{
    while (true)
    {
        //获取新连接
        struct sockaddr_in addr;
        socklen_t addrlen = sizeof(addr);
        memset(&addr, 0, sizeof(addr));
        int serverSocket = accept(_listensock, (sockaddr *)&addr, &addrlen);
        
        //执行任务
        Server(serverSocket, addr);

        close(serverSocket);
    }
}

void Server(int serverSocket, sockaddr_in addr)
{
    while (true)
    {
        std::string buffer;
        int n = Recvfrom(serverSocket, buffer);
        if (n > 0)
            std::cout << buffer << std::endl;
        else
            break;

        sendto(serverSocket, buffer.c_str(), buffer.size(), 0, (sockaddr *)&addr, sizeof(addr));
    }
}

前面我们就是以上面这种单进程的方式进行的。

4.1多进程

让父进程获取新连接,并且创建子进程执行服务。

子进程会继承父进程的文件描述符表,当子进程创建的孙子进程也会继承父进程的文件描述符表。

对于父进程来说,创建完子进程之后,就可以关闭accpet返回的文件描述符了(后续服务让子进程进行),自己继续通过socket的返回值获取新连接,而对于子进程来说,socket返回的文件描述符也没有意义,所以可以关闭。

注意:对于父进程来说,一定要关闭accept返回的文件描述符,如果只分配不关闭的话,会导致文件描述符越来越多,可用的文件描述符越来越少,这种问题叫做文件描述符泄露。但是对于子进程来说,关闭文件描述符socket文件描述符不是必须的(但是最好也要关闭)

等待子进程问题

我们知道,在父进程创建子进程之后,需要等待子进程,否则子进程会变成僵尸进程,造成给内存泄露的问题,所以父进程需要调用wait或者waitpid等待子进程。

  • 但是如果采用了阻塞式等待的话,那就和单进程没什么区别了
  • 如果采用非阻塞式等待,虽然也可以,但是父进程需要不断消耗资源去检测有无子进程退出

无论哪种方法都不太合适,所以我们可以想出一种无需等待子进程的方法

4.1.2孙子进程

int fd = fork();
if (fd == 0)
{
    //child
    close(_listensock);
    if (fork() > 0)
    {
        exit(0);
    }
    //孙子进程

    Server(serverSocket, addr);
    close(serverSocket);
    exit(0);
}
else if (fd > 0)
{
    //father
    close(serverSocket);
    waitpid(fd, nullptr, 0);
}
else
{
    std::cout << "fork error" << std::endl;
}

创建子进程之后,子进程会再创建一个孙子进程,子进程创建完孙子进程之后就退出,让孙子进程变成孤儿进程,从而被操作系统领养。此后,而父进程创建完子进程之后就开始等待子进程退出,子进程创建完孙子进程就退出,所以父进程并不需要等待很长的时间。

这种方式也是可以成功运行的。

确实创建了两个进程,并且这两个进程的ppid是1(被bash领养了),当客户端退出的时候,操作系统会自动释放孤儿进程的资源

4.1.3信号捕捉

在学习系统的信号部分时,我们学过当子进程退出时会发送SIGCHLD信号,信号的主要作用是通知父进程其一个子进程已经终止,以便父进程可以执行一些清理工作,比如回收子进程的资源。

父进程只要捕捉这个信号,并将这个信号忽略即可。子进程会自动释放资源。

signal(SIGCHLD, SIG_IGN);


// V3多进程信号版
int fd = fork();
if (fd == 0)
{
    // child
    close(_listensock);
    Server(serverSocket, addr);
    close(serverSocket);
    exit(0);
}
else if (fd > 0)
{
    // father
    close(serverSocket);
}

也是可以正常运行的。

也是正常的三个进程在运行。接下来我们将两个子进程退出看看

最后只剩下父进程在跑了,而且子进程也没有显示出僵尸状态

4.2多线程

虽然使用多进程的方式可以解决问题,但是多进程的方式并不是主流,原因是多进程的创建成本比较大,每个进程独享一个进程地址空间,页表,进程控制块,文件描述符表等。实际开发中,我们会更倾向于选择使用多线程的方式。

只需要让主线程负责获取新连接,子线程负责给用提供服务(读取用户的信息,并将信息经过处理后,再返回给用户)。

因为子线程和主线程共享一个文件描述符表,所以并不像多进程那样双方都需要关闭文件描述符,只需要子线程在服务完之后关闭文件描述符即可。

线程等待问题

和进程一样,我们创建完线程之后,也是需要等待线程的,但是也有方法可以不用进行等待,那就是线程分离(pthread_detach),线程如果分离了,会在退出时自动释放资源。


有了大概思路之后我们就可以开始实现了

struct ThreadData
{
    ThreadData(int sockfd, sockaddr_in user, TcpServer *self)
        : _sockfd(sockfd), _user(user), _self(self)
    {
    }

public:
    int _sockfd;
    sockaddr_in _user;
    TcpServer *_self;
};

先创建一个线程传递的参数,用于线程将来调用Server函数。这个参数是一个结构体,内部有三个对象,sockfd告诉线程从哪个文件描述符中读,user告诉线程客户端的信息(IP,Port),剩下一个参数等会说

pthread_t p;
ThreadData *data = new ThreadData(serverSocket, addr, this);
pthread_create(&p, nullptr, Handler, (void *)data);

我们可以开始创建一个线程了,但是pthread_create的第三个参数是一个返回值为void*,参数也为void*的函数指针,如果传的是类内成员函数Handler,就会报错

因为类内成员函数会自带一个隐藏的this指针,为了解决这个办法,我们只能将Handler函数设置为static

static void* Handler(void* arg)
{

}

但是这时,新的问题又出现了,Handler是静态的,无法调用类内成员函数Server了,所以我们就给线程传递的参数中增加了第三个对象,一个自己类型的指针。

static void *Handler(void *arg)
{
    pthread_detach(pthread_self());
    ThreadData *data = static_cast<ThreadData *>(arg);
    data->_self->Server(data->_sockfd, data->_user)
}

先将线程进行分离,然后将arg参数强转为ThreadData类型,然后通过我们之前传递的this指针来调用Server函数。

void Start()
{
    signal(SIGCHLD, SIG_IGN);
    while (true)
    {
        // 获取新连接
        struct sockaddr_in addr;
        socklen_t addrlen = sizeof(addr);
        memset(&addr, 0, sizeof(addr));
        int serverSocket = accept(_listensock, (sockaddr *)&addr, &addrlen);

        pthread_t p;
        ThreadData *data = new ThreadData(serverSocket, addr, this);
        pthread_create(&p, nullptr, Handler, (void *)data);
    }
}

static void *Handler(void *arg)
{
    pthread_detach(pthread_self());
    ThreadData *data = static_cast<ThreadData *>(arg);
    data->_self->Server(data->_sockfd, data->_user);
    close(data->_sockfd);
}

测试:

也是可以成功运行的。

创建了三个线程(PID都相同)。

并且查看当前进程,可以看到创建了三个文件描述符,3为主线程socket获取的,其他两个是accept获得的。

当用户退出时,也可以正常关闭文件描述符。

4.3线程池版本

刚刚我们选的多线程版本还存在问题吗?答案是还存在的。

每次用户发起连接后,才会创建线程,并且在断开连接,会释放线程,这样反复创建释放,效率就会比较低

如何解决这个问题呢,我们需要使用线程池来解决。线程池就是会预先创建一批线程,这些线程会进入休眠状态,等到有用户连接时,会将一个线程唤醒,然后让这个线程去为用户提供服务。

准备工作

首先我们需要一个线程池

template <class T>
class ThreadPool
{
private:
    ThreadPool(size_t thread_num = 5, size_t task_num = 10)
        : _thread_num(thread_num), _task_num(task_num)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);

        for (int i = 0; i < _thread_num; i++)
        {
            std::string thread_name = GetPthreadName();
            _threads.push_back(Thread<void, std::string>(std::bind(&ThreadPool::ThreadRun, this, std::placeholders::_1), thread_name, thread_name));
            log.LogMessage(Debug, "create %s success", thread_name.c_str());
        }
    }
    ThreadPool(const ThreadPool<T> &tp) = delete;
    const ThreadPool<T> &operator=(const ThreadPool<T> &tp) = delete;

public:
    static ThreadPool *GetInstance()
    {
        if (_instance == nullptr)
        {
            LockGuard lg(&_mtinst);
            if (_instance == nullptr)
            {
                _instance = new ThreadPool<T>();
            }
        }

        return _instance;
    }

    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
    }

    void ThreadRun(std::string name)
    {
        while (true)
        {
            T t;
            {
                LockGuard lg(&_mutex);
                while (_task_queue.empty())
                {
                    ThreadWait(name);
                }
                t = _task_queue.front();
                _task_queue.pop();
            }
            t();
        }
    }

    void Start()
    {
        for (auto &th : _threads)
        {
            th.Create();
        }
    }

    void Wait()
    {
        for (auto &th : _threads)
        {
            th.Jion();
        }
    }

    void Push(T date)
    {
        LockGuard lock(&_mutex);
        _task_queue.push(date);
        ThreadWakeUp();
    }

private:
    void ThreadWait(const std::string &thread_name)
    {
        log.LogMessage(Debug, "%s start to wait", thread_name.c_str());
        pthread_cond_wait(&_cond, &_mutex);
    }

    void ThreadWakeUp()
    {
        pthread_cond_signal(&_cond);
    }

private:
    std::vector<Thread<void, std::string>> _threads;
    std::queue<T> _task_queue;
    size_t _thread_num;
    size_t _task_num;

    pthread_mutex_t _mutex;
    pthread_cond_t _cond;

    static ThreadPool<T> *_instance;
    static pthread_mutex_t _mtinst;

    Log log;
};

template <class T>
ThreadPool<T> *ThreadPool<T>::_instance = nullptr;

template <class T>
pthread_mutex_t ThreadPool<T>::_mtinst = PTHREAD_MUTEX_INITIALIZER;

先完成线程池的代码,该线程池会自动创建5个线程,并且会绑定ThreadRun函数,然后我们使用你start函数就可以启动线程池,5个线程会被启动,开始执行ThraedRun函数,并被阻塞住,我们只需要将任务push到_task_queue任务队列当中即可,当任务push之后,会唤醒一个线程,并让这个线程去执行刚刚push的任务。

注意:上面有一个LogMessage函数,主要就是用于打印日志,方便我们观看,还有一个LockGuard函数,我们将锁交给他,他会帮我们管理这个锁,出了作用域之后自动释放。下面是这个函数的原型。

#pragma once

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

class Mutex;
class LockGuard;

class Mutex
{
public:
    Mutex(pthread_mutex_t *lock)
        :_lock(lock)
    {}
    void Lock()
    {
        pthread_mutex_lock(_lock);
    }
    void Unlock()
    {
        pthread_mutex_unlock(_lock);
    }
    ~Mutex()
    {}

private:
    pthread_mutex_t *_lock;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t* mutex)
        : _mutex(mutex)
    {
        _mutex.Lock();
    }

    ~LockGuard()
    {
        _mutex.Unlock();
    }

private:
    Mutex _mutex;
};

封装用户信息

我们前面使用sockaddr_in来保存用户端发来的信息,例如IP和端口号,但是需要我们手动写,将sockaddr_in中的信息提取出来,比较麻烦,我们可以封装成一个类

class InetAddr
{
public:
    InetAddr(const sockaddr_in addr)
        : _addr(addr)
    {
        _ip = inet_ntoa(addr.sin_addr);
        _port = ntohs(addr.sin_port);
    }

    std::string GetUser()
    {
        std::string temp;
        temp += _ip;
        temp += " : ";
        temp += std::to_string(_port);

        return temp;
    }

    std::string& GetIp()
    {
        return _ip;
    }

    uint16_t GetPort()
    {
        return _port;
    }

    sockaddr_in& GetAddr()
    {
        return _addr;
    }

private:
    std::string _ip;
    uint16_t _port;
    sockaddr_in _addr;
};

我们只需要将sockaddr_in交给这个函数,他就会自动帮我们提取IP和端口号,并且GetUser函数还会返回IP+端口的一个字符串

线程池版本整体框架

现在完事具备了,可以正式开始写服务了

TcpServer(uint16_t &port, std::string ip = "")
{
    // 创建套接字
    _listensock = socket(AF_INET, SOCK_STREAM, 0);
    if (_listensock < 0)
    {
        lg.LogMessage(Error, "create socket error");
        exit(1);
    }
    lg.LogMessage(Normal, "create socket success, socket:%d", _listensock);

    int opt = 1;
    setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));

    // 绑定IP和端口
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = ip.empty() ? INADDR_ANY : inet_addr(ip.c_str());
    if (bind(_listensock, (sockaddr *)&addr, sizeof(addr)) < 0)
    {
        lg.LogMessage(Error, "bind error");
        exit(2);
    }
    lg.LogMessage(Normal, "bind success");

    // 监听listen
    if (listen(_listensock, backlog) < 0)
    {
        lg.LogMessage(Error, "listen error");
        exit(3);
    }
    lg.LogMessage(Normal, "listen success");

    ThreadPool<task_t>::GetInstance()->Start();
}

首先就是我们要在构造函数中添加,让线程池启动。

using task_t = std::function<void()>;
using callback_t = std::function<void(std::string&)>;

然后使用function,设计将来我们会将什么函数push进线程池内。

void Start()
{
    while (true)
    {
        struct sockaddr_in addr;
        socklen_t addrlen = sizeof(addr);
        memset(&addr, 0, sizeof(addr));
        int serverSocket = accept(_listensock, (sockaddr *)&addr, &addrlen);
        // 从这往后,都使用serverSocket
        InetAddr user(addr);

   
        // V5线程池版
        task_t task = std::bind(&TcpServer::Routine, this, serverSocket, user);
        ThreadPool<task_t>::GetInstance()->Push(task);
    }
}

每接受到一个用户申请的连接后,我们就创建一个task_t的函数对象,并且绑定一下对应的函数以及其参数,再将这个函数push到线程池内,push后自动唤醒一个线程去执行这个函数。

接下来我们只需要完成Routine函数的逻辑即可。这个函数我们可以设计成之前的Server

void Server(int serverSocket, InetAddr user)
{
    sockaddr_in addr = user.GetAddr();
    socklen_t addrlen = sizeof(addr);
    char temp[1024];
    while (true)
    {
        std::string buffer = "[" + user.GetUser() + "] ";
        int n = recvfrom(serverSocket, temp, sizeof(temp) - 1, 0, (sockaddr *)&addr, &addrlen);
        if (n > 0)
        {
            temp[n] = 0;
            buffer += temp;
            sendto(serverSocket, buffer.c_str(), buffer.size(), 0, (sockaddr *)&addr, sizeof(addr));
        }
        else if (n == 0)
        {
            std::cout << "you close the connect, me too" << std::endl;
            break;
        }
        else
        {
            std::cout << "recvfrom error" << std::endl;
            break;
        }
    }
    close(serverSocket);
}

读取用户消息,然后处理(这里的处理是在消息前面加上客户端的IP和端口),再重新发送给用户。

我们先使用Server测试一下逻辑有无问题。

启动服务端之后,帮我们创建了五个线程,并且这五个线程都进入阻塞等待

最后也是符合我们的预期。

如果我们想完成更多功能呢,用户启动的时候,我们给他发送能提供哪些服务,根据用户的选择,执行不同的服务。

为了达到刚刚的目标,首先我们需要一些函数

提供各种业务

void Ping(std::string& str)
{
    str = "Pong";
}

如果用户选择Ping函数,无论用户发送什么我们都给他发送一个Pong。

void Transforme(std::string& str)
{
    for (auto& ch : str)
    {
        if ('a' <= ch && ch <= 'z')
        {
            ch -= 32;
        }
    }
}

Transforme函数将用户传入的字符串全部改为大写字母。

void  Translate(std::string& str)
{
    std::string chinese = dict.Find(str);
    str = chinese;
}

Translate函数会将用户传过来的英文转化成中文返还给用户。

我们先从网上找一些中英文对照的单词。并将这些单词保存在一个文件当中

我们要做的是封装一个类,将这个文件中的所有单词读取出来(按行读),然后将每一行单词和对应的中文保存起来。

#include <iostream>
#include <cstring>
#include <string>
#include <fstream>
#include <vector>
#include <unordered_map>

const std::string path = "./word/E_C.txt";

class Dictionary
{
public:
    Dictionary()
    {
        Set();
    }

    void Updata()
    {
        lines.clear();
        dict.clear();
        Set();
    }

    void Set()
    {
        std::ifstream file(path);
        if (!file.is_open())
        {
            std::cerr << "打开文件失败" << std::endl;
            exit(1);
        }

        std::string buffer;
        while (std::getline(file, buffer))
        {
            lines.push_back(buffer);

            //读取空行
            std::getline(file, buffer);
        }
        
        //切分
        for (auto& line : lines)
        {
            size_t left = line.find(" ");
            //真正的单词是从left + 1开始找的
            size_t right = line.find(" ", left + 1);
            dict.insert(std::make_pair(line.substr(left + 1, right - left - 1), line.substr(right + 1)));
        }
    }

    std::string Find(std::string word)
    {
        auto it = dict.find(word);
        if (it == dict.end())
        {
            return "Not found";
        }
        else 
        {
            return it->second;
        }
    }

private:
    std::vector<std::string> lines;
    std::unordered_map<std::string, std::string> dict;
};

Set函数会执行我们刚刚说的那几步,按行读取文本,然后切分并保存进dict中,未来我们只需要调用Find函数就能获取英文对应的汉语。 

我们在TcpServer中创建一个函数名和函数的映射的哈希表。

std::unordered_map<std::string, callback_t> _funcs;

我给TcpServer中添加一个函数,用于添加新的函数。

void AddFunc(std::string func_name, callback_t task)
{
    _funcs.insert({func_name, task});
}

有了这几个函数之后,我们可以将这几个函数交给TcpServer

t->AddFunc("ping", Ping);
t->AddFunc("transforme", Transforme);
t->AddFunc("translate", Translate);

Routinue函数

我们想让这个函数达到的效果就是,将来一个用户申请连接之后,我们就让一个线程去执行这个函数。

  • 1.先给用户发送有哪些服务
// 向用户发送有哪些功能
std::string str = GetAllFunction();
Sendto(sockfd, user, str);

GetAllFunct函数就是将_funcs中的所有函数的函数名形成一个字符串。然后发送给字符串。

  • 2.读取用户选择
std::string buffer;
Recvfrom(sockfd, buffer);

将用户想要的选择读取到buffer中。

  • 3.读取用户的输入
std::string message;
Recvfrom(sockfd, message);

读取用户对相应服务的输入信息

  • 4.执行用户选择服务
// 根据选择执行相应的方法
auto func = _funcs.find(buffer);
if (func != _funcs.end())
{
    func->second(message);
}
else 
{
    message = "choise the tast not exist";
}

buffer中就是客户选择的服务,直接去func中查询。

  • 5.将数据写回
//将数据写回
Sendto(sockfd, user, message);
close(sockfd);

再将数据写回,再将sockfd写回去。

长连接问题

我们之前写的服务都是长连接(连接之后死循环)。它们之间的连接并不会主动关闭,后续的读写操作会继续使用这个连接。长连接的缺点就是,连接数过多时,影响服务端的性能和并发数量

所以我们尽量使用短链接的方式,一次连接就完成了

通常浏览器访问服务器的时候就是短连接。对于服务端来说,长连接会耗费服务端的资源,而且用户用浏览器访问服务端相对而言不是很频繁的如果有几十万,上百万的连接,服务端的压力会非常大,甚至会崩溃。所以对于并发量大,请求频率低的,建议使用短连接

客户端

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "LogMessage.hpp"

void Usage()
{
    std::cout << "Please enter: ./Client ip port" << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage();
        return 4;
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);

    Log lg;
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        lg.LogMessage(Error, "create socket error");
        exit(1);
    }
    lg.LogMessage(Normal, "create socket success, socket:%d", sockfd);

    // 2.发起连接
    sockaddr_in addr;
    socklen_t addrlen = sizeof(addr);
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip.c_str());
    if (connect(sockfd, (sockaddr *)&addr, addrlen) < 0)
    {
        lg.LogMessage(Error, "connect error");
        exit(2);
    }
    lg.LogMessage(Normal, "connect success");

    // 3.先接受有哪些服务
    char temp[128];
    sockaddr_in raddr;
    socklen_t raddrlen = sizeof(addr);
    int n = recvfrom(sockfd, temp, sizeof(temp) - 1, 0, (sockaddr *)&raddr, &raddrlen);
    if (n <= 0)
    {
        std::cout << "recvfrom error" << std::endl;
        exit(3);
    }
    temp[n] = 0;
    std::cout << temp << std::endl;

    // 4.向服务端发送你想要执行的服务
    std::string buffer;
    std::cout << "Please enter# " << std::endl;
    getline(std::cin, buffer);
    sendto(sockfd, buffer.c_str(), buffer.size(), 0, (sockaddr *)&addr, addrlen);

    // 5.为你要执行的服务发送消息
    std::cout << "Please enter you message: " << std::endl;
    getline(std::cin, buffer);
    sendto(sockfd, buffer.c_str(), buffer.size(), 0, (sockaddr *)&addr, addrlen);

    // 6.接受处理后的信息
    raddrlen = sizeof(addr);
    n = recvfrom(sockfd, temp, sizeof(temp) - 1, 0, (sockaddr *)&raddr, &raddrlen);
    if (n > 0)
    {
        temp[n] = 0;
        std::cout << temp << std::endl;
    }

    return 0;
}

运行程序

我们发先客户端在执行完一次服务之后就退出了,而服务端在执行完服务之后,线程也阻塞挂起了。

执行transforme之后,也会将用户的信息转化成大写。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/550174.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

简单3步,OpenHarmony上跑起ArkUI分布式小游戏

标准系统新增支持了方舟开发框架&#xff08;ArkUI&#xff09;、分布式组网和 FA 跨设备迁移能力等新特性&#xff0c;因此我们结合了这三种特性使用 ets 开发了一款如下动图所示传炸弹应用。 打开应用在通过邀请用户进行设备认证后&#xff0c;用户须根据提示完成相应操作&am…

2024-14.python前端+Django

第四篇 web前端 第1章 、Web的基本概念 前端基础总共分为三部分&#xff1a;html、css和js。 1.3、HTTP协议 1.3.1 、http协议简介 HTTP协议是Hyper Text Transfer Protocol&#xff08;超文本传输协议&#xff09;的缩写,是用于万维网&#xff08;WWW:World Wide Web &am…

神经网络压缩图像

简介 典型的压缩管道由四个组件组成&#xff1a; 编码&#xff1a;输入图像 x x x通过编码器函数 ε \varepsilon ε&#xff0c;将其转换为潜在表示 z z z。 量化&#xff1a;截断 z z z以丢弃一些不重要的信息 熵编码&#xff1a;使用某种形式的熵编码&#xff08;例如&…

淘宝API商品详情数据在数据分析行业中具有不可忽视的重要性

淘宝商品详情数据在数据分析行业中具有不可忽视的重要性。这些数据为商家、市场分析师以及数据科学家提供了丰富的信息&#xff0c;有助于他们更深入地理解市场动态、消费者行为以及商品竞争态势。以下是淘宝商品详情数据在数据分析行业中的重要性体现&#xff1a; 请求示例&a…

OpenStack 入门体验

目录 一、云计算概述 1.1、什么是云计算 1.2、云计算的服务模型 1&#xff09;IaaS 2&#xff09;PaaS 3&#xff09;SaaS 1.3、OpenStack 概述 1&#xff09;OpenStack 起源 2&#xff09;什么是 OpenStack 3&#xff09;OpenStack 优势 二、OpenStack 一…

基于JavaWeb开发的springboot网约车智能接单规划小程序[附源码]

基于JavaWeb开发的springboot网约车智能接单规划小程序[附源码] &#x1f345; 作者主页 央顺技术团队 &#x1f345; 欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; &#x1f345; 文末获取源码联系方式 &#x1f4dd; &#x1f345; 查看下方微信号获取联系方式 承接各种…

Java项目如何使用EasyExcel插件对Excel数据进行导入导出

文章目录 一、EasyExcel的示例导入依赖创建实体类数据导入和导出 二、EasyExcel的作用三、EasyExcel的注解 EasyExcel是一个阿里巴巴开源的excel处理框架&#xff0c;它以使用简单、节省内存著称。在解析Excel时&#xff0c;EasyExcel没有将文件数据一次性全部加载到内存中&…

使用 Flask 和 Flask-Login 构建用户认证的 Web 应用程序

在本篇技术博客中&#xff0c;我们将学习如何使用 Flask 框架和 Flask-Login 扩展构建一个具有用户认证功能的简单 Web 应用程序。我们将从创建 Flask 应用实例开始&#xff0c;然后逐步添加用户认证功能。 1. 安装依赖库 首先&#xff0c;确保您已经安装了 Flask、Flask-PyM…

大模型微调的几种常见方法

在文章深入理解大语言模型微调技术中&#xff0c;我们详细了解大语言模型微调的概念和训练过程&#xff0c;本篇给大家介绍大模型微调常见的7种训练方法。 1、Adapter Tuning 2019年谷歌的研究人员首次在论文《Parameter-Efficient Transfer Learning for NLP》提出针对 BERT 的…

2024年Q1季度空调行业线上市场销售数据分析

Q1季度一直以来就是空调行业的淡季&#xff08;旺季一般出现在5月至7月&#xff09;。而今年&#xff0c;空调线上市场低迷发展的态势越发明显。 根据鲸参谋数据显示&#xff0c;2024年1月至3月线上电商平台&#xff08;京东天猫淘宝&#xff09;空调累计销量约270万件&#x…

开源 Ruo-Yi 项目引入 Mybatis-Plus:3.5.3 报错ClassNotFoundException:

开源 Ruo-Yi 项目引入 Mybatis-Plus:3.5.3 报错ClassNotFoundException&#xff1a; Caused by: java.lang.ClassNotFoundException: com.baomidou.mybatisplus.extension.plugins.MybatisPlusInter1 分析问题 控制台报错说明我们引入的 mybatis-plus 的依赖里找不到com.baom…

Apache Tomcat 简单使用

Apache Tomcat 下载 download Tomcat服务器是一个免费的开放源代码的Web应用服务器&#xff0c;属于轻量级应用服务器&#xff0c;在中小型系统和并发访问用户不是很多的场合下被普遍使用&#xff0c;是开发和调试JSP程序的首选。 支持JDK版本 JDK8 要下载tomcat 9.0.x版本 …

【云计算】混合云分类

《混合云》系列&#xff0c;共包含以下 3 篇文章&#xff1a; 【云计算】混合云概述【云计算】混合云分类【云计算】混合云组成、应用场景、风险挑战 &#x1f60a; 如果您觉得这篇文章有用 ✔️ 的话&#xff0c;请给博主一个一键三连 &#x1f680;&#x1f680;&#x1f68…

Samtec应用分享 | 汽车应用中的视觉系统

【前言】 视觉系统在未来的汽车设计中扮演着关键的角色。 在过去&#xff0c;一直是由驾驶员掌握和应对道路上的危险&#xff0c;但现代车辆在保障驾驶安全方面发挥着前所未有的作用。 视觉系统&#xff0c;无论是可见光摄像头还是先进的探测系统&#xff0c;如激光雷达&…

分类损失函数与评估指标

目录 1 评估指标 1.1 准确率 1.2 精确率 1.3 召回率 1.4 F1 score 1.5 ROC曲线 1.6 AUC 1.7 PRC曲线的优势 2 损失函数 1. 负对数似然损失 2. 交叉熵损失 3. 指数损失 3 分类问题为什么用交叉熵损失不用 MSE 损失 1 评估指标 混淆矩阵 TP(True Positive) ---- 正…

「51媒体」媒体邀约采访的分类?

传媒如春雨&#xff0c;润物细无声&#xff0c;大家好&#xff0c;我是51媒体网胡老师。 媒体邀约采访可以根据不同的标准进行分类。以下是一些常见的分类方式&#xff1a; 1. 按照邀约形式&#xff1a; - 电话邀约&#xff1a;通过电话与媒体联系&#xff0c;说明采访或报道…

免费的 ChatGPT、GPT4.0、GPTs、Midjourney-AI绘画(国内版)

&#x1f525;博客主页&#xff1a;只恨天高 ❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ ChatGPT3.5、GPT4.0、GPTs、AI绘画相信对大家应该不感到陌生吧&#xff1f;简单来说&#xff0c;GPT-4技术比之前的GPT-3.5相对来说更加智能&#xff0c;会根据用户的要求生成多种内容…

【Java NIO】那NIO为什么速度快?

Java IO在工作中其实不常用到&#xff0c;更别提NIO了。但NIO却是高效操作I/O流的必备技能&#xff0c;如顶级开源项目Kafka、Netty、RocketMQ等都采用了NIO技术&#xff0c;NIO也是大多数面试官必考的体系知识。虽然骨头有点难啃&#xff0c;但还是要慢慢消耗知识、学以致用哈…

小例子——Flask网站开发(二)【保姆级】

问题一&#xff1a; 如何实现Flask发送get请求&#xff1f; 下面是python代码演示。 要使用Flask发送GET请求&#xff0c;首先需要安装Flask库&#xff0c;然后创建一个Flask应用。1. 首先在管理员窗口安装Flask库&#xff1a; ​ 2. 创建一个名为app.py的文件&#xff0c;并添…

mac 最小化全部程序回到桌面(基于alfred workflow)

前言 换到 mac 系统之后&#xff0c;很多快捷键根本就不好用&#xff0c;组合太多了&#xff0c;除了 cmd Q/W/A/S/X/R/Z/C/V &#xff0c;个人认为其它的真的一坨屎。像我的需求就是&#xff0c;开的窗口太多了&#xff0c;我需要全部最小化&#xff0c;再重新打开我需要那个…