SOCKET网络编程五：IO多路复用epoll

最新推荐文章于 2024-09-03 05:30:00 发布
最新推荐文章于 2024-09-03 05:30:00 发布
阅读量493 收藏 1
点赞数
分类专栏： linux网络编程 文章标签： socket epoll 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_22991367/article/details/104332098
版权

一、关于select、poll、epoll这三者使用、对比介绍这篇：

网络编程--IO多路复用之select,poll和epoll详解

二、poll的使用和上篇的select大同小异：

int main(void)
{
	//当客户端结束时，服务器还维持一个僵尸进程
	signal(SIGCHLD, SIG_IGN);//使用signal忽略SIGCHLD信号(第一种方法)
	/*signal(SIGCHLD, handle_sigchld);//(第二种方法)*/

	int listenfd;//建立套接字
	if((listenfd=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
/*	if((listenfd=socket(PF_INET,SOCK_STREAM, 0))<0)*/
	ERR_EXIT("socket");
	//建立服务器地址
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(5188);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	/*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
	/*inet_aton("127.0.0.1",&servaddr.sin_addr);*/

	 int on = 1;
	 //为了使服务器处于TIME_WATTING状态，能再次绑定地址
	 if(setsockopt(listenfd,SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))<0)
		ERR_EXIT("setsockopt");
	 //绑定地址
	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
	ERR_EXIT("bind");
	//监听套接字
	if(listen(listenfd,SOMAXCONN)<0)//套接字变为被动套接字
		ERR_EXIT("listen");
	//存放客户端地址
	struct sockaddr_in peeraddr;
  	socklen_t peerlen;
  	
	int conn;//接受accept的套接字

	int i;
	int maxi = 0;
	struct pollfd client[2048];//假设一个进程可以打开最大的文件描述符数为2048
	for(i=0; i<2048; i++)
	{
		client[i].fd = -1;//空闲可以容纳新的客户端
	} 

	int nready;
	client[0].fd = listenfd;
	client[0].events = POLLIN;//读可读事件感兴趣
	//目前，加入到数组中的文件描述符个数等于1
	while(1)
	{
		nready = poll(client, maxi+1, -1);
		//nready = select(maxfd+1, &rset, NULL,NULL, NULL);
		if(nready==-1)
		{
			if(errno == EINTR)
				continue;
			ERR_EXIT("poll");
		}
		if(nready==0)
			continue;

		if(client[0].revents & POLLIN)//返回发生的事件与POLLIN相同
		//if(FD_ISSET(listenfd, &rset))
		{
			peerlen= sizeof(peeraddr);
			conn=accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);
			if(conn==-1)
				ERR_EXIT("accept");
			for(i=0; i<2048;i++)
			{
				if(client[i].fd<0)
				{
					client[i].fd=conn;//将新的套接字加入
					if(i>maxi)
						maxi=i;
					break;
				}

			}
			if(i==2048)
			{
				fprintf(stderr,"too many clients");
				exit(EXIT_FAILURE);
			}
			printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
			//FD_SET(conn, &allset);
			client[i].events = POLLIN;//添加事件

			
			if(--nready<=0)
				continue;
		}
		//监听套接口总为client[0]
		//已连接套接口从1到maxi
		for(i=1; i<=maxi; i++)
		{
			conn=client[i].fd;
			if(conn == -1)
				continue;

			if(client[i].events & POLLIN)//事件为POLLIN则处理
			//if(FD_ISSET(conn, &rset))
			{
				char recvbuf[1024] = {0};
				int ret = readline(conn, recvbuf,1024);//先接受包头
				if(ret==-1)//读取失败则退出
					ERR_EXIT("readline");
				else if(ret==0)//客户端关闭
				{
					printf("client_close\n");
					//FD_CLR(conn, &allset);
					client[i].fd = -1;
					close(conn);
				}
				
				
				fputs(recvbuf,stdout);//打印标准输出
				writen(conn,recvbuf, strlen(recvbuf));
				if(--nready<=0)
					break;
			}
		}
	}
	return 0;
}

三、我们主要关注epoll

//仅修改服务器端
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>//使用signal函数
#include <sys/wait.h>//使用wait函数
#include <sys/epoll.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include <vector>
#include <algorithm>

typedef std::vector<struct epoll_event> EventList;

#define ERR_EXIT(m) \
	do \
	{ \
		perror(m);	\
		exit(EXIT_FAILURE);\
	}while(0)

/*
activate_nonblock —— 设置I/O为非阻塞模式
*/
void activate_nonblock(int fd)
{
	int ret;
	int flags = fcntl(fd, F_GETFL);//获取文件标志
	if(flags == -1)
	{
		ERR_EXIT("fcntl");
	}

	flags |= O_NONBLOCK;//设置非阻塞模式
	ret = fcntl(fd, F_SETFL, flags);
	if(ret == -1)
		ERR_EXIT("fcntl");
}
//读确定大小的包
//ssize_t有符号数，size_t为无符号数
ssize_t readn(int fd, void *buf, size_t count)
{
	size_t nleft=count;//剩余字节数
	ssize_t nread;//已经接受的字节数
	char *bufp = (char*)buf;//

	while(nleft>0)
	{
		if((nread=read(fd, bufp, nleft))<0)
		{
			if(errno==EINTR)//信号中断
			{
				continue;
			}
			return -1;//否则出错
		}
		else if(nread==0)//表示对方关闭传送
		{
			return count-nleft;//返回已读字节数
		}
		bufp+=nread;//进行指针偏移
		nleft -= nread;
	} 
	return count;
}
ssize_t writen(int fd, const void *buf, size_t count)
{
	size_t nleft=count;//剩余字节数
	ssize_t nwritten;//已经写入的字节数
	char *bufp = (char*)buf;//

	while(nleft>0)
	{
		if((nwritten=write(fd, bufp, nleft))<0)
		{
			if(errno==EINTR)//信号中断
			{
				continue;
			}
			return -1;//否则出错
		}
		else if(nwritten==0)
		{
			continue;
		}
		bufp+=nwritten;//进行指针偏移
		nleft -= nwritten;
	} 
	return count;
}
ssize_t recv_peek(int sockfd, void *buf,size_t len)
{
	while(1)
	{
		//recv函数只用于套接口
		//recv函数读取后，不将数据在缓冲区清除
		int ret= recv(sockfd, buf, len, MSG_PEEK);
		if(ret == -1 && errno == EINTR)
			continue;
		return ret;
	}
}

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
	int ret;//设置窥探返回值
	int nread;//设置已窥探字符数
	char *bufp = (char*)buf;//缓存buf
	int nleft = maxline;//设置maxline为包最大长度，nleft为剩余需读取字符数
	while(1)
	{
		ret=recv_peek(sockfd, bufp, nleft);
		if(ret<0)
		{
			return ret;
		}
		else if(ret=0)
		{
			return ret;//对方终止了传送
		}

		nread=ret;
		int i;//检测有没有‘\n’字符，有则读取
		for(i=0; i<nread;i++)
		{
			if(bufp[i]=='\n')
			{
				ret= readn(sockfd,bufp, i+1);
				if(ret != i+1)//已经窥探到有i+1字符，如果没有则错误
					exit(EXIT_FAILURE);
				return ret;
			}
		}
		//如果没有读到‘\n’，则将消息读入，直到最大包
		nleft -= nread;
		ret= readn(sockfd, bufp, nread);
		if(ret != nread)//已经窥探到有nread个字符，如果readn函数不能读取这么多，则错误
		{
			exit(EXIT_FAILURE);
		}
		bufp += nread;
	}
	return -1;
}

void do_service(int conn)//执行连接建立后，内容读取，和返回内容
{
	char recvbuf[1024];
	int n;
		while(1)
		{
			memset(recvbuf, 0, sizeof(recvbuf));
			int ret = readline(conn, recvbuf,1024);//先接受包头
			if(ret==-1)//读取失败则退出
			ERR_EXIT("readline");
			else if(ret==0)//客户端关闭
			{
				printf("client_close\n");
				break;
			}
			
			
			fputs(recvbuf,stdout);//打印标准输出
			writen(conn,recvbuf, strlen(recvbuf));
		}
}
void ehco_srv(int conn)//执行连接建立后，内容读取，和返回内容
{
	char recvbuf[1024];
	int n;
		while(1)
		{
			memset(recvbuf, 0, sizeof(recvbuf));
			int ret = readline(conn, recvbuf,1024);//先接受包头
			if(ret==-1)//读取失败则退出
			ERR_EXIT("readline");
			else if(ret==0)//客户端关闭
			{
				printf("client_close\n");
				break;
			}
			
			
			fputs(recvbuf,stdout);//打印标准输出
			writen(conn,recvbuf, strlen(recvbuf));
		}
}
void handle_sigchld(int sig)
{
	//只等待一个子进程结束，就退出消除一个子进程产生的僵尸进程，无法处理并发的多个子进程，造成的僵尸进程
	//wait(NULL);
	//等待选项为不挂起，用来处理客户端多个并发子进程连接后关闭时造成的多个僵尸进程
	while(waitpid(-1, NULL, WNOHANG)>0);
}
void handle_sigpipe(int sig)
{
	printf("recv a sig=%d\n", sig);
}
int main(void)
{
	int count = 0;
	//处理A调用了close,A不能再接收和发送数据段，但对等方B可以向A发送数据包，
	//如果B这样做了，A返回RST段，B再向A发送数据，A会产生SIGPIPE信号，该信号直接忽略就好
	signal(SIGPIPE, handle_sigpipe);
	//当客户端结束时，服务器还维持一个僵尸进程
	/*signal(SIGCHLD, SIG_IGH)；//使用signal忽略SIGCHLD信号(第一种方法)*/
	signal(SIGCHLD, handle_sigchld);//(第二种方法)

	int listenfd;//建立套接字
	if((listenfd=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)
	/*	if((listenfd=socket(PF_INET,SOCK_STREAM, 0))<0)*/
		ERR_EXIT("socket");
	//建立服务器地址
	struct sockaddr_in servaddr;
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(5188);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	/*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
	/*inet_aton("127.0.0.1",&servaddr.sin_addr);*/

	 int on = 1;
	 //为了使服务器处于TIME_WATTING状态，能再次绑定地址
	 if(setsockopt(listenfd,SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))<0)
		ERR_EXIT("setsockopt");
	 //绑定地址
	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("bind");
	//监听套接字
	if(listen(listenfd,SOMAXCONN)<0)//套接字变为被动套接字
		ERR_EXIT("listen");

	//epoll函数修改
	std::vector<int> clients;//存放已连接套接字
	int epollfd;//存放epoll实例
	epollfd = epoll_create1(EPOLL_CLOEXEC);//创建一个EPOLL实例

	//将感兴趣的事件加入到epoll队列
	struct epoll_event event;
	event.data.fd = listenfd;
	event.events = EPOLLIN | EPOLLET;//边沿触发
	epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event);

	EventList events(16);//存放并发事件

	//存放客户端地址
	struct sockaddr_in peeraddr;
	socklen_t peerlen;

	int conn;//接受accept的套接字
	
	int i;

	int nready;
	while(1)
	{//&*events.begin()动态数组首地址
		nready = epoll_wait(epollfd, &*events.begin(), static_cast<int>(events.size()), -1);

		//nready = poll(client，maxi+1, -1);
		//nready = select(maxfd+1, &rset, NULL,NULL, NULL);
		if(nready==-1)
		{
			if(errno == EINTR)
				continue;
			ERR_EXIT("epoll_wait");
		}
		if(nready==0)
			continue;
		//数组已满，等待的数已经满了，扩充数组
		if((size_t)nready == events.size())//等待的事件的个数
			events.resize(events.size()*2);

		//开始处理已检测到的事件
		for(i=0; i<nready; i++)
		{
			//处理监听套接口
			if(events[i].data.fd == listenfd)
			{
				peerlen = sizeof(peeraddr);
				conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);
				if(conn==-1)
				{
					ERR_EXIT("accept");
				}
				printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
				clients.push_back(conn);

				activate_nonblock(conn);

				//监听套接口变为已连接套接口，放入队列，进行管理，等待数据到来
				event.data.fd = conn;
				event.events = EPOLLIN | EPOLLET;
				epoll_ctl(epollfd, EPOLL_CTL_ADD, conn, &event);
			}
			else if(events[i].events & EPOLLIN)//已连接套接字
			{
				conn = events[i].data.fd;
				if(conn<0)
					continue;
				char recvbuf[1024] = {0};
				int ret = readline(conn, recvbuf, 1024);
				if(ret ==-1)
					ERR_EXIT("readline");
				if(ret ==0)
				{
					printf("client close\n");
					close(conn);

					event= events[i];
					epoll_ctl(epollfd, EPOLL_CTL_DEL, conn, &event);
					clients.erase(std::remove(clients.begin(), clients.end(), conn), clients.end());
				}
				fputs(recvbuf,stdout);//打印标准输出
				writen(conn,recvbuf, strlen(recvbuf));
			}
		}
	}
	return 0;
}

 

麻子来了
关注
专栏目录
socket编程：epoll多路复用
04-27 323
/* *url:http://www.cnblogs.com/yuuyuu/p/5103744.html * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <unistd.h> #incl...
IO多路复用机制——epoll
李小恩恩子的博客
07-21 3006
高效地对海量用户提供服务，必须要让进程能同时处理很多个tcp连接。假设一个进程保持了10000条连接，如何发现哪条连接上有数据可读、可写？实现循环遍历来发现IO事件？效率太低了。epoll的通俗解释，当文件描述符的内核缓冲区非空的时候，发出可读信号进行通知，当写缓冲区不满的时候，发出可写信号通知的机制。..................
socket网络编程（四）——epoll多路复用问题
一点
11-03 413
目录 1、epoll诞生的原因 2、epoll是什么 3、具体实现 3.1、服务端代码 3.2、客户端代码 4、epoll结构剖析 1、epoll诞生的原因 问大家一个问题，如果要设计一款有着千万级别并发的系统，你的客户端和服务端的网络通信底层该怎么设计？我在上一篇文章（计算机通信之谜，带你彻底理解socket网络编程（三））中有说到用select可以实现IO多路复用，但是select的设计有瓶颈所在，超过十万的并发效率就非常慢。那么着又该怎么办呢？ 于是epoll就腾空出世了！ 2
epoll详解（使用、原理、实验）
最新发布
Andrew_Chenwq的博客
09-03 1468
执行epoll_create时，创建了红黑树和就绪链表，执行epoll_ctl时，如果增加socket句柄，则检查在红黑树中是否存在，存在立即返回，不存在则添加到树干上，然后向内核注册回调函数，用于当中断事件来临时向准备就绪链表中插入数据。所以进程A被阻塞，不会往下执行代码，也不会占用cpu资源。epoll_wait在调用时，在给定的timeout时间内，当在监控的所有句柄中有事件发生时，就返回用户态的进程,不用传递socket句柄给内核，因为内核已经在epoll_ctl中拿到了要监控的句柄列表。
socket编程——epoll多路复用
ayaya的博客
03-31 390
一、前言 在学习epoll之前，我们已经学过select，poll了。那我们为什么不直接使用select、poll来实现并发服务器程序呢？我们先了解一下select和poll来编写服务器的缺点： 1.内核 / 用户空间内存拷贝问题，select和poll需要复制大量的句柄数据结构，产生巨大的开销。 2.select和poll返回的是含有整个句柄的数组，应用程序需要遍历整个数组才能发现哪些句柄发生了...
IO多路复用,以socket为例
a274521712的博客
05-12 283
import selectors #导入selectors模式,不同于select,它是基于select模块实现的IO多路复用,import socket #导入的模块,用于服务端与用户端的交互sock =socket.socket() #sock.bind(('127.0.0.1',8083)) #sock.listen(5)sock.setblocking(False)se...
图解 | 深入揭秘 epoll 是如何实现 IO 多路复用的！
zhangyanfei01的专栏
03-17 1615
点击上方蓝字"开发内功修炼"，关注并设为星标了解你的每一比特，用好你的每一纳秒进程在 Linux 上是一个开销不小的家伙，先不说创建，光是上下文切换一次就得几个微秒。所以为...
socket编程之epoll多路复用
我们的征途是星辰大海
08-01 1026
epoll的相关系统调用 1、int epoll_create(int size); 创建一个epoll描述符，该描述符占用一个fd值，程序退出前必须调用close()关闭，参数size为最大监听事件数 2、int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); epoll的事件注册函数，它不同于select(
网络编程 IO多路复用 [epoll版] (TCP网络聊天室)
Hellomino_的博客
07-30 1082
功能：创建一个epoll句柄//创建红黑树根节点 epoll把要监测的事件文件描述符挂载到红黑树上。timeout:超时检测 >0:毫秒级检测 ==0：立即返回 -1：不关心是否超时。EPOLL_CTL_MOD：修改epoll检测的事件类型。EPOLL_CTL_DEL：将文件描述符从epoll删除。EPOLL_CTL_ADD:添加要监测的事件文件描述符。>0:准备好的文件描述符的个数。返回值：成功返回根节点对应的文件描述符，失败返回-1。参数： epfd:epoll_create创建的句柄。
Linux IO多路复用之epoll网络编程
09-15
在Linux系统中，IO多路复用是一种高效的网络编程技术，它允许多个网络连接在同一时间进行处理，而不需要为每个连接创建单独的线程或进程。`epoll`是Linux内核提供的一种IO多路复用机制，特别适合于高并发、高性能的...
C++网络编程（五）：IO多路复用实现并发服务器
weixin_44164489的博客
10-05 2201
目录前置知识五种IO模型阻塞i/o非阻塞I/O模型I/O复用模型信号驱动I/O模型异步I/O模型五种I/O模型比较selectselect引入seclect应用实例POLLepoll总结select poll epoll区别参考资料 前置知识 1.Unix五种IO模型 [1] blocking IO - 阻塞IO [2] nonblocking IO - 非阻塞IO [3] IO multiplexing - IO多路复用 [4] signal driven IO - 信号驱动IO [5] asynchro
IO 多路复用，epoll 工作原理
身在边城 心在编程
02-26 523
IO多路转接模型 select poll epoll 对大量描述符进行事件监控，监控事件描述符是否 （可读，可写，异常） select 用户定义描述符的事件监控集合 fd_set,用户将需要监控的描述符添加到集合中 将集合拷贝到内核中进行监控，在内核中对所有描述符进行轮询遍历，判断是否有关心的事假就绪 假设有描述符就绪，从监控集合中，将未就绪的描述符移除，然后调用返回（返回给用户就绪描述符集合）...
python网络编程——IO多路复用之epoll
墨鱼菜鸡
07-11 558
来源：http://www.cnblogs.com/maociping/p/5132583.html 1、内核EPOLL模型讲解 此部分参考http://blog.csdn.net/mango_song/article/details/42643971博文并整理 首先我们来定义流的概念，一个流可以是文件，soc...
socket网络编程-epoll/select/poll
hdadiao的博客
03-02 202
epoll/select/poll epoll int epoll_create(int size);//这个参数被忽略，只要大于0就行了 int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event); int epoll_wait(int epfd, struct epoll_event* events, int maxev...
深入Socket网络编程与I/O多路复用
青玉白露的博客
10-07 496
进一步学习select、poll、epoll。 全文目录Socket网络编程I/O分类select/pollepoll读写就绪条件参考资料 Socket网络编程 学过计算机网络的同学应该都看得懂这幅图： 一个进程进行网络传输的过程可以分为两个阶段： 第一阶段：在用户态下，将需要用到的数据封装，调用相应的系统函数如write/read，陷入内核态； 第二阶段：在内核态下，内核根据拷贝至内核空间的数据依次运行TCP/IP协议栈，对应用数据进行封装（TCP/IP、IP、帧），而后将数据帧传给网卡，由网卡完.
I/O多路复用和Socket
SWhard的专栏
06-09 510
原文：I/O多路复用和Socket 由于IO操作涉及到系统调用，涉及到用户空间和内核空间的切换，所以理解系统的IO模型，对于需要进入到系统调用层面进行编程来说是很重要的。 阻塞IO和非阻塞IO 从程序编写的角度来看，I/O就是调用一个或多个系统函数，完成对输入输出设备的操作。输入输出设置可以是显示器、字符终端命令行、网络适配器、磁盘等。操作系统在这些设备与用户程序之间完成一个衔接，称为驱动程序，驱动程序向下驱动硬件，向上提供抽象的函数调用入口。 一般来说I/O操作是需要时间的，因为这涉及到系统、硬件
socket编程：多路复用I/O服务端客户端之epoll
weixin_34248849的博客
05-31 140
什么是epollepoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel2.5.44)，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。epoll的相...
【C语言】Linux Socket epoll多路复用
weixin_43757283的博客
07-28 865
文章目录前言一、epoll 多路复用是什么？二、epoll 函数解析1、epoll_create() 函数2、epoll_ctl() 函数3、epoll_wait() 函数三、具体代码四、运行效果总结 前言 前面谈完 poll 多路复用，这篇文章我们来聊聊 epoll 多路复用 在 Linux 没有实现 epoll 事件驱动机制之前，我们一般选择用 select 或者 poll 等 IO 多路复用的方法来实现并发服务程序。自 Linux 2.6 内核正式引入 epoll 以来，epoll 已经成为了目前
socket编程 - 演化过程之IO多路复用epoll原理
猛犸象
05-18 863
在学习socket编程之前，先要了解TCP通讯，因为我们常用的服务器都是基于TCP协议的。 关于TCP的详细解释 https://blog.csdn.net/raoxiaoya/article/details/106113128 epoll的实现原理： 创建监听fd => 3。 调用 epoll_create() 返回一个文件描述符 => 4，系统在内核空间开辟空间 Z 和 X，并都关联到 4fd。 调用 epoll_ctl(4fd,…) 将 3fd 加入到 Z 空间，监听3fd的EPOLL
Linux网络编程：IO多路复用——epoll
lichengyang的博客
08-23 50
【代码】Linux网络编程：IO多路复用——epoll。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值