网络编程套接字（三）之TCP服务器简单实现

目录

一、服务端TcpServer

1、tcp_server.hpp

2、tcp_server.cc

二、客户端TcpClient

tcp_client.cc

三、服务器和客户端进行通信

四、完整代码

一、服务端TcpServer

首先我们需要对服务端进行封装。我们需要的成员变量有IP地址，端口号port，以及监听套接字listensock。Tcp服务器实现的一般步骤就是：创建套接字，进行绑定，监听等待连接，获取连接，开始通信服务。下面我们一一讲解。

1、tcp_server.hpp

第一步，创建套接字使用的函数和UDP完全一样，只不过我们需要把socket的第二个参数由基于数据报的SOCK_DGRAM 更改为基于字节流式的SOCK_STREAM，SOCK_STREAM提供的就是一个有序的、可靠的、全双工的、基于连接的流式服务。其他参数和后续步骤完全一样。

第二步，进行绑定时使用的bind函数及其参数设置与UDP完全一样。

第三步，TCP和UDP不一样的地方就是这里了。前面我们知道UDP不是面向连接的，而TCP是面向连接的，所以服务器和客户端之间需要建立连接。而服务器首先需要做的就是进行监听，等待客户端的连接。需要使用listen函数。

NAME
       listen - listen for connections on a socket

SYNOPSIS
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

       int listen(int sockfd, int backlog);

参数说明：

sockfd：需要设置为监听状态的套接字对应的文件描述符。

backlog：全连接队列的最大长度。如果有多个客户端同时发来连接请求，此时未被服务器处理的连接就会放入连接队列，该参数代表的就是这个全连接队列的最大长度，一般不要设置太大，设置为5或10即可。

返回值：监听成功返回0，监听失败返回-1，同时错误码会被设置。

以上三步就是服务器的初始化。

第四步，TCP服务器初始化后就可以开始运行了，但TCP服务器在与客户端进行网络通信之前，服务器需要先获取到客户端的连接请求。我们需要使用accept函数。

NAME
       accept, accept4 - accept a connection on a socket

SYNOPSIS
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

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

参数说明：

sockfd：特定的监听套接字，表示从该监听套接字中获取连接。

addr：对端网络相关的属性信息，包括协议家族、IP地址、端口号等。

addrlen：调用时传入期望读取的addr结构体的长度，返回时代表实际读取到的addr结构体的长度，这是一个输入输出型参数。

返回值：获取连接成功返回接收到的套接字的文件描述符，获取连接失败返回-1，同时错误码会被设置。

注意：为什么获取连接成功了还要返回一个新的套接字呢？

类里面的监听套接字：用于获取客户端发来的连接请求。accept函数会不断从监听套接字当中获取新连接。
accept函数返回的套接字：用于为本次accept获取到的连接提供服务。

所以说，监听套接字的任务只是不断获取新连接，而真正为这些连接提供服务的套接字是accept函数返回的套接字，而不是监听套接字。

第五步，我们只要获取到客户端的连接，就可以对客户端进行服务了。

2、tcp_server.cc

与UDP相同，我们需要创建TCP服务器对象，然后对其进行初始化，然后运行。我们也是只需要绑定端口号即可。

二、客户端TcpClient

tcp_client.cc

作为TCP客户端，首先也是需要创建套接字。然后向服务器发起连接，最后就可以开始通信了。和UDP一样，客户端不需要绑定端口号。

客户端向服务器发起连接需要使用connect函数。

NAME
       connect - initiate a connection on a socket

SYNOPSIS
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

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

参数说明：

sockfd：特定的套接字，表示通过该套接字发起连接请求。

addr：对端网络相关的属性信息，包括协议家族、IP地址、端口号等。

addrlen：传入的addr结构体的长度。

返回值：连接或绑定成功返回0，连接失败返回-1，同时错误码会被设置。

三、服务器和客户端进行通信

首先，我们要知道：对于TCP服务器和客户端，我们也可以使用write函数和read函数进行消息的读取和发送。

我们先写一个服务，实现客户端给服务器发送什么消息，服务器就返回什么消息。

我们先写一个单进程版本的服务。tcp_server.hpp：

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cassert>
#include <signal.h>

static int gmv = 20;

static void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
    char buffer[1024];
    while (true)
    {
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s < 0)
        {
            std::cout << "接收信息失败！" << std::endl;
            break;
        }
        else if (s > 0)
        {
            buffer[s] = 0;
            std::cout << clientip << ":" << clientport << std::endl;
        }
        else
        {
            std::cout << "客户端关闭！" << std::endl;
            break;
        }
        write(sock, buffer, strlen(buffer));
    }
}

class TcpServer
{
public:
    TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
    {
    }

    void initTcpServer()
    {
        // 1.创建套接字
        listensock_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock_ < 0)
        {
            std::cout << "创建套接字失败！" << std::endl;
            exit(0);
        }

        // 2.进行绑定
        struct sockaddr_in src_server;
        bzero(&src_server, sizeof(src_server));
        src_server.sin_family = AF_INET;
        src_server.sin_port = htons(port_);
        inet_pton(AF_INET, ip_.c_str(), &src_server);
        socklen_t len = sizeof(src_server);
        if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
        {
            std::cout << "绑定失败！" << std::endl;
            exit(1);
        }

        // 3.开始监听,等待连接
        if (listen(listensock_, gmv) < 0)
        {
            std::cout << "监听失败！" << std::endl;
            exit(2);
        }

        std::cout << "服务器初始化成功！" << std::endl;
    }

    void start()
    {
        //signal(SIGCHLD, SIG_IGN);
        while (true)
        {
            // 4.获取链接
            struct sockaddr_in client_sock;
            socklen_t len = sizeof(client_sock);
            int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
            if (serversock < 0)
            {
                std::cout << "获取链接失败！" << std::endl;
                exit(3);
            }
            // 5.开始通信服务
            uint16_t client_port = ntohs(client_sock.sin_port);
            std::string client_ip = inet_ntoa(client_sock.sin_addr);
            std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;

            //version 1：单进程版服务————服务器一次只能处理一个客户端，只有处理完一个，才能处理下一个
            service(serversock, client_ip, client_port);
        }
    }

    ~TcpServer()
    {
        close(listensock_);
    }

private:
    int listensock_;
    std::string ip_;
    uint16_t port_;
};

结果：

上面的结果没有什么问题，那么，如果我们同时有两个客户端访问服务器，会发生什么呢？

因为我们目前所写的是一个单执行流版的服务器，这个服务器一次只能为一个客户端提供服务。所以我们发现，当其中一个客户端在和服务器进行通信的时候，另一个客户端并不能与服务器通信，也就是说服务器在某一时刻只能向一个客户端提供服务，只有对一个客户端提供服务完成后，才能对下一个服务器提供服务。

很显然，这种提供服务的方式是不符合实际的，一个服务器应该要能够同时给多个客户端提供服务。所以我们需要改进代码。

多进程服务版本：既然单进程不符合实际，那么我们最先想到的就是使用多进程——创建子进程给新的连接提供服务，父进程去继续获取新的连接。

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cassert>
#include <signal.h>

static int gmv = 20;

static void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
    char buffer[1024];
    while (true)
    {
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s < 0)
        {
            std::cout << "接收信息失败！" << std::endl;
            break;
        }
        else if (s > 0)
        {
            buffer[s] = 0;
            std::cout << clientip << ":" << clientport << std::endl;
        }
        else
        {
            std::cout << "客户端关闭！" << std::endl;
            break;
        }
        write(sock, buffer, strlen(buffer));
    }
}

class TcpServer
{
public:
    TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
    {
    }

    void initTcpServer()
    {
        // 1.创建套接字
        listensock_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock_ < 0)
        {
            std::cout << "创建套接字失败！" << std::endl;
            exit(0);
        }

        // 2.进行绑定
        struct sockaddr_in src_server;
        bzero(&src_server, sizeof(src_server));
        src_server.sin_family = AF_INET;
        src_server.sin_port = htons(port_);
        inet_pton(AF_INET, ip_.c_str(), &src_server);
        socklen_t len = sizeof(src_server);
        if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
        {
            std::cout << "绑定失败！" << std::endl;
            exit(1);
        }

        // 3.开始监听,等待连接
        if (listen(listensock_, gmv) < 0)
        {
            std::cout << "监听失败！" << std::endl;
            exit(2);
        }

        std::cout << "服务器初始化成功！" << std::endl;
    }

    void start()
    {
        signal(SIGCHLD, SIG_IGN);
        while (true)
        {
            // 4.获取链接
            struct sockaddr_in client_sock;
            socklen_t len = sizeof(client_sock);
            int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
            if (serversock < 0)
            {
                std::cout << "获取链接失败！" << std::endl;
                exit(3);
            }
            // 5.开始通信服务
            uint16_t client_port = ntohs(client_sock.sin_port);
            std::string client_ip = inet_ntoa(client_sock.sin_addr);
            std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;
            // version 2.0：多进程版本——创建子进程给新的连接提供服务，父进程去继续获取新的连接
            pid_t id = fork();
            assert(id != -1);
            if (id == 0)
            {
                // child 并且注意僵尸状态
                // child会继承父进程打开的文件及其fd，子进程不需要进行监听的套接字，关闭
                close(listensock_);
                //子进程只需要给连接客户端提供服务的套接字
                service(serversock, client_ip, client_port);
                exit(0);
            } 
            close(serversock);
        }
    }

    ~TcpServer()
    {
        close(listensock_);
    }

private:
    int listensock_;
    std::string ip_;
    uint16_t port_;
};

结果：

这种方法可以解决问题。

当然，我们还有如下的多进程版本：

​
#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cassert>
#include <signal.h>

static int gmv = 20;

static void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
    char buffer[1024];
    while (true)
    {
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s < 0)
        {
            std::cout << "接收信息失败！" << std::endl;
            break;
        }
        else if (s > 0)
        {
            buffer[s] = 0;
            std::cout << clientip << ":" << clientport << std::endl;
        }
        else
        {
            std::cout << "客户端关闭！" << std::endl;
            break;
        }
        write(sock, buffer, strlen(buffer));
    }
}

class TcpServer
{
public:
    TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
    {
    }

    void initTcpServer()
    {
        // 1.创建套接字
        listensock_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock_ < 0)
        {
            std::cout << "创建套接字失败！" << std::endl;
            exit(0);
        }

        // 2.进行绑定
        struct sockaddr_in src_server;
        bzero(&src_server, sizeof(src_server));
        src_server.sin_family = AF_INET;
        src_server.sin_port = htons(port_);
        inet_pton(AF_INET, ip_.c_str(), &src_server);
        socklen_t len = sizeof(src_server);
        if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
        {
            std::cout << "绑定失败！" << std::endl;
            exit(1);
        }

        // 3.开始监听,等待连接
        if (listen(listensock_, gmv) < 0)
        {
            std::cout << "监听失败！" << std::endl;
            exit(2);
        }

        std::cout << "服务器初始化成功！" << std::endl;
    }

    void start()
    {
        while (true)
        {
            // 4.获取链接
            struct sockaddr_in client_sock;
            socklen_t len = sizeof(client_sock);
            int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
            if (serversock < 0)
            {
                std::cout << "获取链接失败！" << std::endl;
                exit(3);
            }
            // 5.开始通信服务
            uint16_t client_port = ntohs(client_sock.sin_port);
            std::string client_ip = inet_ntoa(client_sock.sin_addr);
            std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;

            // version 2.1:多进程版
            pid_t pid = fork();
            if (pid == 0)
            {
                // 子进程
                if (fork() > 0)
                    exit(0);
                // 孙子进程
                close(listensock_);
                service(serversock, client_ip, client_port);
            }
             // 父进程
            waitpid(pid, nullptr, 0);
            close(serversock);
        }
    }

    ~TcpServer()
    {
        close(listensock_);
    }

private:
    int listensock_;
    std::string ip_;
    uint16_t port_;
};

我们让子进程创建完孙子进程后立刻退出，此时服务进程（父进程）调用wait/waitpid函数等待子进程就能立刻等待成功，此后服务进程就能继续调用accept函数获取其他客户端的连接请求。

而由于子进程退出，孙子进程就变成孤儿进程，被os领养，最后由os自动回收。 

结果：

多线程版本：我们还可以创建新的线程去对客户端进行服务，让主线程继续获取连接：

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cassert>
#include <signal.h>

static int gmv = 20;

static void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
    char buffer[1024];
    while (true)
    {
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s < 0)
        {
            std::cout << "接收信息失败！" << std::endl;
            break;
        }
        else if (s > 0)
        {
            buffer[s] = 0;
            std::cout << clientip << ":" << clientport << std::endl;
        }
        else
        {
            std::cout << "客户端关闭！" << std::endl;
            break;
        }
        write(sock, buffer, strlen(buffer));
    }
}

class threaddata
{
public:
    int sock_;
    std::string ip_;
    uint16_t port_;
};

class TcpServer
{
public:
    static void *threadRountine(void *arg)
    {
        pthread_detach(pthread_self());
        threaddata *td = static_cast<threaddata *>(arg);
        service(td->sock_, td->ip_, td->port_);
        delete td;
    }

    TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
    {
    }

    void initTcpServer()
    {
        // 1.创建套接字
        listensock_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock_ < 0)
        {
            std::cout << "创建套接字失败！" << std::endl;
            exit(0);
        }

        // 2.进行绑定
        struct sockaddr_in src_server;
        bzero(&src_server, sizeof(src_server));
        src_server.sin_family = AF_INET;
        src_server.sin_port = htons(port_);
        inet_pton(AF_INET, ip_.c_str(), &src_server);
        socklen_t len = sizeof(src_server);
        if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
        {
            std::cout << "绑定失败！" << std::endl;
            exit(1);
        }

        // 3.开始监听,等待连接
        if (listen(listensock_, gmv) < 0)
        {
            std::cout << "监听失败！" << std::endl;
            exit(2);
        }

        std::cout << "服务器初始化成功！" << std::endl;
    }

    void start()
    {
        while (true)
        {
            // 4.获取链接
            struct sockaddr_in client_sock;
            socklen_t len = sizeof(client_sock);
            int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
            if (serversock < 0)
            {
                std::cout << "获取链接失败！" << std::endl;
                exit(3);
            }
            // 5.开始通信服务
            uint16_t client_port = ntohs(client_sock.sin_port);
            std::string client_ip = inet_ntoa(client_sock.sin_addr);
            std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;

            // version 3——多线程版本
            pthread_t tid;
            threaddata *td = new threaddata();
            td->sock_ = serversock;
            td->ip_ = client_ip;
            td->port_ = client_port;
            pthread_create(&tid, nullptr, threadRountine, td);
        }
    }

    ~TcpServer()
    {
        close(listensock_);
    }

private:
    int listensock_;
    std::string ip_;
    uint16_t port_;
};

 

四、完整代码

tcp_server.hpp

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cassert>
#include <signal.h>

static int gmv = 20;

static void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
    char buffer[1024];
    while (true)
    {
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s < 0)
        {
            std::cout << "接收信息失败！" << std::endl;
            break;
        }
        else if (s > 0)
        {
            buffer[s] = 0;
            std::cout << clientip << ":" << clientport << std::endl;
        }
        else
        {
            std::cout << "客户端关闭！" << std::endl;
        }
        write(sock, buffer, strlen(buffer));
    }
}

class threaddata
{
public:
    int sock_;
    std::string ip_;
    uint16_t port_;
};

class TcpServer
{
public:
    static void *threadRountine(void *arg)
    {
        pthread_detach(pthread_self());
        threaddata *td = static_cast<threaddata *>(arg);
        service(td->sock_, td->ip_, td->port_);
        delete td;
    }

    TcpServer(const uint16_t port, const std::string &ip = "") : listensock_(-1), ip_(ip), port_(port)
    {
    }

    void initTcpServer()
    {
        // 1.创建套接字
        listensock_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock_ < 0)
        {
            std::cout << "创建套接字失败！" << std::endl;
            exit(0);
        }

        // 2.进行绑定
        struct sockaddr_in src_server;
        bzero(&src_server, sizeof(src_server));
        src_server.sin_family = AF_INET;
        src_server.sin_port = htons(port_);
        inet_pton(AF_INET, ip_.c_str(), &src_server);
        socklen_t len = sizeof(src_server);
        if (bind(listensock_, (struct sockaddr *)&src_server, len) < 0)
        {
            std::cout << "绑定失败！" << std::endl;
            exit(1);
        }

        // 3.开始监听,等待连接
        if (listen(listensock_, gmv) < 0)
        {
            std::cout << "监听失败！" << std::endl;
            exit(2);
        }

        std::cout << "服务器初始化成功！" << std::endl;
    }

    void start()
    {
        signal(SIGCHLD, SIG_IGN);
        while (true)
        {
            // 4.获取链接
            struct sockaddr_in client_sock;
            socklen_t len = sizeof(client_sock);
            int serversock = accept(listensock_, (struct sockaddr *)&client_sock, &len);
            if (serversock < 0)
            {
                std::cout << "获取链接失败！" << std::endl;
                exit(3);
            }
            // 5.开始通信服务
            uint16_t client_port = ntohs(client_sock.sin_port);
            std::string client_ip = inet_ntoa(client_sock.sin_addr);
            std::cout << "[" << client_port << "-" << client_ip << "]" << std::endl;

            // version 1：单进程版服务————服务器一次只能处理一个客户端，只有处理完一个，才能处理下一个
            // service(serversock, client_ip, client_port);

            // version 2.0：多进程版本——创建子进程给新的连接提供服务，父进程去继续获取新的连接
            /* pid_t id = fork();
            assert(id != -1);
            if (id == 0)
            {
                // child 并且注意僵尸状态
                // child会继承父进程打开的文件及其fd，子进程不需要进行监听的套接字，关闭
                close(listensock_);
                //子进程只需要给连接客户端提供服务的套接字
                service(serversock, client_ip, client_port);
                exit(0);
            } */

            /* // version 2.1:多进程版
            pid_t pid = fork();
            if (pid == 0)
            {
                // 子进程
                if (fork() > 0)
                    exit(0);
                // 孙子进程
                close(listensock_);
                service(serversock, client_ip, client_port);
            }
            // 父进程
            waitpid(pid, nullptr, 0); */

            // version 3——多线程版本
            pthread_t tid;
            threaddata *td = new threaddata();
            td->sock_ = serversock;
            td->ip_ = client_ip;
            td->port_ = client_port;
            pthread_create(&tid, nullptr, threadRountine, td);

            close(serversock);
        }
    }

    ~TcpServer()
    {
        close(listensock_);
    }

private:
    int listensock_;
    std::string ip_;
    uint16_t port_;
};

tcp_server.cc

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

static void usage(std::string proc)
{
    std::cout << "\n"
              << proc << " port"
              << std::endl;
}

// ./tcpserver 8080
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        usage(argv[0]);
        exit(0);
    }
    uint16_t server_port=atoi(argv[1]);
    std::unique_ptr<TcpServer> sev(new TcpServer(server_port));
    sev->initTcpServer();
    sev->start();

    return 0;
}

tcp_client.cc 

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

static void usage(std::string proc)
{
    std::cout << "\n"
              << proc << " port"
              << std::endl;
}

// ./tcpclient IP port
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    std::string server_ip = argv[1];
    uint16_t server_port = atoi(argv[2]);

    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0)
    {
        std::cout << "创建套接字失败！" << std::endl;
        exit(0);
    }

    struct sockaddr_in server;
    memset(&server, 0, sizeof server);
    server.sin_family = AF_INET;
    server.sin_port = htons(server_port);
    server.sin_addr.s_addr = inet_addr(server_ip.c_str());
    if (connect(sock, (struct sockaddr *)&server, sizeof server) < 0)
    {
        std::cout << "连接失败！" << std::endl;
        exit(0);
    }

    // 开始通信
    while (true)
    {
        std::string line;
        std::cout << "请输入# ";
        std::getline(std::cin, line);
        ssize_t s = write(sock, line.c_str(), line.size());

        char buffer[1024];
        ssize_t m = read(sock, buffer, sizeof buffer - 1);
        buffer[m] = 0;
        std::cout << "服务器：" << buffer << std::endl;
    }

    return 0;
}

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

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

相关文章

JMM与内存屏障

JMM与内存屏障

一、cpu多核并发缓存架构解析 JMM内存模型&#xff1a;java多线程内存模型跟cpu缓存模型类似&#xff0c;是基于cpu缓存模型来建立的&#xff0c;java线程内存模型是标准化的&#xff0c;屏蔽掉了底层不同计算机的区别 JMM数据原子操作 read(读取)&#xff1a;从主内存读取数据…
阅读更多...
作为Boss，还在写代码。what？赶紧改掉这个坏毛病

作为Boss，还在写代码。what？赶紧改掉这个坏毛病

有些创业中的老板&#xff0c;经常或者偶尔也要写代码&#xff0c;我听了很震惊呀&#xff0c;这叫创业吗&#xff1f;这不是给员工打工吗&#xff1f;其他重要的事情谁来干&#xff0c;这个毛病一定要改。 一、比起写代码&#xff0c;你还有更重要的事情要做 作为BOSS和创业…
阅读更多...
【Node.js从基础到高级运用】二十五、Node.js中Cluster的作用

【Node.js从基础到高级运用】二十五、Node.js中Cluster的作用

引言 Node.js中的cluster模块允许您轻松创建共享服务器端口的子进程。这是一个核心模块&#xff0c;用于在Node.js应用程序中实现多进程架构&#xff0c;以充分利用多核CPU系统的计算能力。 cluster介绍 当您启动一个Node.js应用程序时&#xff0c;默认情况下它运行在单个进程…
阅读更多...
怎么设置启用远程桌面? 如何让外网电脑远程本地内网?

怎么设置启用远程桌面? 如何让外网电脑远程本地内网?

如何远程控制电脑&#xff1f;最简单实用的方案是开启电脑系统自带的远程桌面功能&#xff0c;如果涉及跨网、内外网互通&#xff0c;可以同时用快解析内网映射外网。下面是方案的具体实施步骤&#xff0c;供大家参考。 怎么打开设置启用远程桌面&#xff1f; 1.在目标需要远…
阅读更多...
idea 中导入的项目maven不自动下载依赖包

idea 中导入的项目maven不自动下载依赖包

导入之后不会自动引入依赖包&#xff0c;如下图&#xff0c;external libraries 下没有依赖 解决方案&#xff1a;重新更新下maven的Local repository 即可
阅读更多...
实测52.4MB/s！全志T3+FPGA的CSI通信案例分享！

实测52.4MB/s！全志T3+FPGA的CSI通信案例分享！

CSI总线介绍与优势 CSI&#xff08;CMOS sensor parallel interfaces&#xff09;总线是一种用于连接图像传感器和处理器的并行通信接口&#xff0c;应用于工业自动化、能源电力、智慧医疗等领域&#xff0c;CSI总线接口示意图如下所示&#xff08;以全志科技T3处理器的CSI0为…
阅读更多...
Qt实现Mysql数据库的连接，查询，修改，删除，增加功能

Qt实现Mysql数据库的连接，查询，修改，删除，增加功能

Qt实现Mysql数据库的连接&#xff0c;查询&#xff0c;修改&#xff0c;删除&#xff0c;增加功能 安装Mysql数据库&#xff0c;QtCreator Mysql选择Mysql Server 8.1版本安装。 Mysql Server 8.1安装过程 1.首先添加网络服务权限&#xff1a; WinR键输入compmgmt.msc进入…
阅读更多...
密码学 | 数字签名 + 数字证书

密码学 | 数字签名 + 数字证书

&#x1f951;原文&#xff1a;数字签名和数字证书的原理解读 - 知乎 &#x1f951;声明&#xff1a;后文图中若未明确指明&#xff0c;默认是 Bob 的公钥或私钥。 Step1&#xff1a;Bob 有两把钥匙&#xff0c;一把是公钥&#xff0c;另一把是私钥。 Step2&#xff1a;Bob 把…
阅读更多...
安全狗云眼的主要功能有哪些？

安全狗云眼的主要功能有哪些？

"安全狗云眼"是一款综合性的网络安全产品&#xff0c;主要用于实时监控和保护企业的网络安全。其核心功能包括威胁检测、漏洞扫描、日志管理和合规性检查等。 以下是安全狗云眼的主要功能详细介绍&#xff1a; 1、资产管理 定期获取并记录主机上的Web站点、Web容器、…
阅读更多...
达梦数据库——异常崩溃(core)分析处理

达梦数据库——异常崩溃(core)分析处理

CORE文件介绍 core文件是在程序异常崩溃时生成的文件&#xff0c;它包含了程序在崩溃瞬间的内存状态信息&#xff0c;主要是用来调试和分析问题。我们可以使用调试器工具&#xff08;如GDB&#xff09;来分析core文件&#xff0c;以便定位和解决问题。 CORE文件的配置 开启cor…
阅读更多...
ActiveMQ主从架构和集群架构的介绍及搭建

ActiveMQ主从架构和集群架构的介绍及搭建

目录 一、主从和集群架构的特点 1.1 主从架构的-Master/slave模式特点 1.2 集群架构-Cluster模式特点 二、ActiveMQ的主从架构 2.1 架构图 2.2 特点 2.3 实现方式&#xff08;3种&#xff09; 2.4 实现 &#xff08;基于LevelDB复制&#xff09; 2.4.1 准备环境 2.4.2…
阅读更多...
2024化工制造企业数字化白皮书

2024化工制造企业数字化白皮书

来源&#xff1a;蓝凌研究院 中国石油和化学工业联合会发布2023年中国石油和化工行业经济运行情况。数据显示&#xff0c;2023年&#xff0c;我国石化行业实现营业收入15.95万亿元&#xff0c; 同比下降1.1%&#xff0c;利润总额8733.6亿元&#xff0c;行业经济运行总体呈现低…
阅读更多...
vscode搭建C/C++环境

vscode搭建C/C++环境

文章目录 一、安装vscode 二、下载安装g 三、安装VSCode插件 四、配置运行环境 一、安装vscode 直接官网免费下载&#xff1a;下载完成后进行安装&#xff0c;记得更换安装路径Visual Studio Code - Code Editing. RedefinedVisual Studio Code is a code editor redefine…
阅读更多...
大数据------额外插件及技术------Git（完整知识点汇总）

大数据------额外插件及技术------Git（完整知识点汇总）

Git 定义 它是分布式版本控制工具&#xff0c;主要用于管理开发过程中的源代码文件&#xff08;如&#xff1a;Java类、xml文件、html页面等&#xff09;&#xff0c;在软件开发过程中被广泛应用 作用 代码回溯&#xff1a;快速回到某一代码历史版本版本切换&#xff1a;同一个…
阅读更多...
Python文件处理--进阶

Python文件处理--进阶

Python标准库文件操作相关模块&#xff1a; 1.使用pickle序列化 序列化指的是&#xff1a;将对象转化成“串行化”数据形式&#xff0c;存储到硬盘或通过网络传输到其他地方。反序列化是指相反的过程&#xff0c;将读取到的“串行化数据”转化成对象。我们可以使用pickle模块…
阅读更多...
算法部署 | 使用TensorRT部署AlphaPose姿态估计算法

算法部署 | 使用TensorRT部署AlphaPose姿态估计算法

项目应用场景 面向 AlphaPose 姿态估计算法的推理加速场景&#xff0c;项目采用 TensorRT 进行 GPU 算法加速推理。 项目效果 项目细节 > 具体参见项目 README.md (1) 模型转换 python pytorch2onnx.py --cfg ./configs/coco/resnet/256x192_res50_lr1e-3_1x.yaml --chec…
阅读更多...
基于Springboot的简历系统

基于Springboot的简历系统

基于SpringbootVue的简历系统的设计与实现 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringbootMybatis工具&#xff1a;IDEA、Maven、Navicat 系统展示 用户登录 首页 简历模板 招聘会 求职论坛 系统公告 后台登录 后台首页 用户管理 简历模板 模板…
阅读更多...
面试八股——JVM★

面试八股——JVM★

类加载 类加载器的定义 类加载器的类别 类装载的执行过程 类的装载过程&#xff1a; 加载&#xff1a; 验证&#xff1a; 准备&#xff1a; 这里设置初始值并不是传统意义的设置初始值&#xff08;那个过程在初始化阶段&#xff09;。 解析&#xff1a; 初始化&#xff1a; …
阅读更多...
YOLOv8改进 | Conv篇 | CVPR2024最新DynamicConv替换下采样（包含C2f创新改进，解决低FLOPs陷阱）

YOLOv8改进 | Conv篇 | CVPR2024最新DynamicConv替换下采样（包含C2f创新改进，解决低FLOPs陷阱）

一、本文介绍 本文给大家带来的改进机制是CVPR2024的最新改进机制DynamicConv其是CVPR2024的最新改进机制&#xff0c;这个论文中介绍了一个名为ParameterNet的新型设计原则&#xff0c;它旨在在大规模视觉预训练模型中增加参数数量&#xff0c;同时尽量不增加浮点运算&#x…
阅读更多...
servlet的三个重要的类（httpServlet 、httpServletRequst、 httpServletResponse）

servlet的三个重要的类（httpServlet 、httpServletRequst、 httpServletResponse）

一、httpServlet 写一个servlet代码一般都是要继承httpServlet 这个类&#xff0c;然后重写里面的方法 但是它有一个特点&#xff0c;根据之前写的代码&#xff0c;我们发现好像没有写main方法也能正常执行。 原因是&#xff1a;这个代码不是直接运行的&#xff0c;而是放到…
阅读更多...
最新文章

Copyright @ 2022~2023