Linux15 select，poll，epoll

最新推荐文章于 2025-07-15 20:11:50 发布
原创 最新推荐文章于 2025-07-15 20:11:50 发布 · 153 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了I/O多路复用技术中的select、poll和epoll三种方法，包括它们的工作原理、代码实现和应用场景。select和poll通过轮询多个文件描述符来检测其是否就绪，而epoll则提供了更高效的事件驱动模型，特别是ET模式下结合非阻塞IO，能显著提升服务器性能。

1.select

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
selsect.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<assert.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#define MAXFD 10
void fds_add(int fds[],int fd)
{
   int i=0;
   for(;i<MAXFD;i++)
   {
	if(fds[i]==-1)
	{
	  fds[i]=fd;
	  break;
	}
   }
}
void fds_del(int fds[],int fd)
{
   int i=0;
   for(;i<MAXFD;i++)
   {
	if(fds[i]==fd)
	{
	  fds[i]=-1;
	  break;
	}
   }
	
}
int main()
{
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    assert(sockfd!=-1);

    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));
    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(6000);
    saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

    //int res=connect(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    int res =bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    assert(res!=-1);
    listen(sockfd,5);
    
    fd_set fdset;
    int fds[MAXFD];//collect fd;
    int i=0;
    for(;i<MAXFD;i++)
    {
	fds[i]=-1;
    }
    fds_add(fds,sockfd);
    while(1)
    {
       FD_ZERO(&fdset);
       int maxfd=-1;
       int i=0;
       for(;i<MAXFD;i++)
       {
          if(fds[i]==-1)
          {
             continue;
	   }
	  FD_SET(fds[i],&fdset);
	  if(fds[i]>maxfd)
 	  {
	    maxfd=fds[i];
	  }
    }
    struct timeval tv={5,0};
    int n=select(maxfd+1,&fdset,NULL,NULL,&tv);
    if(n==-1)
    {
	perror("select error!!");
    }
    else if(n==0)
    {
	printf("time out\n");
    }
    else
    {
	for(i=0;i<MAXFD;i++)
	{
	   if(fds[i]==-1)
	   {
	    continue;
	   }
	   if(FD_ISSET(fds[i],&fdset))
	   {
		if(fds[i]==sockfd)
		{
		  
		  //accept
		  struct sockaddr_in caddr;
		  int len =sizeof(caddr);
		  int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
		  if(c<0)
		  {
		    continue;
		  }
		  printf("accept c=%d\n",c);
		  fds_add(fds,c);
		}
		else
		{
		  //recv;
		  char buff[128]={0};
		  int res =recv(fds[i],buff,127,0);
		  if(res<=0)
		 {
		   close(fds[i]);
		   fds_del(fds,fds[i]);
		   printf("one client over!!\n");
		  
		  }
		else
		{
			printf("recv(%d)=%s\n",fds[i],buff);
			send(fds[i],"ok",2,0);
		}
	   }
}
}
}
}
}

2.poll

在这里插入图片描述
在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<assert.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<poll.h>
#define MAXFD 10
int creat_sockfd();
void fds_add(struct pollfd fds[],int fd)
{
	int i=0;
	for(;i<MAXFD;i++)
	{
		if(fds[i].fd==-1)
		{
			fds[i].fd=fd;
			fds[i].events=POLLIN;
			fds[i].revents=0;
			break;
		}
	}
}
void fds_del(struct pollfd fds[],int fd)
{
	int i=0;
	for(;i<MAXFD;i++)
	{
		if(fds[i].fd==fd)
		{
			fds[i].fd=-1;
			fds[i].events=0;
			fds[i].revents=0;
			break;
		}
	}
}

void fds_init(struct pollfd fds[])
{
	int i=0;
	for(;i<MAXFD;i++)
	{
		fds[i].fd=-1;
		fds[i].events=0;
		fds[i].revents=0;
	}
}
int main()
{
	int sockfd=creat_sockfd();
	assert(sockfd!=-1);

	struct pollfd fds[MAXFD];
	fds_init(fds);

	fds_add(fds,sockfd);

	while(1)
	{
		int n=poll(fds,MAXFD,5000);//zu se;????????????
		if(n==-1)
		{
			perror("poll error");
		}
		if(n==0)
		{
			printf("time out!!\n");
		}
		else
		{
			int i=0;
			for(;i<MAXFD;i++)
			{
				if(fds[i].fd==-1)
				{
					continue;
				}
				if(fds[i].revents & POLLIN)
				{
					if(fds[i].fd==sockfd)
					{
						//accept
						struct sockaddr_in caddr;
						int len =sizeof(caddr);
						int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
						if(c<0)
						{
							continue;
						}
						printf("accept c=%d\n",c);
						fds_add(fds,c);
					}
					else
					{
						//recv
						char buff[128]={0};
						int res=recv(fds[i].fd,buff,127,0);
						if(res<=0)
						{
							close(fds[i].fd);
							fds_del(fds,fds[i].fd);
							printf("one client over!!\n");
						}
						else
						{
							printf("recv(%d)=%s\n",fds[i].fd,buff);
							send(fds[i].fd,"ok",2,0);
						}

					}
				}
			}
		}
	}

	
}
int creat_sockfd()
{
	int sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(sockfd==-1)
	{
		return -1;
	}
	struct sockaddr_in saddr;
	memset(&saddr,0,sizeof(saddr));
	saddr.sin_family =AF_INET;
	saddr.sin_port =htons(6000);
	saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

	//saddr.sin_addr.s_addr=inet((struct sockaddr*)&saddr,sizeof(saddr));

	int res=bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
	assert(res!=-1);
	listen(sockfd,20);
	return sockfd;

}

3.epoll

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<assert.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/epoll.h>
#define MAXFD 10
int creat_sockfd();
void epoll_add(int epfd,int fd)
{
	struct epoll_event ev;
	ev.data.fd=fd;
	ev.events=EPOLLIN;

	if( epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev)==-1)
	{
		perror("epoll error!!");
	}
	
}
void epoll_del(int epfd,int fd)
{
	if(epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL)==-1)
	{
		perror("epoll_del error!!");
	}
}
int main()
{
	int sockfd=creat_sockfd();
	assert(sockfd!=-1);

	int epfd=epoll_create(MAXFD);
	assert(epfd!=-1);

	epoll_add(epfd,sockfd);

	struct epoll_event events[MAXFD];//creat neihe event

	while(1)
	{
		int n=epoll_wait(epfd,events,MAXFD,5000);
		if(n==-1)
		{
			perror("epoll_wait error!!");
		}
		if(n==0)
		{
			printf("time out!!\n");
		}
		else
		{
			int i=0;
			for(;i<n;i++)
			{
				int fd=events[i].data.fd;
				if(events[i].events & EPOLLIN)
				{
					if(fd==sockfd)
					{
						//accept
						struct sockaddr_in caddr;
						int len =sizeof(caddr);
						int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
						if(c<0)
						{
							continue;
						}
						printf("accept c=%d\n",c);
						epoll_add(epfd,c);
					}
					else
					 {
						//recv
						char buff[128]={0};
						int num=recv(fd,buff,127,0);
						if(num==0)
						{
							epoll_del(epfd,fd);//xian yichu zai close
							close(fd);
							printf("one client over!!\n");
						}
						else
						{
							printf("buff(%d)=%s\n",fd,buff);
							send(fd,"ok",2,0);
						}
					}
				}
			}

		}
		
	}



	
}
int creat_sockfd()
{
	int sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(sockfd==-1)
	{
		return -1;
	}
	struct sockaddr_in saddr;
	memset(&saddr,0,sizeof(saddr));
	saddr.sin_family =AF_INET;
	saddr.sin_port =htons(6000);
	saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

	//saddr.sin_addr.s_addr=inet((struct sockaddr*)&saddr,sizeof(saddr));

	int res=bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
	assert(res!=-1);
	listen(sockfd,20);
	return sockfd;


}

4.epoll的两种工作模式

在这里插入图片描述

4.1LT模式

LT（没读完io提醒继续读，直到读完为止）默认反复提醒，返回次数为字符数
默认为LT模式

4.2ET模式

只能使用非阻塞模式（减少返回次数，只返回一次），fcntl开启高效模式：发一次数据才会提醒一次，只提醒一次，无论处理还是未处理完，只提醒一次。客户端一关，服务器就崩掉了，原因是：

4.2.1 代码实现

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<assert.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/epoll.h>
#include<fcntl.h>
#define MAXFD 10
int creat_sockfd();
void setnonblock(int fd)
{
	int oldfl=fcntl(fd,F_GETFL);
	int newfl=oldfl| O_NONBLOCK;
	if(fcntl(fd,F_SETFL,newfl)==-1)
	{
		perror("fcntl error");
	}
}
void epoll_add(int epfd,int fd)
{
	//开启ET模式
	struct epoll_event ev;
	ev.data.fd=fd;
	ev.events=EPOLLIN;
	ev.events|=EPOLLET;

	if( epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev)==-1)
	{
		perror("epoll error!!");
	}
	setnonblock(fd);//设置非阻塞
	
}
void epoll_del(int epfd,int fd)
{
	if(epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL)==-1)
	{
		perror("epoll_del error!!");
	}
}
int main()
{
	int sockfd=creat_sockfd();
	assert(sockfd!=-1);

	int epfd=epoll_create(MAXFD);
	assert(epfd!=-1);

	epoll_add(epfd,sockfd);

	struct epoll_event events[MAXFD];//creat neihe event创建内核事件

	while(1)
	{
		int n=epoll_wait(epfd,events,MAXFD,5000);//5s
		if(n==-1)
		{
			perror("epoll_wait error!!");
		}
		if(n==0)
		{
			printf("time out!!\n");
		}
		else
		{
			int i=0;
			for(;i<n;i++)
			{
				int fd=events[i].data.fd;
				if(events[i].events & EPOLLIN)
				{
					if(fd==sockfd)
					{
						//accept
						struct sockaddr_in caddr;
						int len =sizeof(caddr);
						int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
						if(c<0)
						{
							continue;
						}
						printf("accept c=%d\n",c);
						epoll_add(epfd,c);
					}
					else
					 {
						//recv
						char buff[128]={0};
						int num=recv(fd,buff,127,0);
						if(num==0)
						{
							epoll_del(epfd,fd);//xian yichu zai close
							close(fd);
							printf("one client over!!\n");
							break;
						}
						else if(num==-1)
						{
							send(fd,"ok",2,0);
							break;
						}
						else
						{
							printf("buff(%d)=%s\n",fd,buff);
							send(fd,"ok",2,0);
						}
					}
				}
			}

		}
		
	}



	
}
int creat_sockfd()
{
	int sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(sockfd==-1)
	{
		return -1;
	}
	struct sockaddr_in saddr;
	memset(&saddr,0,sizeof(saddr));
	saddr.sin_family =AF_INET;
	saddr.sin_port =htons(6000);
	saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

	//saddr.sin_addr.s_addr=inet((struct sockaddr*)&saddr,sizeof(saddr));

	int res=bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
	assert(res!=-1);
	listen(sockfd,20);
	return sockfd;

}

4.2.3

在这里插入图片描述

4.2.4利用管道处理两种事件

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>

int pipefd[2];
#define     MAXFD   10
int create_sockfd();

void epoll_add(int epfd, int fd)
{
    struct epoll_event ev;
    ev.data.fd = fd;
    ev.events = EPOLLIN | EPOLLRDHUP;//读事件

    if ( epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev) == -1 )
    {
        perror("epoll_ctl error");
    }

}
void epoll_del(int epfd, int fd)
{
    if ( epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL) == -1 )
    {
        perror("epoll_ctl del error");
    }
}

void fun(int sig)
{
    write(pipefd[1],&sig,sizeof(sig));
}
int main()
{
    int sockfd = create_sockfd();
    assert( sockfd != -1 );
   
    pipe(pipefd);//创建管道

    int epfd = epoll_create(MAXFD); //创建内核事件
    assert( epfd != -1 );

    epoll_add(epfd,sockfd);
    epoll_add(epfd,pipefd[0]);//添加管道的读端

    signal(SIGINT,fun);
    struct epoll_event events[MAXFD];
    int run = 1;
    while( run )
    {
        int n = epoll_wait(epfd,events,MAXFD,5000);
        if ( n == -1 )
        {
            if ( errno != EINTR )
            {
                perror("epoll_wait error");
            }
        }
        else if ( n == 0 )
        {
            printf("time out\n");
        }
        else
        {
            int i = 0;
            for( ;i < n; i++ )
            {
                int fd = events[i].data.fd;
                if ( events[i].events & EPOLLRDHUP)
                {
                            epoll_del(epfd,fd);
                            close(fd);
                            printf("one client hup over\n");

                }
                if ( events[i].events & EPOLLIN )
                {
                    if ( fd == sockfd )
                    {
                        //accept
                        struct sockaddr_in caddr;
                        int len = sizeof(caddr);
                        int c = accept(sockfd,(struct sockaddr*)&caddr,&len);
                        if ( c < 0 )
                        {
                            continue;
                        }

                        printf("accept c=%d\n",c);
                        epoll_add(epfd,c);
                    }
                    else if ( fd == pipefd[0] )
                    {
                        int sig = 0;
                        read(pipefd[0],&sig,sizeof(sig));
                        printf("recv sig=%d\n",sig);
                        run = 0;

                    }
                    else
                    {
                        //recv
                        char buff[128] = {0};
                        int num = recv(fd,buff,127,0);
                        if ( num == 0 )
                        {
                            epoll_del(epfd,fd);
                            close(fd);
                            printf("one client over\n");
                        }
                        else
                        {
                            printf("buff(%d)=%s\n",fd,buff);
                            send(fd,"ok",2,0);
                        }
                    }
                }
            }
        }
    }

    close(sockfd);
    close(epfd);

    printf("main over\n");
}

int create_sockfd()
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if ( sockfd == -1 )
    {
        return -1;
    }

    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(6000);
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    int res = bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if ( res == -1 )
    {
        return -1;
    }

    listen(sockfd,5);

    return sockfd;
}

5.select，poll，epoll三种的区别

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

【Linux】select、poll、epoll代码
m0_64263546的博客
02-06 1130
select poll epoll
【Linux】高级IO --- 多路转接，select，poll，epoll
The porters of knowledge
09-05 1831
五种IO模型，编写select_server，poll_server，epoll_server服务器代码，理解epoll模型的底层原理，总结select poll epoll三者的优缺点……
【Linux】select，poll和epoll
m0_73839343的博客
11-27 1054
select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符fd，一旦某个描述符就绪(一般是读就绪或者写就绪)，系统会通知有I/O事件发生了（不能定位是哪一个）。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。 select、poll和epoll这三个函数是Linux系统中I/
select poll epoll之间的区别
热门推荐
m0_61802230的博客
04-06 1万+
前导 首先在分析他们之前的区别前，需要明确几个概念。 同步阻塞、 同步非阻塞 异步非阻塞 同步和异步的概念： 同步是指用户线程发起IO请求后,需要等待或者轮询内核IO操作完成后才能继续执行； 异步是指用户线程发起IO请求后仍继续执行，当内核IO操作完成后会通知用户线程或者调用用户线程注册的回调函数。 阻塞和非阻塞的概念： 阻塞是指IO操作需要彻底完成后才返回到用户空间； 非阻塞是指IO操作被调用后立即返回给用户一个状态值，无需等到IO操作彻底完成。 I/O 同步和异步的区别在于：
select、poll 和 epoll
最新发布
纯洁的小魔鬼
07-15 1219
摘要：Linux系统中的select、poll和epoll都是I/O多路复用机制，用于高效监控多个文件描述符状态。select通过位图结构实现，但存在1024个文件描述符的限制；poll改用数组结构解决了数量限制，但仍是线性扫描；epoll采用事件驱动模型，通过红黑树和就绪队列实现O(1)时间复杂度，特别适合高并发场景。三者主要区别在于：select/poll需要每次重新传入所有描述符，而epoll只需注册一次；select/poll仅支持水平触发，epoll还支持边沿触发；epoll在性能上优势明显但仅适
【Linux高级IO】select、poll、epoll
m0_74215144的博客
06-09 1647
本篇博客将会介绍面试重点考察的select、poll、epoll
分析linux下select、poll和epoll
xuweilin的博客
09-20 487
对于少量连接的情况，select和poll都能满足需求，但select由于文件描述符数量的限制和效率问题，不推荐在需要处理大量连接的场景中使用。poll虽然解决了select的文件描述符数量限制问题，但效率上并未有显著提升。epoll是处理大量并发连接的首选方案，特别是在Linux平台上，其高效性和灵活性使其成为构建高性能网络服务器的关键技术之一。
Linux I/O 多路复用：select、poll 和 epoll 详解
2301_80067496的博客
05-13 812
本文将详细介绍三种主要的 I/O 多路复用机制：select、poll 和 epoll，分析它们的工作原理、API 使用、示例代码以及各自的优缺点。epoll 是 Linux 特有的高性能 I/O 多路复用机制，解决了 select 和 poll 的性能瓶颈。select 是最早出现的 I/O 多路复用机制，它使用位图（fd_set）来表示文件描述符集合。poll 改进了 select 的一些限制，使用链表结构代替位图，没有最大文件描述符数量的限制。: 需要监控的文件描述符的最大值加 1。
select、poll和epoll的区别
weixin_38597669的博客
02-06 2075
本文总结了从阻塞I/O模型到多路复用I/O模型的演变，以及select、poll、epoll三者各自优缺点。
【Linux基础】select、poll、epoll详解
白夜行
07-04 2823
引入1.定义 I/O 多路复用技术是为了解决进程或线程阻塞到某个 I/O 系统调用而出现的技术，使进程不阻塞于某个特定的 I/O 系统调用。而select()，poll()，epoll()都是I/O多路复用的机制。 I/O多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。 2.IO多路复用的适用场合 当客户处理多个描述符时（一般是交互式输入和网络套接口），必须使用I/O
Linux网络select/poll/epoll：学习笔记1
weixin_68925552的博客
06-27 2181
1.socket函数。
linux内核select/poll，epoll实现与区别
12-31
下面文章在这段时间内研究 select/poll/epoll的内核实现的一点心得体会： select，poll，epoll都是多路复用IO的函数，简单说就是在一个线程里，可以同时处理多个文件描述符的读写。 select/poll的实现很类似，epoll...
精选资源
LinuxIO模式及select、poll、epoll详解
02-01
15件事。无论你是刚加入Ubuntu行列的新用户，还是有经验的老用户，你都会发现一些非常有用的调整和建议。注：本文是对众多博客的学习和总结，可能存在理解错误。请带着怀疑的眼光，同时如果有错误希望能指出。同步IO...
精选资源
select poll epoll 代码实例
05-14
select poll epoll 代码实例
Linux 18shell编程
sunshinecandy的博客
07-31 2608
1. 2. 3. 4.
Linux 13网络服务器与客户端ser,cli
sunshinecandy的博客
04-20 468
@[TOC] # 1.dsgsrg # 2.ddsb # 3. zdf # 4. df
Linux16，17守护进程的实现，libevent库的使用
sunshinecandy的博客
04-26 259
1.实现过程 守护进程（编程流程）： fork（）退出父进程 setsid（）创建新会话 fork（）退出父进程（失去会话组长，进程组长的身份） 改变工作路径：chdir（“/”）改到根目录 Umask掩码全部清零设置为000 （umask 0），掩码（002）中有什么权限，创建的文件就缺什么 关闭所有描述符close() //（关闭僵死进程） Chkconfig查看后台的服务 UNIX第十三章...
Linux06，07，fork的使用与回顾，，解决僵死进程，文件操作
sunshinecandy的博客
03-23 241
1. 2. 3. 4. 5.
Linux10,11进程间通信（管道，信号量，共享内存，消息队列，套接字（未讲））
sunshinecandy的博客
03-23 240
进程间通信命令： ipcs可以看进程间的通信 -s看信号量-q消息队列-m共享内存 1.管道 1.1用法 管道有同步，在内存中使用方便。 有名管道，mkfifo fifo创建管道 无名管道。（在父子进程间使用） 1.2面试问题 1.管道是半双工，对讲机（半双工，同一时刻只能发或收） 单工（只能接受或发送） 全双工（吵架） 2.区别：任意两个进程 无名：只在父子进程间通讯。 3.管道在内存上存着。写...
linux驱动select poll epoll
10-16
2. poll：与 select 类似，但支持的文件描述符数量没有限制，而且不需要每次调用时都将所有文件描述符从用户态拷贝到内核态，效率比 select 稍高一些。 3. epoll：最新、最高效的 I/O 多路复用机制，支持的文件描述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我的sun&shine

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

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

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

打赏作者

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

抵扣说明：

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

余额充值