搭建一个后台服务器--服务端（异步，大并发）

最新推荐文章于 2019-02-27 02:11:05 发布
最新推荐文章于 2019-02-27 02:11:05 发布
阅读量1.1k 收藏
点赞数
分类专栏： Linux

本文转自：http://blog.csdn.net/xiaofei_hah0000/article/details/8743627

阻塞模式下服务器的并发只有几K，而真正的server 像nginx, apache, yumeiz 轻轻松松处理几万个并发完全不在话下，因此大并发的场合下是不能用阻塞的。

1W的并发是一个分隔点，如果单进程模型下能达到 的话，说明至少在服务器这块你已经很厉害了。

服务器开发就像一门气功，能不能搞出大并发，容错性处理得怎么样，就是你有没有内功，内功有多深。


异步模式是专门为大并发而生，linux下一般用 epoll 来管理事件，下面就开始我们的异步大并发服务器实战吧。

跟阻塞开发一样，先来看看设计过程：

1.创建事件模型。

2.创建监听连接并监听。

3.将监听连接加入事件模型。

4.当有事件时，判断事件类型。

5.若事件为监听连接，则产生客户连接同时加入事件模型，对客户连接接收发送。

6.若事件为客户连接，处理相应IO请求。


为了让大家一概全貌，我用一个函数实现的( 一个函数写一个2W并发的服务器，你试过么），可读性可能会差点，但是对付这道面试题是绰绰有余了。

实际开发过程如下：

先定义一个事件结构，用于对客户连接进行缓存

[cpp]  view plain copy
  1. struct my_event_s {
  2.     int fd;  
  3.     char recv[64];  
  4.     char send[64];  
  5.   
  6.     int rc_pos;  
  7.     int sd_pos;  
  8. };  

建立缓存对象：

[cpp]  view plain copy
  1. struct epoll_event wait_events[EPOLL_MAX];  
  2. struct my_event_s my_event[EPOLL_MAX];  

创建监听连接：

[cpp]  view plain copy
  1. sock_server = socket(AF_INET, SOCK_STREAM, 0);  
  2. flag = fcntl(sock_server, F_GETFL, 0);  
  3. fcntl(sock_server, F_SETFL, flag | O_NONBLOCK); /* 设定为监听套接口为非阻塞 */ 

绑定地址并监听：

[cpp]  view plain copy
  1. flag = bind(sock_server, (struct sockaddr *)&addr_server, sizeof(struct sockaddr));  
  2. if (flag < 0) {  
  3.     printf("your bind is not ok\n");  
  4.     close(sock_server);  
  5.     return 0;  
  6. }  
  7.   
  8. flag = listen(sock_server, 1024);  
  9. if (flag < 0) {  
  10.     printf("your listen is not ok\n");  
  11.     close(sock_server);  
  12.     return 0;  
  13. }
创建事件模型：
[cpp]  view plain copy
  1. epfd = epoll_create(EPOLL_MAX);  
  2. if (epfd <= 0) {  
  3.     printf("event module could not be setup\n");  
  4.     close(sock_server);  
  5.     return 0;  
  6. }  
将监听事件加入事件模型：
[cpp]  view plain copy
  1. tobe_event.events = EPOLLIN;  
  2. tobe_event.data.fd = sock_server;  
  3. epoll_ctl(epfd, EPOLL_CTL_ADD, sock_server, &tobe_event);  

事件模型处理：

[cpp]  view plain copy
  1. e_num = epoll_wait(epfd, wait_events, EPOLL_MAX, WAIT_TIME_OUT);  
  2. if (e_num <= 0) {  
  3.     continue;
  4. }
  5. for (i = 0; i < e_num; ++i) {
监听处理：
[cpp]  view plain copy
  1. if (sock_server == wait_events[i].data.fd) {
  2.     while (1) {

连接客户端：

[cpp]  view plain copy
  1. sock_client = accept(sock_server, (struct sockaddr *)&addr_client, (socklen_t *)&size);
  2. if (sock_client < 0) {
  3.     if (errno == EAGAIN) {  
  4.         break;
  5.     }
  6.     if (errno == EINTR) {
  7.         continue;  
  8.     }
  9.     break;
  10. }
将客户端连接设置为异步：
[cpp]  view plain copy
  1. flag = fcntl(sock_client, F_GETFL, 0);
  2. fcntl(sock_client, F_SETFL, flag | O_NONBLOCK);
将客户端连接加入到事件模型：
[cpp]  view plain copy
  1. tobe_event.events = EPOLLIN | EPOLLET; 
  2. tobe_event.data.u32 = my_empty_index;
  3. epoll_ctl(epfd, EPOLL_CTL_ADD, sock_client, &tobe_event);  
统计每秒并发数并得到系统当前时间：
[cpp]  view plain copy
  1. ++num;
  2. current = time(0);
  3. if (current > last) {
  4.     printf("last sec qps:%d\n", num);  
  5.     num = 0;
  6.     last = current;
  7. }
将时间填充到连接缓存中：
[cpp]  view plain copy
  1. memcpy(tobe_myevent->send, ¤t, sizeof(time_t));  

接收连接内容：

[cpp]  view plain copy
  1. flag = recv(sock_client, tobe_myevent->recv, 64, 0);  
  2. if (flag < 64) {
  3.     if (flag > 0) {
  4.         tobe_myevent->rc_pos += flag;
  5.     }
  6.     continue;
  7. }

[cpp]  view plain copy
  1. if (tobe_myevent->recv[31] || tobe_myevent->recv[63]) {  
  2.     printf("your recv does follow the protocal\n");  
  3.     tobe_myevent->fd = 0;  
  4.     close(sock_client);  
  5.     continue;  
  6. }

  8. flag = send(sock_client, tobe_myevent->send, sizeof(time_t), 0);  
  9. if (flag < sizeof(time_t)) {
  10. <span style="white-space:pre">  </span>tobe_event.events =  EPOLLET | EPOLLOUT;  
  11. <span style="white-space:pre">  </span>epoll_ctl( epfd, EPOLL_CTL_MOD, sock_client, &tobe_event );  
  12.     if( flag > 0 )  
  13.         tobe_myevent->sd_pos += flag;  
  14.     continue;  
  15. }  
  16. tobe_myevent->fd = 0;  
  17. close( sock_client );  

后面进行普通连接事件处理，错误处理：

[cpp]  view plain copy
  1. if (event_flag | EPOLLHUP) {  
  2.     tobe_myevent->fd = 0;  
  3.     close( sock_client );  
  4.     continue;  
  5. } else if (event_flag | EPOLLERR) {  
  6.     tobe_myevent->fd = 0;  
  7.     close( sock_client );  
  8.     continue;  
  9. }
写事件：
[cpp]  view plain copy
  1. else if (event_flag | EPOLLOUT) {  
  2.     if (tobe_myevent->rc_pos != 64) {  
  3.         continue;  
  4.     }  
  5.   
  6.     if (tobe_myevent->sd_pos >= sizeof(time_t)) {  
  7.         tobe_myevent->fd = 0;  
  8.         close( sock_client );  
  9.         continue;  
  10.     }
  11.   
  12.     flag = send(sock_client, tobe_myevent->send 
  13.                 + tobe_myevent->sd_pos, sizeof(time_t) - tobe_myevent->sd_pos, 0);
  14.     if (flag < 0) {  
  15.         if (errno == EAGAIN) {  
  16.             continue;  
  17.         } else if (errno == EINTR) {  
  18.             continue;  
  19.         }
  20.         tobe_myevent->fd = 0;  
  21.         close(sock_client);  
  22.         continue;  
  23.     }
  24.   
  25.     if (flag > 0) {  
  26.         tobe_myevent->sd_pos += flag;  
  27.         if (tobe_myevent->sd_pos >= sizeof(time_t)) {  
  28.             tobe_myevent->fd = 0;  
  29.             close(sock_client);  
  30.             continue;  
  31.         }
  32.     }
  33. }
读事件：
[cpp]  view plain copy
  1. if (event_flag | EPOLLIN) {  
  2.     if (tobe_myevent->rc_pos < 64) {  
  3.         flag = recv(sock_client, tobe_myevent->recv 
  4.                     + tobe_myevent->rc_pos, 64 - tobe_myevent->rc_pos, 0);
  5.         if (flag <= 0) {
  6.             continue;  
  7.         }

  9.         tobe_myevent->rc_pos += flag;  
  10.   
  11.         if (tobe_myevent->rc_pos < 64) {
  12.             continue;
  13.         }
  14.   
  15.         if (tobe_myevent->recv[31] || tobe_myevent->recv[63]) {
  16.             printf( "your recv does follow the protocal\n");
  17.             tobe_myevent->fd = 0;
  18.             close(sock_client);  
  19.             continue;  
  20.         }
  21.   
  22.         flag = send(sock_client, tobe_myevent->send, sizeof(time_t), 0);
  23.         if (flag < sizeof(time_t)) {
  24.             if (flag > 0)
  25.                 tobe_myevent->sd_pos += flag;  
  26.         <span style="white-space:pre">  </span>tobe_event.events = EPOLLET | EPOLLOUT;  
  27.             tobe_event.data.u32 = wait_events[i].data.u32;  
  28.             epoll_ctl(epfd, EPOLL_CTL_MOD, sock_client, &tobe_event);  
  29.             continue;  
  30.         }  
  31.         tobe_myevent->fd = 0;  
  32.         close(sock_client);  
  33.     }  
  34.   
  35. } 
  36.     

到此，一个异步服务器搭建完毕，轻松实现2W的并发量，代码你可以在这里下载，下一篇是完整的代码，满足喜欢在网上看代码的码狂们。。。


完整代码如下：

#include <stdio.h>
#include <time.h>
#include <fcntl.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>


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

struct my_event_s {
    int fd;
    char recv[64];
    char send[64];
    int rc_pos;
    int sd_pos;
};

int main(int argc, char *argv[]) {
    int port;
    int flag;
    int size;
    int sock_server;
    int sock_client;
    time_t current;
    time_t last;
    int num;
    int e_num;
    int my_empty_index;
    int i,j;
    int event_flag;
    #define EPOLL_MAX 51200
    struct epoll_event wait_events[EPOLL_MAX];
    struct my_event_s my_event[EPOLL_MAX];
    struct my_event_s* tobe_myevent;
    struct epoll_event tobe_event;
    int epfd;

    #define RECV_BUF_LEN 256
    char buffer[RECV_BUF_LEN];

    struct sockaddr_in addr_server;
    struct sockaddr_in addr_client;

    if (argc <= 1) {
        printf("please set your port\n");
        return 0;
    }

    printf("your port:%s\n", argv[1]);
    port = atoi(argv[1]);

    addr_server.sin_family = AF_INET;
    addr_server.sin_port = htons(port);
    addr_server.sin_addr.s_addr = htonl(INADDR_ANY);

    sock_server = socket(AF_INET, SOCK_STREAM, 0);
    flag = fcntl(sock_server, F_GETFL, 0);
    fcntl(sock_server, F_SETFL, flag | O_NONBLOCK);

    flag = bind(sock_server, (struct sockaddr *)&addr_server, sizeof(struct sockaddr));
    if (flag < 0) {
        printf("your bind is not ok\n");
        close(sock_server);
        return 0;
    }

    flag = listen(sock_server, 1024);
    if (flag < 0) {
        printf("your listen is not ok\n");
        close(sock_server);
        return 0;
    }

    epfd = epoll_create(EPOLL_MAX);
    if (epfd <= 0) {
        printf("event module could not be setup\n");
        close(sock_server);
        return 0;
    }

    tobe_event.events = EPOLLIN;
    tobe_event.data.fd = sock_server;

    epoll_ctl(epfd, EPOLL_CTL_ADD, sock_server, &tobe_event);

    size = sizeof(addr_client);
    num = 0;
    last = 0;
    my_empty_index = 0;

    while (1) {
#define WAIT_TIME_OUT 600
        e_num = epoll_wait(epfd, wait_events, EPOLL_MAX, WAIT_TIME_OUT);
        if (e_num <= 0) {
            continue;
        }

        for (i = 0; i < e_num; ++i) {
            if (sock_server == wait_events[i].data.fd) {
                while (1) {
                    sock_client = accept(sock_server, (struct sockaddr *)&addr_client, (socklen_t *)&size);
                    if (sock_client < 0) {
                        if (errno == EAGAIN) {
    break;
                        }
                        if (errno == EINTR) {
                            continue;
                        }
                        break;
                    }

                    tobe_myevent = my_event + my_empty_index;
                    memset(tobe_myevent, 0, sizeof(struct my_event_s));
                    tobe_myevent->fd = sock_client;

                    flag = fcntl(sock_client, F_GETFL, 0);
                    fcntl(sock_client, F_SETFL, flag | O_NONBLOCK);

                    tobe_event.events = EPOLLIN | EPOLLET;
                    tobe_event.data.u32 = my_empty_index;

                    epoll_ctl(epfd, EPOLL_CTL_ADD, sock_client, &tobe_event);

                    for(j = my_empty_index + 1; j < EPOLL_MAX; ++j) {
                        if (!my_event[j].fd) {
                            my_empty_index = j;
                            break;
                        }
                    }

                    if (my_event[j].fd) {
                        for (j = 0; j < EPOLL_MAX; ++j) {
                            if (!my_event[j].fd) {
                                my_empty_index = j;
                                break;
                            }
                        }

                        if (my_event[j].fd) {
                            printf("your events has been none else\n");
                            close(sock_client);
                            close(sock_server);
                            return 0;
                        }
                    }

                    ++num;
                    current = time(0);
                    if (current > last) {
                        printf("last sec qps:%d\n", num);
                        num = 0;
                        last = current;
                    }

                    memcpy(tobe_myevent->send, ¤t, sizeof(time_t));

                    flag = recv(sock_client, tobe_myevent->recv, 64, 0 );
                    if (flag < 64) {
                        if (flag > 0)
                            tobe_myevent->rc_pos += flag;
                        continue;
                    }

                    if (tobe_myevent->recv[31] || tobe_myevent->recv[63]) {
                        printf("your recv does follow the protocal\n");
                        tobe_myevent->fd = 0;
                        close(sock_client);
                        continue;
                    }

                    flag = send(sock_client, tobe_myevent->send, sizeof(time_t), 0);
                    if (flag < sizeof(time_t)) {
                        tobe_event.events =  EPOLLET | EPOLLOUT;
                        epoll_ctl(epfd, EPOLL_CTL_MOD, sock_client, &tobe_event);
                        if (flag > 0)
                            tobe_myevent->sd_pos += flag;
                        continue;
                    }
                    tobe_myevent->fd = 0;
                    close(sock_client);
                }
            } else {
                tobe_myevent = my_event + wait_events[i].data.u32;
                sock_client = tobe_myevent->fd;
                event_flag = wait_events[i].events;

                if (event_flag | EPOLLHUP) {
                    tobe_myevent->fd = 0;
                    close(sock_client);
                    continue;
                } else if( event_flag | EPOLLERR) {
                    tobe_myevent->fd = 0;
                    close(sock_client);
                    continue;
                } else if (event_flag | EPOLLOUT) {
                    if (tobe_myevent->rc_pos != 64) {
                        continue;
                    }


                    if (tobe_myevent->sd_pos >= sizeof(time_t)) {
                        tobe_myevent->fd = 0;
                        close(sock_client);
                        continue;
                    }


                    flag = send(sock_client, tobe_myevent->send + tobe_myevent->sd_pos, sizeof(time_t) - tobe_myevent->sd_pos, 0);
                    if (flag < 0) {
                        if (errno == EAGAIN) {
                            continue;
                        } else if( errno == EINTR) {
                            continue;
                        }
                        tobe_myevent->fd = 0;
                        close(sock_client);
                        continue;
                    }

                    if (flag > 0) {
                        tobe_myevent->sd_pos += flag;
                        if (tobe_myevent->sd_pos >= sizeof(time_t)) {
                            tobe_myevent->fd = 0;
                            close(sock_client);
                            continue;
                        }
                    }
                }
                if (event_flag | EPOLLIN) {
                    if (tobe_myevent->rc_pos < 64) {
                        flag = recv(sock_client, tobe_myevent->recv + tobe_myevent->rc_pos, 64 - tobe_myevent->rc_pos, 0);
                        if (flag <= 0) {
                            continue;
                        }

                        tobe_myevent->rc_pos += flag;

                        if (tobe_myevent->rc_pos < 64) {
                            continue;
                        }

                        if (tobe_myevent->recv[31] || tobe_myevent->recv[63]) {
                            printf("your recv does follow the protocal\n");
                            tobe_myevent->fd = 0;
                            close(sock_client);
                            continue;
                        }

                        flag = send(sock_client, tobe_myevent->send, sizeof(time_t), 0);
                        if (flag < sizeof(time_t)) {
                            if (flag > 0)
                                tobe_myevent->sd_pos += flag;
                            tobe_event.events = EPOLLET | EPOLLOUT;
                            tobe_event.data.u32 = wait_events[i].data.u32;
                            epoll_ctl(epfd, EPOLL_CTL_MOD, sock_client, &tobe_event);
                            continue;
                        }
                        tobe_myevent->fd = 0;
                        close(sock_client);
                    }
                }
            }
        }
    }
    printf("close server connection\n");
    close(sock_server);
    return 0;
}

暴走的小绵羊
关注
专栏目录
Nginx----高性能的WEB服务端(一)
AH99999的博客
02-22 1510
1、编译安装 2、平滑升级 3、location 4、优先级 5、验证模块 6、页面配置
1、搭建一个后台服务器--引子
Super的博客
10-26 1015
最近去了几家公司面试，有一些大公司（比如企鹅）的考核内容真心弱智，考的都是些算法，尼玛，拿一个刚毕业的学生来做说不定也可以过的，看来本来就不是在招搞服务器的，举个例子，企鹅多个部门都曾出的一道题：如何知道集合A,B中的相关性。 意思就是哪些元素在A,B之中都有，哪些元素在A,B中不都出现。其实解法很简单，学过算法的完全可以做到 。我们知道集合具有互异性，就是集合中的元素只能出现一次，可以建一个ma
搭建一个后台服务器--服务端（阻塞）
xiaofei chain
03-31 3844
为什么 要在标题后面加个“阻塞”呢，因为系统为了增大并发，减小等待（阻塞），建立了另一种事件模式，后文将介绍，这里只介绍阻塞的模型。 阻塞服务器要干的事大致可以分为以下几步： 1.创建服务端监听连接 2.产生用户连接 3.接收用户请求 4.发送返回给用户 敲码过程如下： 设置监听地址与端口： addr_server.sin_family = AF_INET; add
高性能异步Socket服务器（UDP）
hsicool的专栏
09-24 3063
转载自：点击打开链接 稍作修改 采用异步模式设计的UDP服务器，源码如下： using System; using System.Net; using System.Net.Sockets; using System.Threading; using System.IO; namespace TestUDPServer { public abstract class U
设计模式之回调模式
每天进步一点点
05-26 8909
回调在Spring中被大量使用，那什么是回调呢?        简单的说，在A类中调用B类的C方法，然后B类调用A类中的D方法。方法D被称为回调方法。回调是实现异步的基础。经典的回调方式如下： Class A实现回调接口CallBack——背景1 class A中包含一个class B的引用b ——背景2 class B有一个参数为callback的方法f(CallBack callback) —
C++从零开始搭建一个web服务器
03-21
Linux下基于C++的轻量级Web服务器； （1）使用 线程池 + 非阻塞socket + epoll(ET和LT均实现) + 事件处理(Reactor、Proactor) 的并发模型； ... （3）访问服务器数据库...（4）实现同步/异步日志系统，记录服务器运行状态
node-sever：后台管理系统服务端
02-25
"node-sever"项目很显然就是利用Node.js构建的一个后台管理系统服务端，这通常涉及到Web应用程序的后端开发。下面将详细讨论相关知识点。 1. **Node.js基础**： Node.js以其非阻塞I/O模型和事件驱动机制而闻名，这...
droiyan源码-决战服务端源码
06-09
总结，"droiyan源码-决战服务端源码"为我们提供了一个宝贵的实战案例，通过学习和研究，我们可以提升自己的编程技能，理解游戏服务端的设计思路，并为未来的开发工作积累经验。无论是对游戏开发爱好者还是专业开发者...
搭建微信小程序服务 - 开发者实验室 - 腾讯云
06-26
Node.js是一个基于Chrome V8引擎的JavaScript运行环境，它让开发者可以用JavaScript编写服务器端程序。Node.js的特点是异步非阻塞I/O，这使得它在处理高并发请求时表现优秀，非常适合构建实时通信的后端服务。 在...
搭建深度学习后台服务器
qq_38957170的博客
09-24 6548
      本篇文章的原创为国外的一篇文章(一个可扩展的Keras深度学习REST API)，链接为： https://www.pyimagesearch.com/2018/01/29/scalable-keras-deep-learning-rest-api/# 我们的Keras深度学习REST API将能够批量处理图像，扩展到多台机器(包括多台web服务器和Redis实例)，并在负载...
Web 端异步下载文件
weixin_30765505的博客
07-23 294
Web 端异步下载文件 实现文件异步下载； 在服务端无法返回文件，或发生异常时给予提示。 JavaScript： 服务端返回的JSON对象形如: { code:200, msg:'下载成功|未找到指定文件', filePath:'/file/test.txt' } function downloadFile() { ...
C#NetworkStream Read Write问题
coyote的专栏
07-30 1万+
最近做一个网络传输相关的项目，其中涉及到NetworkStream，但是遇到了一些问题，写下来以供后来人参考，免走弯路。 1、NetworkStream Write       NetworkStream netStream; byte[] data = new byte[dataLength]; netStream.Write(data, 0, dataLength); 其中，data
搭建一个后台服务器
chenglinhust的专栏
05-29 4794
搭建一个后台服务器 参考来源：http://blog.csdn.net/column/details/yumeiz.html 一. 需求        原题：时间同步系统开发需求 需求场景：客户端向服务器发起登录请求，鉴权通过后（为了简化工作，所有登录请求，只要请求参数里的用户名和密码不为空，都鉴权通过），客户端再向服务器请求当前系统时间，服务器返回当前系
搭建一个简单的服务器
lintax的专栏
03-19 2万+
做Android开发有一段时间了，经常与后台服务器进行交互，有时就会想，后台服务器到底是怎么工作的呢？我发出去一个http请求，他怎么接收到，又怎么进行处理、返回信息呢？ 本文描述了搭建一个简单静态服务器的方法，以及使用servlet+tomcat搭建一个动态服务器的方法。
从零开始搭建一个简易的服务器（一）
热门推荐
wierton的博客
08-30 3万+
从零开始搭建一个简易的服务器（一）前言其实大家大可不必被服务器这三个字吓到，一个入门级后端框架，所需的仅仅是HTTP相关的知识与应用这些知识的编程工具。据本人的经验，绝大多数人拥有搭建后端所涉及到的基础理论知识，但是缺乏能将之应用出去的工具，而本文即是交给读者这样一个工具，并能够运用之来实现一个可用的后端。本文以基础理论知识的运用为主，并不会在服务器的稳定性安全性上做探究，同时为了避免大家在实现中被
设计模式： 回调模式，剖析与深入探讨····
Jaylon Wang的专栏
11-02 796
  一 回调模式（CallBack）     1 类A持有一个类B的一个引用，类A并且实现了一个接口CallBack     2 类B有一个方法f，接收一个参数callBack，参数类型为CallBack，在方法f中调用了callBack的方法     下面是一个小例子：   /*** * @author Jaylon Huang * @date 2018/11/2 11:0...
Java服务端开发异步化实践的一点小结
weixin_34007020的博客
02-27 682
一、背景随着Java 9、Spring 5以及Spring Boot 2对于响应式编程（Reactive Stack）的支持，Reactor模式也日渐趋于流行，虽然当前并未在业界全面落地应用，但随着Java 8函数式编程、Lambda表达式、Stream数据流式处理的深入人心，加之Spring框架对于事件驱动模型的有力支持，日后响应式编程的全面落地当只是时间问题。而响应式编程的一个很重要的特性就是...
Vue + Element-UI实现的后台管理系统实战
node-elm可能是一个使用Node.js框架搭建的服务端项目，Node.js使用JavaScript作为服务端的开发语言，可以构建高性能的网络应用。 - **异步非阻塞I/O**：Node.js的特点是采用事件驱动、非阻塞I/O模型，使得它在处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值