简易TCP服务器通信、IO多路复用（select、poll、epoll）以及reactor模式。

news2024/11/27 14:50:23

网络编程学习

  • 简单TCP服务器通信
    • TCP三次握手和四次挥手
      • 三次握手（如下图）
        • 常见问题？
      • 四次挥手
    • client和server通信写法
      • server端
      • client端
    • 通信双方建立连接到断开连接的状态转换
    • 怎么应对多用户连接？
      • 缺点
  • IO多路复用
    • select
      • 优缺点
    • poll
      • poll写法和改进点
    • epoll（使用最多，重中之重）
      • epoll写法和改进点
      • LT模式和ET模式
        • **LT模式**
        • **ET模式**：
        • LT模式如何解决数据保存问题？
  • reactor模式
    • 针对IO处理的两种写法
  • 思考题
    • main函数如何被执行的？
    • time_wait怎么产生的？如果有大量的time_wait是为什么？
    • close_wait怎么产生的？如果有大量的close_wait是为什么？
    • epoll里是否使用了mmap？
    • epoll是否是线程安全的？

简单TCP服务器通信

TCP三次握手和四次挥手

三次握手（如下图）

  1. 首先由通信双方的某一方（后面就用client了，其实server和client都是可以的）发起连接请求，即发送一个带SYN标志位的TCP数据包给server端。
  2. server端收到数据包后，除了SYN位以外，还会增加一个ACK确认位，然后发送给clinet端。
  3. client端收到数据包后，给server端回复一个带ACK确认位的数据包给服务端，到此，通信双方就算建立连接了。
常见问题？
  • 为什么是三次握手而不是两次？
    • 因为TCP连接是安全可靠的，三次握手的话会保证双方都能接受到对方的数据，第一次服务端收到客户端消息后可以确定客户端发送数据没问题，然后第二次服务端发送给客户端消息，客户端可以确定服务端的收发都没有问题，但是服务端不知道客户端接收是否成功，所以，客户端还需要发一个数据包告诉服务端，它的接收也没有问题，因此，这里是三次连接而不是两次。

四次挥手

  1. 第一次挥手，是主动断开连接的一方，发送带有FIN和ACK标志位的TCP包。
  2. 第二次是被动断开连接一方在收到数据包后，立马回应一个ACK标志位的TCP包，告诉对方我收到了对方的包，但是数据还没有处理完成,还有些工作要处理。
  3. 第三次依然是被动断开连接一方在数据处理完成之后，会给对方发送FIN和ACK标志位的TCP包，告诉对方我数据处理完了，你可以关闭连接了。
  4. 第四次挥手，是主动断开方发送ACK标志位的TCP包，然后被动断开方就关闭连接了。

client和server通信写法

server端

  • 服务端编码步骤：
    1. 调用socket函数，获取一个sockfd（本质上是一个文件描述符,受到系统能打开文件数量上限限制）,int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    2. 调用bind函数,将sockfd和ip、端口号绑定
      1. 创建一个sockaddr_in结构体变量，通过改结构体设置服务器的IP地址和端口号（这里要调用htonl和htons转换字节序）。
      2. 调用bind函数，绑定sockfd和ip、端口号；bind(sockfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr))
    3. 调用listen函数去监听sockfd上的请求。listen(sockfd, 8)
    4. 调用accept函数（默认为堵塞）去接收客户端请求。
      1. 创建两个变量，一个是sockaddr_in结构体变量，存储用来通信的客户端信息，一个是len代表结构体变量的大小。
      2. 调用accept函数，函数返回一个fd（可以用来读写数据的fd），int clientfd = accept(sockfd, (struct sockaddr*)&client_addr, &len);
    5. 第五步就是一个while循环，然后循环里调用recv和send函数去读写数据。
  • 整体代码如下：
       int sockfd = socket(AF_INET, SOCK_STREAM, 0);
   struct sockaddr_in server_addr;
   memset(&server_addr, 0, sizeof(struct sockaddr_in));//赋值为空
   server_addr.sin_family = AF_INET;//IPV4协议
   server_addr.sin_addr.s_addr = htonl(INADDR_ANY);//本地地址，如果有多个IP不知道设置为哪个就可以用这个参数。
   server_addr.sin_port = htons(2204);
   if (-1 == bind(sockfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr))) {
       perror("bind error");
       return -1;
   }
   if (-1 == listen(sockfd, 8)) {
       perror("listen error");
       return -1;
   }
   //accept
   struct sockaddr_in client_addr;
   int len = sizeof(struct sockaddr);
   //clientfd用于收发数据的
   int clientfd = accept(sockfd, (struct sockaddr*)&client_addr, &len);
   printf("clientfd: %d, serverfd: %d\n", clientfd, sockfd);
   while (1) {
       //receive
       char buf[128] = {0};
       int recv_len = recv(clientfd, buf, 128, 0);
       printf("accept len: %d", recv_len);
       if (recv_len == -1){
           perror("recv error");
           break;
       } else if (recv_len == 0) {
           break;
       } else {
           printf("recv success\n");
       }
       //send
       printf("send");
       send(clientfd, buf, recv_len, 0);
       printf("send success");
   }

client端

client写法步骤：
1. 调用socket函数，获取一个sockfd（本质上是一个文件描述符）,int sockfd = socket(AF_INET, SOCK_STREAM, 0);
2. 调用connect函数建立连接（这一步完成三次握手）
1. 创建一个sockaddr_in结构体变量，通过改结构体设置服务器的IP地址和端口号（这里要调用htonl和htons转换字节序）。
2. 调用connect函数，如果成功返回那么就可以直接用sockfd进行通信了。
3. 使用sockfd进行数据读写。

  • 整体代码如下：
    uint32_t lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd == -1) {
        perror("create socket");
        exit(-1);
    }
    //connect 172.17.71.122
    uint32_t dst = 0;
    inet_pton(AF_INET, "8.141.4.79", &dst);
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;//IPV4协议
    server_addr.sin_addr.s_addr = dst;
    server_addr.sin_port = htons(2204);
    if (connect(lfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("connect");
        exit(-1);
    }
    while (1) {
        for (int i = 0; i < 20; ++i) {
            const char* str = std::to_string(i).c_str();
            int write_fd = write(lfd, str, sizeof(str));
            char receive[1024] = "";
            int len1 = read(lfd, receive, sizeof(receive));
            if (len1 < 0) {
                perror("client read");
                exit(-1);
            } else if (len1 == 0) {
                printf("server closed!!!");
                break;
            } else {
                printf(" client read success: %s\n", receive);
            } 
            sleep(1);
        }
        sleep(2);
    }

通信双方建立连接到断开连接的状态转换

在这里插入图片描述

  • 建立连接：
    • 服务端：
      1. 初始状态为closed状态，调用listen函数后进入LISTEN状态。
      2. 收到SYN标志位的TCP包，并向对方发送SYN和ACK标志位的TCP包后，变为SYN_RCVD状态。
      3. 收到对方带ACK标志位的包后变为ESTABLISTED状态，至此连接建立。（这里不是accept去完成三次握手的，三次握手由TCP协议栈完成，accept只是堵塞获取客户端信息的）。
    • 客户端：
      1. 初始状态为closed状态，调用connect函数，发送SYN标志位的TCP包后进入SYN_SENT状态。
      2. 由TCP协议栈完成后续的握手环节，当connect函数成功返回后，直接进入ESTABLISTED状态。
  • 断开连接：断开连接一般情况下可以是任意一方发起，这里以客户端主动断开为例
    • 服务端：
      1. 当客户端主动断开连接后，服务端收到FIN位的TCP包，此时服务端的协议栈会立刻发送给对方一个ACK确认位，此时服务端酒进入了CLOSED_WAIT状态。
      2. 此时recv函数会继续去处理数据，当读到数据长度为0，并且数据全部处理完后，服务端主动调用close函数关闭通信fd，这时服务端会给客户端发送FIN标志位的TCP包，然后服务端进入LAST_ACK状态。
      3. 当服务端收到客户端的ACK标志位的包后，服务端由LAST_ACK转变为CLOSED状态。
    • 客户端：
      1. 客户端主动调用closed函数关闭fd，那么TCP协议栈会给服务端发送一个带SYN标志位的TCP包，此后客户端进入FIN_WAIT1状态。
      2. 当收到服务端带ACK标志位的TCP包后，由FIN_WAIT1转变为FIN_WAIT2状态。
      3. 当收到服务端带FIN标志位的TCP包，并向服务端发送ACK标志位的TCP包后就进入了TIME_WAIT状态，该状态会持续2MSL，（MSL为网络包在网络中的最大存活时间。），当2MSL到达后，转换为CLOSED状态。
  • 注意：
    • TCP的状态转换是由TCP协议栈管理的，不是由代码管理。

怎么应对多用户连接？

  • 上面的简单通信过程只能一次处理一个用户，我们如果想要处理多用户连接可以采用多线程的方式。
  • 方法也比较简单，就是将IO操作以及业务处理逻辑放到一个函数里，然后accept只要返回了，那么就创建一个线程去执行回调函数。

缺点

  1. 当并发量特别大的时候，服务器会受到内存的影响，性能并不高，无法适应高并发场景。
  2. 为此，我们需要学习下面的IO多路复用，采用一个线程去处理多个请求。

IO多路复用

  • 简单来讲就是可以用一个线程去同时监听多个请求，并一起返回，同时处理，减少线程资源消耗。

select

  • select相当于一个代理，去帮我们检测有哪些fd有事件发生，然后返回给我们一个数组，我们需要遍历数组依次处理每个fd。

  • 实现步骤如下：

    1. 定义一个fd_set变量和maxfd变量。
      1. fd_set变量是一个结构体变量，内部存储了一个fd数组，然后我们调用FD_SET函数将sockfd添加到fd_set里。
      2. maxfd变量存储当前的最大fd值，初始值为sockfd，后续会及时更新。
    2. 调用select函数去监听事件。int ret_code = select(maxfd + 1, &r_set, NULL, NULL, NULL); 这里maxfd+1的目的是为了能够处理maxfd，因为select的实现比较老了。
    3. select函数返回后，我们需要写一个状态机，去判断是sockfd还是其他fd也有。两种不同的fd，会有不同的IO操作。

  • 代码如下：

    fd_set rf_set, r_set;
FD_ZERO(&rf_set);//清空集合
FD_SET(sockfd, &rf_set);//增加sockfd到集合

int maxfd = sockfd;//设置最大fd
while (1) {
    r_set = rf_set;
    int ret_code = select(maxfd + 1, &r_set, NULL, NULL, NULL);

    if (FD_ISSET(sockfd, &r_set)) {
        //accept
        struct sockaddr_in client_addr;
        int len = sizeof(struct sockaddr);
        int client_fd = accept(sockfd, (struct sockaddr*)&client_addr, &len);
        FD_SET(client_fd, &rf_set);//增加新的fd到fd_set里
        maxfd = maxfd > client_fd ? maxfd : client_fd;//更新maxfd
    } else {
        for (int i = sockfd + 1; i < maxfd + 1; ++i) {
            if (FD_ISSET(i, &r_set)) {
                //receive
                char buf[128] = {0};
                int recv_len = recv(i, buf, 128, 0);
                printf("accept len: %d", recv_len);
                if (recv_len == -1){
                    perror("recv error");
                    break;
                } else if (recv_len == 0) {
                    FD_CLR(i, &rf_set);
                    close(i);//记得close，不然会一直在close_wait状态。
                    break;
                } else {
                    printf("recv success\n");
                }
                //send
                printf("send");
                send(i, buf, recv_len, 0);
                printf("send success");
            }
        }
    }
}

优缺点

  • 优点：相较于多线程实现法，进行了极大的优化，减少线程资源消耗。
  • 缺点：
    1. 函数参数太多了，一共有五个参数，中间三个参数分别为r_set、w_set、e_set分别对应不同的事件。
    2. 使用select会频繁的进行内存拷贝，每当处理完数据就会将fd_set拷贝到内核态，而每次有事件发生都会将fd_set拷贝到用户态，频繁拷贝，浪费很多资源，性能很低。
    3. select能够处理的最大连接数为1024个。

poll

poll写法和改进点

  • 改进点：

    1. 优化了函数参数，将中间三个参数变为一个，增加了一个结构体，用来存储监听哪些事件（读写）、是否监听以及fd。用户定义一个数组，作为传出参数，传给poll函数，等函数返回后，用户需要遍历数组，对于数组每个元素，如果revents被改变，那么就是发生的对应的事件，用户可以进行相应的操作。
    2. 因为用户可以自定义数组大小，所以poll解决了select只能监听1024个文件描述符的问题。

  • 缺点：

    • 底层的内核监听过程和select类似，也需要把数组从用户态拷贝到内核态，只是把修改fdset换成了每个数组元素中revents的值，其他相差不大。

  • 写法代码如下：

    // struct pollfd {
//     int fd;			/* File descriptor to poll.  */
//     short int events;		/* Types of events poller cares about.  */
//     short int revents;		/* Types of events that actually occurred.  */
// };
struct pollfd fds[1024];
fds[sockfd].fd = sockfd;
fds[sockfd].events = POLLIN;
int maxfd = sockfd;
while (1) {
    int ret_code = poll(fds, maxfd + 1, -1);

    if (fds[sockfd].revents & POLLIN) {
        struct sockaddr_in client_addr;
        int len = sizeof(struct sockaddr);
        int client_fd = accept(sockfd, (struct sockaddr*)&client_addr, &len);
        fds[client_fd].fd = client_fd;
        fds[client_fd].events = POLLIN;
        maxfd = maxfd > client_fd ? maxfd : client_fd;
    } 
    for (int i = sockfd + 1; i < maxfd + 1; ++i) {
        if (fds[i].revents & POLLIN) {
            //receive
            char buf[128] = {0};
            int recv_len = recv(i, buf, 128, 0);
            printf("accept len: %d", recv_len);
            if (recv_len == -1){
                perror("recv error");
                break;
            } else if (recv_len == 0) {
                fds[i].events = 0;
                fds[i].fd = -1;
                close(i);
                break;
            } else {
                printf("recv success\n");
            }
            //send
            printf("send");
            send(i, buf, recv_len, 0);
            printf("send success");
        }
    }
}

epoll（使用最多，重中之重）

epoll写法和改进点

  • 改进点：

    1. epoll是在内核中申请一块缓存，存放一个节点，里面包含一个红黑树和双向链表，采用红黑树存储要监听的fd，然后将监听到的fd存储到一个双向链表里，这样加大了内核的查询效率，以及用户拿到的是被触发的结果集，不需要再去遍历所有的fd了，也就是不需要用户自己维护maxfd了。
    2. 虽然epoll也定义了一个数组，但是epoll的写法采用的共享内存的方式，而select和poll是单纯的拷贝。

  • 缺点：

    • 当服务遇到大量的短连接时，就会频繁的调用epoll_ctl系统调用，消耗系统资源。

  • 写法步骤：

    1. 调用epoll_create系统调用会在内核为该进程创建一个句柄，其中包含红黑树根节点和一个双向链表分别存储需要监听的节点和准备就绪的fd。
    2. 调用epoll_ctl系统调用，向红黑树节点中添加、删除、修改想要操作的fd，起初肯定是sockfd，并且注册一个回调函数，告诉内核如果有准备就绪的节点就添加到双向链表中。
    3. 调用epoll_wait系统调用，由内核去检测双向链表是否为空，如果为空，就sleep，直到链表里有数据时，epoll_wait被唤醒，将数据返回给用户，当然用户也可以自己设置超时时间，在该时间到达后，即使没有数据也会返回告知用户。

  • 代码如下：

    /*struct epoll_event {
        uint32_t events;	
        epoll_data_t data;	
    } __EPOLL_PACKED;
    */
    int epoll_fd = epoll_create(1);//这里只要大于0就可以，内部实现改为链表了。

    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = sockfd;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &ev);

    struct epoll_event epoll_events[1024] = {};

    while (1) {
        int ret_code = epoll_wait(epoll_fd, epoll_events, 1024, -1);

        for (int i = 0; i < ret_code; ++i) {
            int connt_fd = epoll_events[i].data.fd;
            if (connt_fd == sockfd) {
                struct sockaddr_in client_addr;
                int len = sizeof(struct sockaddr);
                int client_fd = accept(sockfd, (struct sockaddr*)&client_addr, &len);
                ev.events = EPOLLIN;
                ev.data.fd = client_fd;
                epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
                printf("clientfd: %d\n", client_fd);
            } else if (epoll_events[i].events & EPOLLIN){
                //receive
                char buf[10] = {0};
                int recv_len = recv(connt_fd, buf, 10, 0);
                printf("accept len: %d", recv_len);
                if (recv_len == -1){
                    perror("recv error");
                    close(connt_fd);
                    continue;
                } else if (recv_len == 0) {
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, epoll_events[i].data.fd, NULL);
                    close(i);
                    continue;
                } else {
                    printf("recv success\n");
                }
                //send
                printf("send");
                send(connt_fd, buf, recv_len, 0);
                printf("send success");
            }
        }
    }

LT模式和ET模式

LT模式
  • 是什么？
    • 我们在处理数据的时候，会有一个存储数据的buffer数组，如果buffer数组的长度小于要读取的数据长度，那么recv函数只会读取buffer长度的数据，然后等下次epoll_wait返回后，再继续读取数据，但是上次的数据需要保存，不然就丢失了。
  • 应用场景：
    • 可以采用LT模式解决粘包问题，先读取数据的长度，然后循环把数据全部读取出来。
ET模式：
  • 是什么？
    • 内核针对每一个fd只返回一次(也就是说针对每次事件，epoll_wait只返回一次)，后续就不再对该fd进行返回，这就使得用户必须一次性读完，否则只能等到下次fd有事件触发的时候才能接着读取上次的数据。
  • 应用场景：
    • 当处理大文件的时候，一次性读取所有数据。因为如果采用LT模式的话，文件太大会针对这个fd频繁调用epoll_wait系统调用。
LT模式如何解决数据保存问题？
  • 直接看代码（定义一个全局变量，存储每个fd对应的buffer，并且记录上次读到的位置idx）：
    struct fd_events    
{
    int fd;
    char r_buffer[128];
    char w_buffer[128];
    int r_idx;
    int w_idx;
    //这里还可以添加事件以及回调函数。
};

//解决LT模式下无法存数据的问题,每次读完后拼接到buffer后，并修改idx到数组末尾
struct fd_events all_events[1024] = {};

reactor模式

针对IO处理的两种写法

  • 针对IO状态机处理
    • 上面的epoll示例就是针对fd去处理的，对sockfd和其他fd分别处理。
  • 针对事件状态机划分
    • 因为epoll_event里的events是有不同的事件的，我们可以针对不同的事件进行状态机判断，然后分别调用不同的回调函数。
    • 代码如下：
         if (epoll_events[i].events & EPOLLIN) {
       //xxx
   } else if (epoll_events[i].events & EPOLLOUT) {
	   //xxx
   } else if (epoll_events[i].events & EPOLLERR) {
	   //xxx
   }
  • reactor模式就是针对不同事件调用不同的回调函数的模式。

思考题

main函数如何被执行的？

  • 程序启动时，操作系统会创建一个进程，并为该进程分配一块内存空间，然后将可执行文件加载到内存中，然后操作系统会进行一些初始化准备工作，之后找到程序执行入口点main函数的地址，将控制权交给main函数的代码逻辑，程序开始执行，程序执行结束后，将控制权返回给操作系统，操作系统根据退出码来判断程序的运行状态。

time_wait怎么产生的？如果有大量的time_wait是为什么？

  • 首先time_wait状态是先断开连接的一方会产生的状态，四次挥手时，当最后一次挥手发送完后，就进入了time_wait状态。
  • 如果有大量的time_wait的原因是什么？
    1. 目前感觉是因为大量的短连接，并且是服务端先主动调用close函数造成的。

close_wait怎么产生的？如果有大量的close_wait是为什么？

  • close_wait是在四次挥手中收到对方的断开连接请求，并且向对方发送ack确认后就进入了close_wait状态，是被断开一方产生的状态。
  • 如果有大量的close_wait是为什么？
    1. 忘记调用close函数，没有去发送finTCP包就会一直处于close_wait状态。
    2. 代码逻辑有问题，可能跳过了close的执行。

epoll里是否使用了mmap？

  • epoll使用的共享内存的方式实现，否则和select、poll一样还是需要进行大量的数据拷贝。

epoll是否是线程安全的？

  • 首先epoll本身是linux下对IO事件进行监听的机制，可以用来处理高并发连接，如果是多进程使用一个epoll_fd实例，那么需要一定的线程同步机制来保证数据一致性。如果是每个线程对应不同的实例，则是线程安全的。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux---命令行参数

Linux---命令行参数

一、命令行参数 在介绍命令行参数前&#xff0c;我想问大家一个问题&#xff0c;在以前写C/C时&#xff0c;main 函数可不可以带参数&#xff1f; 答案是可以带的&#xff0c;int main(int argc, char* argv[]){}&#xff0c;但平时写代码时也证明了&#xff0c;main 函数的参…
阅读更多...
Gradle连接超时问题connect time out

Gradle连接超时问题connect time out

出现这样的问题不要慌张&#xff0c;可能是你配置gradle的问题一步一步来解决就完事了 1. 出现这样的问题首先我们先检查配置 首先我们先看到的标出来的地址可以看到&#xff0c;我们需要下载的是这个链接里面的压缩包数据&#xff0c;查看版本以及这个链接是不是错误的 2. 第…
阅读更多...
[OpenCV学习笔记]Qt+OpenCV实现图像灰度反转、对数变换和伽马变换

[OpenCV学习笔记]Qt+OpenCV实现图像灰度反转、对数变换和伽马变换

目录 1、介绍1.1 灰度反转1.2 图像对数变换1.3 图像伽马变换 2、效果图3、代码实现4、源码展示 1、介绍 1.1 灰度反转 灰度反转是一种线性变换&#xff0c;是将某个范围的灰度值映射到另一个范围内&#xff0c;一般是通过灰度的对调&#xff0c;突出想要查看的灰度区间。 S …
阅读更多...
大创项目推荐 深度学习 opencv python 实现中国交通标志识别_1

大创项目推荐 深度学习 opencv python 实现中国交通标志识别_1

文章目录 0 前言1 yolov5实现中国交通标志检测2.算法原理2.1 算法简介2.2网络架构2.3 关键代码 3 数据集处理3.1 VOC格式介绍3.2 将中国交通标志检测数据集CCTSDB数据转换成VOC数据格式3.3 手动标注数据集 4 模型训练5 实现效果5.1 视频效果 6 最后 0 前言 &#x1f525; 优质…
阅读更多...
Windows下载使用nc(netcat)命令

Windows下载使用nc(netcat)命令

‘nc’ 不是内部或外部命令&#xff0c;也不是可运行的程序&#xff1f; 点击链接地址&#xff0c;下载压缩包。 完成后解压 使用方式&#xff08;三种&#xff09;&#xff1a; 1、直接双击exe使用 2、把这个exe放到cmd启动的默认路径下 放到默认路径下&#xff0c;使用nc&a…
阅读更多...
【Deep Learning 11】Graph Neural Network

【Deep Learning 11】Graph Neural Network

&#x1f31e;欢迎来到图神经网络的世界 &#x1f308;博客主页&#xff1a;卿云阁 &#x1f48c;欢迎关注&#x1f389;点赞&#x1f44d;收藏⭐️留言&#x1f4dd; &#x1f31f;本文由卿云阁原创&#xff01; &#x1f4c6;首发时间&#xff1a;&#x1f339;2024年3月20日…
阅读更多...
openLooKeng开发环境搭建

openLooKeng开发环境搭建

文章目录 搭建OpenLooKeng开发环境要求 以下是搭建OpenLooKeng开发环境的基本步骤&#xff1a;1、从OpenLooKeng的GitHub仓库克隆代码&#xff1a;2、 构建OpenLooKeng生成IntelliJ IDEA项目文件 airbase构建项目过程中出现的问题checkstyle错误版本冲突问题hetu-heuristic-ind…
阅读更多...
辽宁政府采购网怎么入驻？

辽宁政府采购网怎么入驻？

辽宁政府采购网的入驻流程包括以下几个主要步骤&#xff1a; 注册账号&#xff1a;在辽宁政府采购网上商城注册账号。CA证书领取&#xff1a;注册成功后&#xff0c;需要领取CA证书以登录网上商城。搭建自营商城&#xff1a;因为后期需要和辽宁政府采购网上商城进行入驻&#…
阅读更多...
执行 kubeadm join 报错ERROR FileAvailable--etc-kubernetes-kubelet.conf

执行 kubeadm join 报错ERROR FileAvailable--etc-kubernetes-kubelet.conf

执行 kubeadm join 报错ERROR FileAvailable–etc-kubernetes-kubelet.conf [rootk8snode2 ~]# kubeadm join apiserver.demo:6443 --token c4nezq.ecv2kg9ok6gsresw --discovery-token-ca-cert-hash sha256:be1a55bea6b5bb5c8810434d3905a9cd0bbc33181862f7ad601346e1ab0…
阅读更多...
.NET CORE 分布式事务(二) DTM实现TCC

.NET CORE 分布式事务(二) DTM实现TCC

目录 引言&#xff1a; 1. TCC事务模式 2. TCC组成 3. TCC执行流程 3.1 TCC正常执行流程 3.2 TCC失败回滚 4. Confirm/Cancel操作异常 5. TCC 设计原则 5.1 TCC如何做到更好的一致性 5.2 为什么只适合短事务 6. 嵌套的TCC 7. .NET CORE结合DTM实现TCC分布式事务 …
阅读更多...
wireshark创建显示过滤器实验简述

wireshark创建显示过滤器实验简述

伯克利包过滤是一种在计算机网络中进行数据包过滤的技术&#xff0c;通过在内核中插入过滤器程序来实现对网络流量的控制和分析。 在数据包细节面板中创建显示过滤器&#xff0c;显示过滤器可以在wireshark捕获数据之后使用。 实验拓扑图&#xff1a; 实验基础配置&#xff1…
阅读更多...
计算机专业在找工作时的注意事项

计算机专业在找工作时的注意事项

目录 说在前面关于我一些忠告关于简历关于银行写在最后 说在前面 满满的求生欲。我不是什么大佬&#xff0c;更没有能力教大家什么。只是看到有不少学弟学妹&#xff0c;还在为找一份工作焦头烂额&#xff0c;却没有努力的方向。所以这里斗胆给计算机相关专业的学弟学妹们的一…
阅读更多...
【动手学深度学习-pytorch】 9.4 双向循环神经网络

【动手学深度学习-pytorch】 9.4 双向循环神经网络

在序列学习中&#xff0c;我们以往假设的目标是&#xff1a; 在给定观测的情况下 &#xff08;例如&#xff0c;在时间序列的上下文中或在语言模型的上下文中&#xff09;&#xff0c; 对下一个输出进行建模。 虽然这是一个典型情景&#xff0c;但不是唯一的。 还可能发生什么其…
阅读更多...
文件操作（随机读写篇）

文件操作（随机读写篇）

1. 铺垫 建议先看&#xff1a; 文件操作&#xff08;基础知识篇&#xff09;-CSDN博客 文件操作&#xff08;顺序读写篇&#xff09;-CSDN博客 首先要指出的是&#xff0c;本篇文章中的“文件指针”并不是指FILE*类型的指针&#xff0c;而是类似于打字时的光标的东西。 打…
阅读更多...
EMD关于信号的重建，心率提取

EMD关于信号的重建，心率提取

关于EMD的俩个假设&#xff1a; IMF 有两个假设条件&#xff1a; 在整个数据段内&#xff0c;极值点的个数和过零点的个数必须相等或相差最多不能超过一 个&#xff1b;在任意时刻&#xff0c;由局部极大值点形成的上包络线和由局部极小值点形成的下包络线 的平均值为零&#x…
阅读更多...
WebGIS开发

WebGIS开发

1.准备工作 高德开发API注册账号&#xff0c;创建项目拿到key和密钥 高德key 2.通过JS API引入高德API <html><head><meta charset"utf-8" /><meta http-equiv"X-UA-Compatible" content"IEedge" /><metaname&quo…
阅读更多...
Ubuntu上安装d4rl数据集

Ubuntu上安装d4rl数据集

Ubuntu上安装d4rl数据集 D4RL的官方 github: https://github.com/Farama-Foundation/D4RL 一、安装Mujoco 1.1 官网下载mujoco210文件 如果装过可以跳过这步 链接&#xff1a;https://github.com/deepmind/mujoco/releases/tag/2.1.0 下载第一个文件即可。我这里是在windo…
阅读更多...
【JAVA】精密逻辑控制过程（分支和循环语句）

【JAVA】精密逻辑控制过程（分支和循环语句）

✅作者简介&#xff1a;大家好&#xff0c;我是橘橙黄又青&#xff0c;一个想要与大家共同进步的男人&#x1f609;&#x1f609; &#x1f34e;个人主页&#xff1a; 橘橙黄又青-CSDN博客 目标&#xff1a; 1. Java 中程序的逻辑控制语句 2. Java 中的输入输出方式 3. 完成…
阅读更多...
动手学机器学习线性回归+习题

动手学机器学习线性回归+习题

线性回归 矩阵求导&#xff1a; 左边是分子布局&#xff0c;右边是分母布局&#xff0c;一般都用分母布局 解析解与数值解&#xff1a; 解析解是严格按照公式逻辑推导得到的&#xff0c;具有基本的函数形式。给出任意的自变量就可以求出其因变量 数值解是采用某种计算方法&a…
阅读更多...
写作类AI推荐（二）

写作类AI推荐（二）

本章要介绍的写作AI如下&#xff1a; 火山写作 主要功能&#xff1a; AI智能创作&#xff1a;告诉 AI 你想写什么&#xff0c;立即生成你理想中的文章AI智能改写&#xff1a;选中段落句子&#xff0c;可提升表达、修改语气、扩写、总结、缩写等文章内容优化&#xff1a;根据全文…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023