网络编程多路复用--EPOLL实现一对一聊天

最新推荐文章于 2022-10-14 12:00:50 发布
最新推荐文章于 2022-10-14 12:00:50 发布
阅读量559 收藏 8
点赞数 2
分类专栏： 网络编程 文章标签： epoll select socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haospark/article/details/90176702
版权

一，IO复用几种方法的比较

select, poll, epoll都可以实现套接字I/O复用，但select这个函数是有缺陷的，主要体现在两个方面：

  1. 最大并发数限制，因为一个进程所打开的 FD （文件描述符）是有限制的，由 FD_SETSIZE 设置，默认值是 1024，这是在<sys/select.h>中的一个常量，因此 Select 模型的最大并发数就被相应限制了，但是对于大多数应用程序而言，这个数是够用的，而且有可能还是太大的，多数应用程序只使用3~10个描述符。而如今的网络服务器小小的都有几万的连接，虽然可以使用多线程多进程(也就有N*1024个)。但是这样处理起来既不方面，性能又低。
  2. 效率问题， select 每次调用后都会线性扫描全部的 fdset 集合，这样效率就会呈现线性下降。
  3. poll 模型

    基本上效率和 select 是相同的， select 缺点的 1和 2 它都没有改掉。

二，select的一对一聊天程序：

1，服务器端代码：

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>

#define SERVER_PORT 7777
#define BUF_LEN 256

int setupSocket()
{
    int ret = 0;
    //1,创建socket
    int server_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(server_sock < 0)
    {
        perror("socket");
        return -1; 
    }
    
    //2,绑定
    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = INADDR_ANY;
    
    //设置套接字可以复用，在关闭后，重新启动不用等待。
    int flags=1;
    setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags));
    
    if(bind(server_sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) < 0)
    {
        perror("bind");
        ret = -1;
        goto sock_error;
    }
    
    //3,监听
    if( listen(server_sock, 10) < 0)
    {
        perror("listen");
        ret = -1;
        goto sock_error;
    }
    ret = server_sock;
    goto sock_ok;
sock_error:
    close (server_sock);
sock_ok:
    return ret;
}

int main()
{    
    int ret = 0, server_sock = 0, clisock = 0, maxid = 0, fd = 0, number = 0;
    char buf[BUF_LEN] = {0};
    struct sockaddr_in  client_addr;
    //socklent_t 就是一个无符号整型 unsigned int
    socklen_t addrlen = sizeof(struct sockaddr_in);
    
    //1,初始化socket
    server_sock = setupSocket();
    if(server_sock < 0)
    {
        perror("setupSocket");
        return -1;
    }
    
    //(1)定义描述符集合
    fd_set readfds, testfds;
    struct timeval  tv;
    tv.tv_sec = 3;
    tv.tv_usec = 0;
    
    //(2)填充要关注的事件，包括，描述符，事件
    //清空fd_set集合
    FD_ZERO(&readfds);
    
    //向fd_set集合中添加一个套接字
    FD_SET(server_sock, &readfds);
    FD_SET(STDIN_FILENO, &readfds);
    
    maxid = server_sock + 1;
    
    while(1)
    {
        testfds = readfds;
        ret =  select(maxid, &testfds, NULL, NULL, &tv);
        //printf("select return: %d, timeout.tv_sec: %lu\n", ++number, (unsigned long)tv.tv_sec);
        
        if(ret < 0)
        {
            perror("select");
            continue;
        }
        else if(ret == 0)
        {
            tv.tv_sec = 3;
            tv.tv_usec = 0;
            //printf("timeout...\n");
            continue;
        }
        
        //
        for(fd = 0; fd < maxid; fd++)
        {
            //判断该描述符是否还存在于fd_set集合中，若存在，则表明该描述字发生了读/写事件
            if(!FD_ISSET(fd, &testfds))
            {
                continue;
            }
            
            if(fd == server_sock)
            {
                //2,接受客户的连接请求
                addrlen = sizeof(struct sockaddr_in);
                if((clisock = accept(server_sock, (struct sockaddr *)&client_addr, &addrlen)) < 0)
                {
                    perror("accept");
                    break;
                }
                printf("connect form : %s, port : %u\n", 
                    (char *)inet_ntoa(client_addr.sin_addr), client_addr.sin_port);
                    
                FD_SET(clisock, &readfds);
                maxid = (maxid > clisock ? maxid : clisock + 1);
            }
            else if(fd == STDIN_FILENO)
            {
                bzero(buf, BUF_LEN);
                if(fgets(buf, BUF_LEN, stdin) == NULL)
                {
                    perror("fgets");
                }
                
                if(send(clisock, buf, strlen(buf), 0) < 0)
                {
                    perror("send");
                    break;
                }
            }
            else if(fd == clisock)
            {
                bzero(buf, BUF_LEN);
                //read(fd, buf, BUF_LEN);
                ret = recv(fd, buf, BUF_LEN, 0);
                if(ret < 0)
                {
                    perror("recv");
                }
                else if(ret == 0)
                {
                    printf("client close\n");
                    close(fd);
                    FD_CLR(fd, &readfds);
                }
                else
                {
                    printf("recv : %s\n", buf);
                }                
            }
        }
    }

error_sock:
    close(server_sock);
    //4,关闭
    return ret;
}

 

2，客户端代码：


#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#define SERVER_PORT 7777
#define BUF_LEN 256

int main()
{
    int ret = 0, maxid = 0, i = 0;
    char buf[BUF_LEN] = {0};
    //1，创建socket
    int clisock = socket(AF_INET, SOCK_STREAM, 0);
    if(clisock < 0)
    {
        perror("socket");
        return -1;
    }
    printf("socket ok.\n");
    
    //2,连接到服务器
    struct sockaddr_in  server_addr;
    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");    
    
    if((ret = connect(clisock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in))) < 0 )
    {
        perror("connect");
        goto error_0;
    }
    printf("connect ok.\n");
    
    fd_set readfds, tempfds;
    FD_ZERO(&readfds);
    
    FD_SET(STDIN_FILENO, &readfds);
    FD_SET(clisock, &readfds);
    maxid = clisock + 1;
    while(1)
    {
        tempfds = readfds;
        ret = select(maxid, &tempfds, NULL , NULL, NULL);
        if(ret < 0)
        {
            perror("select");
        }
        
        for(i = 0; i < maxid; i++)
        {
            if(!FD_ISSET(i, &tempfds))
            {
                continue;
            }
            
            if(i == STDIN_FILENO)
            {
                memset(buf, 0, BUF_LEN);
                scanf("%s", buf);
                if((ret = send(clisock, buf, strlen(buf), 0)) <= 0)
                {
                    perror("send");
                    goto error_0;
                }        
            }
            else
            {
                memset(buf, 0, BUF_LEN);
                if((ret = recv(clisock, buf, BUF_LEN, 0)) <= 0)
                {
                    perror("recv");
                    goto error_0;
                }
        
                printf("client recv : %s\n", buf);
            }
        }
    }
error_0:
    //4，关闭连接
    close(clisock);
    printf("client closed \n");
    return 0;
}

三，epoll实现的一对一聊天程序：

1，服务器端代码：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>

#define PORT 10234
#define LISTEN_Q 5
#define BUF_SIZE 256
#define MAX_EVENTS 500

//服务器端的初始化，不需要客户端参与
int setup_listen_sock() 
{
    int sockfd, len;
    struct sockaddr_in address;

    //1,创建TCP套接字
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd == -1) {
        perror("socket");
        exit(1);
    }

    //2,填充要绑定的服务器地址
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
    len = sizeof(address);
    
    //设置可以复用地址
    int on = 1;
    if(setsockopt(sockfd,SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1){
        perror("setsockopt");
        exit(-1);
    }

    //3，绑定地址
    if(bind(sockfd, (struct sockaddr *)&address, len) == -1) {
        perror("bind");
        exit(1);
    }

    //4，监听客户端连接
    if(listen(sockfd, LISTEN_Q) == -1) {
        perror("listen");
        exit(1);
    }

    return sockfd;    
}

int main()
{
    int listen_sockfd, client_sockfd = 0, i = 0, ret = 0, client_len;
    struct sockaddr_in client_address;    
    char rwbuf[BUF_SIZE] = {0};
    //服务器端初始化，返回服务器端的监听套接字
    listen_sockfd = setup_listen_sock();
    
    //(1)定义epoll相关的数据结构
    struct epoll_event eventArray[MAX_EVENTS];
    struct epoll_event event_sock;
    struct epoll_event event_stdin;
    
    //(2)调用epoll_create，创建epoll描述符
    int epollfd = epoll_create(MAX_EVENTS);
    
    //(3)填充要关注的信息，包括套接字描述符和事件
    event_sock.events = EPOLLIN;
    event_sock.data.fd = listen_sockfd;//把listen_sockfd fd封装进events里面
    
    event_stdin.events = EPOLLIN;
    event_stdin.data.fd = STDIN_FILENO;
    
    //(4)epoll_ctl设置属性,注册事件
    if(epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sockfd, &event_sock) < 0 )
    {
        printf("epoll 加入失败 fd:%d\n",listen_sockfd);
        exit(-1);
    }
    
    if(epoll_ctl(epollfd, EPOLL_CTL_ADD, STDIN_FILENO, &event_stdin) < 0)
    {
        printf("epoll 加入失败 fd:%d\n",listen_sockfd);
        exit(-1);
    }

    while(1) 
    {
        printf("server waiting\n");        
        
        //(5)等待事件发生
        ret = epoll_wait(epollfd, eventArray, MAX_EVENTS, -1);

        if(ret < 0)
        {
            perror("epoll_wait");
            exit(1);
        }
        
        //(4)获取哪个套接字上发生了事件
        //select返回后会把未发生事件的描述符从fd_set集合中移除
        for(i = 0; i < ret; i++) 
        {            
            //错误输出
            if((eventArray[i].events & EPOLLERR) ||
                (eventArray[i].events & EPOLLHUP) || 
                !(eventArray[i].events & EPOLLIN)) 
            {
                      perror("epoll error");
                   close(eventArray[i].data.fd);
                   exit(-1);
            }

            else if(eventArray[i].data.fd == listen_sockfd)
            {  
                // receive client connect request
                client_len = sizeof(client_address);
                client_sockfd = accept(listen_sockfd, (struct sockaddr *)&client_address, &client_len);

                //把客户端连接注册到监听中
                struct epoll_event event_cli;
                event_cli.data.fd = client_sockfd;
                event_cli.events = EPOLLIN;
                epoll_ctl(epollfd, EPOLL_CTL_ADD, client_sockfd, &event_cli);
                printf("adding client on fd %d\n", client_sockfd);
            }
            else if(STDIN_FILENO == eventArray[i].data.fd)
            {
                read(STDIN_FILENO, rwbuf, BUF_SIZE);                
                if(client_sockfd > 0)
                {
                    send(client_sockfd, rwbuf, strlen(rwbuf), 0);
                    printf("send client_sockfd %d: %s\n",client_sockfd, rwbuf);
                }
            }
            else
            {
                int nread = 0;
                ioctl(eventArray[i].data.fd, FIONREAD, &nread); 
                //得到缓冲区里有多少字节要被读取，然后将字节数放入nread里面
                if(nread == 0) 
                {  
                    // client disconnect
                    close(eventArray[i].data.fd);
                    epoll_ctl(epollfd, EPOLL_CTL_DEL, eventArray[i].data.fd, &eventArray[i]);
                    printf("removing client on fd ：%d\n", eventArray[i].data.fd);
                }
                else 
                {  // receive client data
                    read(eventArray[i].data.fd, rwbuf, BUF_SIZE);
                    //printf("serving client on fd %d : %d\n", fd, data);
                    printf("recv fd %d: %s\n", eventArray[i].data.fd, rwbuf);
                }
            }
        }
    }
    
    close(epollfd);
}
        
2，epoll客户端代码

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>

#define PORT 10234
#define BUF_LEN 256
#define MAX_EVENTS 500

int main()
{
    int ret = 0, i = 0;
    char buf[BUF_LEN] = {0};
    
    //1，创建socket
    int clisock = socket(AF_INET, SOCK_STREAM, 0);
    if(clisock < 0)
    {
        perror("socket");
        return -1;
    }
    printf("socket ok.\n");
    
    //2,连接到服务器
    struct sockaddr_in  server_addr;
    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");    
    
    if((ret = connect(clisock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in))) < 0 )
    {
        perror("connect");
        goto error_0;
    }
    printf("connect ok.\n");
    
    //(1)定义相关数据结构
    int epollfd=0;
    struct epoll_event event_stdin;
    struct epoll_event event_clisock;
    struct epoll_event eventArray[MAX_EVENTS];
    
    //(2)创建epoll专用的描述符
    epollfd = epoll_create(MAX_EVENTS);
    
    //(3)填充要关注的信息，包括套接字描述和事件
    event_stdin.events = EPOLLIN|EPOLLET;
    event_stdin.data.fd = STDIN_FILENO;//把STDIN_FILENO封装进events里面    
    
    event_clisock.events = EPOLLIN|EPOLLET;
    event_clisock.data.fd = clisock;//把clisock封装进events里面
    
     //(4)epoll_ctl设置属性,注册事件
    if(epoll_ctl(epollfd, EPOLL_CTL_ADD, STDIN_FILENO, &event_stdin) < 0 )
    {
        printf("epoll 加入失败 fd:%d\n",STDIN_FILENO);
        exit(-1);
    }
    if(epoll_ctl(epollfd, EPOLL_CTL_ADD, clisock, &event_clisock) < 0 )
    {
        printf("epoll 加入失败 fd:%d\n",clisock);
        exit(-1);
    }

    while(1)
    {

        //(5)等待事件发生
        ret = epoll_wait(epollfd, eventArray, MAX_EVENTS, -1);
        if(ret < 0)
        {
            perror("epoll_wait");
            exit(1);
        }        
        
        //(6)处理事件
        for(i = 0; i < ret; i++)
        {
            //错误输出
            if((eventArray[i].events & EPOLLERR) ||
                (eventArray[i].events & EPOLLHUP) || 
                !(eventArray[i].events & EPOLLIN)) 
            {
                      perror("epoll error");
                   close(eventArray[i].data.fd);
                   exit(-1);
            }
            
            else if(STDIN_FILENO == eventArray[i].data.fd)
            {
                memset(buf, 0, BUF_LEN);
                read(STDIN_FILENO, buf, BUF_LEN);    

                send(clisock, buf, strlen(buf), 0);
                printf("send clisock %d: %s\n",clisock, buf);
            }
            else
            {
                memset(buf, 0, BUF_LEN);
                ret = recv(clisock, buf, BUF_LEN, 0);
                if(ret <0)
                {
                    perror("recv");
                    goto error_0;
                }
                else if(ret == 0)
                {
                    goto error_0;
                }
        
                printf("client recv : %s\n", buf);
            }

        }
    }
error_0:
    //4，关闭连接
    close(clisock);
    return 0;
}

 

haospark
关注
专栏目录
Linux平台基于epoll实现网络编程IO多路复用
cchangcs
11-14 352
epoll 是在Linux 2.6 内核中提出的，是之前select 和poll 的增强版本。相对于select 和poll 来说， epoll 更加灵活，没有描述符限制。epoll 使用一个文件描述符管理多个描述符，将 用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间之间的数据拷贝只需一次。 一、epoll 接口 使用epoll 必须包含下面的这个头文件：#include <sys/epoll .h> epoll 操作过程需要3 个接口，分别如下： int e
Linux网络编程(四)——epoll+多线程实现简单的聊天（linux 服务器端 windows客户端）
06-13
Linux网络编程(四)——epoll+多线程实现简单的聊天（linux 服务器端 windows客户端）
网络编程——多线程技术实现网络聊天程序
HeartHelp2013的博客
10-16 772
最近学习了网络编程，在学习多线程技术后，就尝试着用多线程技术写了一个网络聊天程序。下面介绍一下具体的实现过程。 既然是聊天程序，肯定要发送数据和接收数据，这里我新创建了一个线程来接收数据，用主线程来发送数据。同一个进程中的两个线程可以独立运行并相互交通信。因此可以实现数据的接收和发送。 先建立一个基于对话框的应用程序，并在对话框上放置接收数据的编辑框、发送数据...
epoll实现多人聊天小项目
Victor_psl的博客
07-26 489
多人聊天项目的流程： 1基于C/S模式建立的多人聊天程序，首先实现单一客户端与服务器的TCP连接。 2然后运用epoll机制实现多人聊天。这里的多人聊天指的是群聊，每个用户可以发消息到服务器，然后可以从服务器收到其他的用户的消息。 3这里fork()子进程，子进程等待接受用户输入的信息，然后把信息输入到管道，传给父进程。父进程把用户的消息传送到服务器，然后接受服务器传来的其他的用户的消息。 4.TCP/IP机制，服务器端，服务器创建套接字，绑定套接字，监听绑定的套接字，链接客户端的套接字，连接上之后
Linux下epoll实现简易聊天
12-03
在linux系统下用epoll实现的简易聊天，简单的qq。所有源码都在里面，直接可运行，分为客户端和服务器两个文件夹
多线程并发与多路复用网络聊天室
emile233的博客
10-14 173
两种聊天室使用的时同一个客户端。多路复用select。
IO多路复用之epoll全面总结(必看篇)
09-15
在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细总结： 1. **基本概念** - **epoll** 是在Linux 2.6内核引入的，是对早期的`select`和`poll`函数的...
select和epoll实现多路复用.zip
05-20
在IT领域，多路复用技术是用于高并发网络编程的一种高效策略，它允许一个单一的线程同时处理多个连接。本项目通过`select`和`epoll`两种方法实现了这一功能，并使用`jmeter`进行了性能测试。下面将详细讨论这两个多...
socket网络编程-epoll-水平触发和边缘触发源码
07-22
（1）I/O多路复用技术用于监控多个TCP连接上的数据收发，而epoll就是一种在Linux上使用的I/O多路复用并支持高并发的典型技术。传统的select、poll也是I/O多路复用技术，但这2种技术受内部实现的限制，不支持高并发，...
网络io与io多路复用select/poll/epoll 服务器并发代码实现
最新发布
08-29
网络I/O多路复用技术则是一种高效处理并发连接的方法，能够提高服务器性能，允许一个进程同时处理多个客户端请求。本文将深入探讨网络I/O的基本概念，以及select、poll和epoll这三种I/O多路复用机制，并通过实际代码...
简单多线程socket聊天室程序(c语言)
01-26
server.c client.c Makefile 在linux下编译通过，C语言编写，短小精练。 server实现数据转发，使用了socket中的accept,select,线程中的线程分离属性（PTHREAD_CREATE_DETACHED）等 client实现读和写的异步，也使用了线程分离属性。 直接实现多个client终端对话。 可做为新人学习的参考。
简单的聊天室程序实现了多人聊天，一对一聊天等
09-06
本实例是在学习java中做的一个案例，实现了多人聊天，一对一聊天，抖动等功能，适合初学java开发者参考学习
linux 多进程聊天程序
06-10
ubuntu下通过多进程实现多太PC机的聊天程序
chat:C\C++语言利用epoll实现高并发聊天室Demo
05-16
chat 项目介绍 本项目是实现一个简单的聊天室，聊天室分为服务端和客户端。采用C/S模型，使用TCP连接。 相关技术点: 支持多个用户接入，实现聊天室的基本功能 使用epoll机制实现并发，增加效率。 使用fork创建两个进程，一个为写进程，一个为读进程。 将聊天信息写到管道（pipe），并发送给父进程。 使用epoll机制接受服务端发来的信息，并显示给用户，使用户看到其他用户的聊天信息 运行效果 订阅客户端接受来自发布服务端的的内容示意图 运行环境 ubuntu 快速教程 1.下载源码 2.解压 3.进入源码目录，运行make命令，生成server，client可执行程序 4.运行server程序 5.运行client订阅者程序 项目结构 无 版权信息 暂无
C语言的一对一即时聊天工具socket实现
06-04
socket即时网络通信工具，服务端客户端都有，详细注释
C语言 Linux 聊天室(IO多路复用、多线程)
qingjiao_fa的博客
08-03 2061
服务器:建立套接字、设置ip和port、绑定ip和port、监听、连接、收发消息。​ 客户端：建立套接字、配置服务器ip和port、连接服务器、创建线程收发消息。建立一个服务器,有很多个客户端加入服务器，就可以实现群聊功能。​服务器需要很多连接加入，所以用到IO多路复用。我们创建4个终端，1个服务器，3个客户端。...
IO多路复用（select）多线程实现点对点聊天
Xinspace
04-05 2023
在网络编程中，IO操作不止本地的read或write，还会有网络套接字上的read和write。这样的话就容易出现这个问题： 当你用fgets函数在等待本地的标准输入，这时IO输入操作会阻塞在这里等待输入。如果此时网络套接字上传来了数据（比如说关闭连接命令），由于你的IO被阻塞在fgets处，无法及时知道网络套接字上传来的关闭命令。当你从fgets处获得数据后，再处理网络套接字发来的关闭命令
多进程和多线程简单tcp聊天程序
sophia__yu的博客
10-02 753
如果需要一个服务端可以连接多个客户端，并同时与多个（不超多listen第二个参数及最大同时并发数）客户端通信，可以利用多进程即创建子进程，子进程来完成服务端的接受和发送数据；也可以创建多个线程。 tcp客户端代码 //tcp 客户端代码 //1.创建套接字 //2.绑定地址信息 //3.向服务端发送连接请求 //4.发送数据 //5.接受数据 //6.关闭socket描述符 #include&amp;amp;l...
【项目收获】epoll实现一个简单的聊天室
o小菜的博客
04-05 975
客户端功能 a.支持用户输入聊天消息 b.显示其他用户输入的信息 c.使用fork创建两个进程 子进程有两个功能： 等待用户输入聊天信息 将聊天信息写到管道（pipe），并发送给父进程 父进程有两个功能 使用epoll机制接受服务端发来的信息，并显示给用户，使用户看到其他用户的聊天信息 将子进程发给的聊天信息从管道（pipe）中读取, 并发送...
理解IO多路复用：select与epoll的深入剖析
本文档深入探讨了计算机网络编程中的I/O模型，特别是多路复用技术在Unix系统中的应用，如select和epoll。I/O模型是操作系统中处理并发网络通信的核心概念，它决定了进程在等待数据传输时的行为模式。 首先，理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

haospark

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值