提升文件IO性能的技巧

最新推荐文章于 2024-07-11 21:47:44 发布
最新推荐文章于 2024-07-11 21:47:44 发布
阅读量7 收藏
点赞数
分类专栏： 嵌入式Linux C/C++ 文章标签： windows 服务器 linux
原文链接：https://mp.weixin.qq.com/s/ABt0F0i5tXnnGEjLQSqe5w
版权

Linux下的AIO基本概念

在异步I/O中，你可以同时初始化多个I/O通道。这样每个I/O通道都需要保存一个唯一的上下文，以便于当I/O操作完成后你能够识别时哪一个I/O通道。在AIO中这个上下文就是aiocb(AIO I/O Control Block) 结构体。这个结构体保存了每个I/O通道的所有信息包括用于缓存数据的用户空间缓冲区。当I/O操作完成时，内核会提供这个I/O通道特定的aiocb结构体。

AIO模型

图片

异步IO则采用订阅-通知模式：即应用程序向操作系统注册IO监听，然后继续做自己的事情。当操作系统发生IO事件，并且准备好数据后，在主动通知应用程序，触发相应的函数。过程如下图所示：

图片

AIO的API

图片

上面的每个API函数都是通过aiocb结构体来初始化或者查询状态的。结构体struct aiocb如下所示：

图片

应用示例

aio_read.c 异步读操作

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<fcntl.h>
#include<aio.h>
  
#define BUFFER_SIZE 1024
 
int MAX_LIST = 2;
 
int main(int argc,char **argv)
{
    //aio操作所需结构体
    struct aiocb rd;
 
    int fd,ret,couter;
 
    fd = open("test.txt",O_RDONLY);
    if(fd < 0)
    {
        perror("test.txt");
    }
 
    //将rd结构体清空
    bzero(&rd,sizeof(rd));
 
    //为rd.aio_buf分配空间
    rd.aio_buf = malloc(BUFFER_SIZE + 1);
 
    //填充rd结构体
    rd.aio_fildes = fd;
    rd.aio_nbytes =  BUFFER_SIZE;
    rd.aio_offset = 0;
 
    //进行异步读操作
    ret = aio_read(&rd);
    if(ret < 0)
    {
        perror("aio_read");
        exit(1);
    }
    
    couter = 0;
    //  循环等待异步读操作结束
    while(aio_error(&rd) == EINPROGRESS)
    {
        printf("第%d次: %s\n",++couter, rd.aio_buf);
    }
    //获取异步读返回值
    ret = aio_return(&rd);
    
    printf("\n\n返回值为:%d",ret);
    return 0;
}

编译gcc -o aio_read aio_read.c -lrt

aio_write.c 异步写操作

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<fcntl.h>
#include<aio.h>
 
#define BUFFER_SIZE 1025
 
int main(int argc,char **argv)
{
    //定义aio控制块结构体
    struct aiocb wr;
 
    int ret,fd;
 
    char str[20] = {"hello,world"};
 
    //置零wr结构体
    bzero(&wr,sizeof(wr));
 
    //追加写
    fd = open("test.txt",O_WRONLY | O_APPEND);
    if(fd < 0)
    {
        perror("test.txt");
    }
 
    //为aio.buf申请空间
    wr.aio_buf = (char *)malloc(BUFFER_SIZE);
    if(wr.aio_buf == NULL)
    {
        perror("buf");
    }
 
    wr.aio_buf = str;
 
    //填充aiocb结构
    wr.aio_fildes = fd;
    wr.aio_nbytes = 1024;
 
    //异步写操作
    ret = aio_write(&wr);
    if(ret < 0)
    {
        perror("aio_write");
    }
 
    //等待异步写完成
    while(aio_error(&wr) == EINPROGRESS)
    {
        printf("hello,world\n");
    }
 
    //获得异步写的返回值
    ret = aio_return(&wr);
    printf("\n\n\n返回值为:%d\n",ret);
 }

编译gcc -o aio_write aio_write.c -lrt

aio_suspend.c 异步阻塞IO

aio_suspend 函数来挂起（或阻塞）调用进程，直到异步请求完成为止，此时会产生一个信号，或者发生其他超时操作。调用者提供了一个 aiocb 引用列表，其中任何一个完成都会导致 aio_suspend 返回

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<fcntl.h>
#include<aio.h> 
 
#define BUFFER_SIZE 1024
 
int MAX_LIST = 2;
 
int main(int argc,char **argv)
{
    //aio操作所需结构体
    struct aiocb rd;
 
    int fd,ret,couter;
 
    //cblist链表
    struct aiocb *aiocb_list[2];
 
    fd = open("test.txt",O_RDONLY);
    if(fd < 0)
    {
        perror("test.txt");
    }
 
    //将rd结构体清空
    bzero(&rd,sizeof(rd));
 
    //为rd.aio_buf分配空间
    rd.aio_buf = malloc(BUFFER_SIZE + 1);
 
    //填充rd结构体
    rd.aio_fildes = fd;
    rd.aio_nbytes =  BUFFER_SIZE;
    rd.aio_offset = 0;
 
    //将读fd的事件注册
    aiocb_list[0] = &rd;
 
    //进行异步读操作
    ret = aio_read(&rd);
    if(ret < 0)
    {
        perror("aio_read");
        exit(1);
    }
 
    couter = 0;
    //  循环等待异步读操作结束
    while(aio_error(&rd) == EINPROGRESS)
    {
        printf("第%d次， %s\n",++couter, rd.aio_buf);
    }
 
    printf("我要开始等待异步读事件完成\n");
    //阻塞等待异步读事件完成
    ret = aio_suspend(aiocb_list,MAX_LIST,NULL);
 
    //获取异步读返回值
    ret = aio_return(&rd);
 
    printf("\n\n返回值为:%d\n",ret);
 }

编译gcc -o aio_suspend aio_suspend.c -lrt

lio_listio 同时发起多个异步IO请求

意味着我们可以在一个系统调用（一次内核上下文切换）中启动大量的 I/O 操作。从性能的角度来看，这非常重要

int lio_listio(int mode, struct aiocb *const aiocb_list[],
                      int nitems, struct sigevent *sevp);

  • • 第一个参数 mode ：LIO_WAIT(阻塞直到所有的IO都完成) 或 LIO_NOWAIT(不阻塞，在进入排队 队列后就返回)

  • • 第二个参数 list ：异步IO请求队列．

  • • 第三个参数nitems ：异步IO请求队列长度

  • • 第四个参数sevp ：定义了在所有 I/O 操作都完成时产生信号的方法。

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<fcntl.h>
#include<aio.h>
 
#define BUFFER_SIZE 1025
 
int MAX_LIST = 2;
 
int main(int argc,char **argv)
{
    struct aiocb *listio[2];
    struct aiocb rd,wr;
    int fd,ret;
 
    //异步读事件
    fd = open("test1.txt",O_RDONLY);
    if(fd < 0)
    {
        perror("test1.txt");
    }
 
    bzero(&rd,sizeof(rd));
 
    rd.aio_buf = (char *)malloc(BUFFER_SIZE);
    if(rd.aio_buf == NULL)
    {
        perror("aio_buf");
    }
 
    rd.aio_fildes = fd;
    rd.aio_nbytes = 1024;
    rd.aio_offset = 0;
    rd.aio_lio_opcode = LIO_READ;   ///lio操作类型为异步读
 
    //将异步读事件添加到list中
    listio[0] = &rd;
 
    //异步些事件
    fd = open("test2.txt",O_WRONLY | O_APPEND);
    if(fd < 0)
    {
        perror("test2.txt");
    }
 
    bzero(&wr,sizeof(wr));
 
    wr.aio_buf = (char *)malloc(BUFFER_SIZE);
    if(wr.aio_buf == NULL)
    {
        perror("aio_buf");
    }
 
    wr.aio_fildes = fd;
    wr.aio_nbytes = 1024;
 
    wr.aio_lio_opcode = LIO_WRITE;   ///lio操作类型为异步写
 
    //将异步写事件添加到list中
    listio[1] = &wr;
 
    //使用lio_listio发起一系列请求
    ret = lio_listio(LIO_WAIT,listio,MAX_LIST,NULL);
 
    //当异步读写都完成时获取他们的返回值
 
    ret = aio_return(&rd);
    printf("\n读返回值:%d",ret);
 
    ret = aio_return(&wr);
    printf("\n写返回值:%d",ret);
 
    return 0;
}

编译gcc -o aio_suspend aio_suspend.c -lrt

AIO通知机制

异步与 同步的区别就是我们不需要等待异步操作返回就可以继续干其他的事情，当异步操作完成时可以通知我们去处理它。

主要有两种通知方式：

  • • 信号

  • • 函数回调

(1)信号通知
在发起异步请求时，可以指定当异步操作完成时给调用进程发送什么信号，这样调用收到此信号就会执行相应的信号处理函数．很明显，这是很不好的，因为在系统中可能会有很多很多信号,而且必须要注意的是在信号处理的时候一定不要有任何阻塞操作，不然就会导致整个进程阻塞（中断）

#include <aio.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>

#define BUFFER_SIZE 1024

// 定义信号处理函数
void aio_completion_handler(int signo, siginfo_t *info, void *context) {
    struct aiocb *req;
    int ret;

    if (info->si_code == SI_ASYNCIO) {
        req = (struct aiocb *)info->si_value.sival_ptr;

        // 检查I/O操作是否成功完成
        if ((ret = aio_error(req)) == 0) {
            // 获取返回值
            ret = aio_return(req);
            printf("AIO operation completed successfully, read %d bytes.\n", ret);
            printf("Data: %.*s\n", ret, (char *)req->aio_buf);
        } else {
            printf("AIO operation failed: %s\n", strerror(ret));
        }

        // 释放分配的缓冲区
        free((void *)req->aio_buf);
    }
}

int main() {
    int fd;
    struct aiocb cb;
    char *buffer;
    struct sigaction sa;

    fd = open("testfile.txt", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    // 分配缓冲区
    buffer = (char *)malloc(BUFFER_SIZE);
    if (!buffer) {
        perror("malloc");
        close(fd);
        return 1;
    }

    // 清零aiocb结构体
    memset(&cb, 0, sizeof(cb));
    cb.aio_fildes = fd;
    cb.aio_buf = buffer;
    cb.aio_nbytes = BUFFER_SIZE;
    cb.aio_offset = 0;

    // 设置信号处理函数
    sa.sa_flags = SA_SIGINFO;
    sa.sa_sigaction = aio_completion_handler;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGUSR1, &sa, NULL);

    // 设置通知方式为信号通知
    cb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
    cb.aio_sigevent.sigev_signo = SIGUSR1;
    cb.aio_sigevent.sigev_value.sival_ptr = &cb;

    // 发起异步读操作
    if (aio_read(&cb) == -1) {
        perror("aio_read");
        free(buffer);
        close(fd);
        return 1;
    }

    // 等待异步I/O操作完成
    while (aio_error(&cb) == EINPROGRESS) {
        // 做其他事情，异步I/O操作在后台进行
        usleep(10000); // 睡眠10毫秒
    }

    // 关闭文件描述符
    close(fd);
    return 0;
}

编译   gcc -o aio_sigaction aio_sigaction.c -lrt

(2)线程函数回调
顾名思义．．．就是我们经常写的回调函数（会另外开一个线程去处理，所以不会阻塞当前进程）

#include <aio.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>

#define BUFFER_SIZE 1024

// 定义回调函数
void aio_completion_handler(sigval_t sigval) {
    struct aiocb *req;
    int ret;

    req = (struct aiocb *)sigval.sival_ptr;

    // 检查I/O操作是否成功完成
    if ((ret = aio_error(req)) == 0) {
        // 获取返回值
        ret = aio_return(req);
        printf("AIO operation completed successfully, read %d bytes.\n", ret);
        printf("Data: %.*s\n", ret, (char *)req->aio_buf);
    } else {
        printf("AIO operation failed: %s\n", strerror(ret));
    }

    // 释放分配的缓冲区
    free((void *)req->aio_buf);
}

int main() {
    int fd;
    struct aiocb cb;
    char *buffer;

    fd = open("testfile.txt", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    // 分配缓冲区
    buffer = (char *)malloc(BUFFER_SIZE);
    if (!buffer) {
        perror("malloc");
        close(fd);
        return 1;
    }

    // 清零aiocb结构体
    memset(&cb, 0, sizeof(cb));
    cb.aio_fildes = fd;
    cb.aio_buf = buffer;
    cb.aio_nbytes = BUFFER_SIZE;
    cb.aio_offset = 0;

    // 设置通知方式为回调函数
    cb.aio_sigevent.sigev_notify = SIGEV_THREAD;
    cb.aio_sigevent.sigev_notify_function = aio_completion_handler;
    cb.aio_sigevent.sigev_notify_attributes = NULL;
    cb.aio_sigevent.sigev_value.sival_ptr = &cb;

    // 发起异步读操作
    if (aio_read(&cb) == -1) {
        perror("aio_read");
        free(buffer);
        close(fd);
        return 1;
    }

    // 等待异步I/O操作完成
    while (aio_error(&cb) == EINPROGRESS) {
        // 做其他事情，异步I/O操作在后台进行
        usleep(10000); // 睡眠10毫秒
    }

    // 关闭文件描述符
    close(fd);
    return 0;
}

总结

        Linux的异步I/O操作提供了一种高效的I/O处理机制，允许应用程序在不阻塞的情况下发起和处理I/O操作，使用异步 I/O 可以帮助我们构建 I/O 速度更快、效率更高的应用程序。如果我们的应用程序可以对处理和 I/O 操作重叠进行，那么 AIO 就可以帮助我们构建可以更高效地使用可用 CPU 资源的应用程序。尽管这种 I/O 模型与在大部分 Linux 应用程序中使用的传统阻塞模式都不同，但是异步通知模型在概念上来说却非常简单，可以简化我们的设计。

xiaosanxian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
6、文件IO
wuzhishiwo的博客
08-27 1130
一、什么是文件IO IO就是input/output，输入/输出。文件IO的意思就是读写文件。 二、文件操作的主要接口API open、close、write、read、lseek (1)API是一些函数，这些函数是由linux系统提供支持的，由应用层程序来使用。 (2)应用层程序通过调用API来调用操作系统中的各种功能，来干活。 1、文件操作的一般步骤 在linux系统中要操作一个文件，一般是先open打开一个文件，得到一个文件描述符，然后对文件进行读写操作（或其他操作），最后close关闭文件。
提升磁盘IO性能的几个技巧
dliang27的专栏
09-12 7843
提升磁盘IO性能的几个技巧 http://bbs.chinaunix.net/forum.php?mod=viewthread&tid=2312248&fromuid=20665047 目前磁盘都是机械方式运作的，主要体现在磁盘读写前寻找磁道的过程。磁盘自带的读写缓存大小，对于磁盘读写速度至关重要。读写速度快的磁盘，通常都带有较 大的读写缓存。磁盘的寻道过程是机械方式，决定了其随机读写速度
Java中的IO操作技巧与性能优化
技术研究中心
06-23 1043
通过本文，我们详细介绍了Java中的IO操作技巧与性能优化，包括文件IO、网络IO以及一些常见的性能优化技巧。掌握这些技巧可以帮助我们编写更加高效和稳定的IO操作代码，从而提升应用的整体性能和用户体验。
提升磁盘IO的性能的几个技巧
软件测试工程师
10-23 4730
目前磁盘都是机械方式运作的，主要体现在磁盘读写前寻找磁道的过程。磁盘自带的读写缓存大小，对于磁盘读写速度至关重要。读写速度快的磁盘，通常都带有较大的读写缓存。磁盘的寻道过程是机械方式，决定了其随机读写速度将明显低于顺序读写。   在我们做系统设计和实现时，需要考虑到磁盘的这一特性。FastDFS最初的实现，文件是按hash方式随机分布到多个目录中的，后来增加了顺序存放的做法。通过对比测试，发现文
提高io性能的技巧
piaoairy219的专栏
12-24 1040
1 合理设计你的文件粒度，太小的文件造成太多的磁盘随机读写，太大的文件会降低系统的可靠性，例如文件header损坏，你丢失的数据就更多 2 同上道理，慎用fseek，这也需要你合理设计你文件中的数据结构 3 采用合适的buf机制，你可以 read/write 无buf fread/fwrite 有buf，用setbuf/setvbuf增大buf可以增加效率，但它的作用不是无效发挥的，如果你
FastDFS ：提升磁盘IO性能的几个技巧
xiaofei0859的专栏
11-11 4076
目前磁盘都是机械方式运作的，主要体现在磁盘读写前寻找磁道的过程。磁盘自带的读写缓存大小，对于磁盘读写速度至关重要。读写速度快的磁盘，通常都带有较大的读写缓存。磁盘的寻道过程是机械方式，决定了其随机读写速度将明显低于顺序读写。在我们做系统设计和实现时，需要考虑到磁盘的这一特性。FastDFS最初的实现，文件是按hash方式随机分布到多个目录中的，后来增加了顺序存放的做法。通过对比测试，发现文件按目录
pytorch训练过程io性能加速技巧（ubuntu 22.04）
u011876981的博客
10-19 808
对于用于做深度学习的个人PC，很容易存在的一个问题，即重GPU，而忽略IO性能，导致输出延时过高，显卡吃不饱。这里总结一些小的技巧，帮助提升IO性能。
深入探讨Python中的文件操作与文件IO操作
一键难忘的博客
03-18 5426
在Python编程中，文件操作和文件IO操作是十分常见的任务。无论是读取数据、写入日志还是处理文件内容，都离不开文件操作的支持。本文将深入探讨Python中文件操作和文件IO操作的各种技术细节，为读者提供全面的理解和实践指南。
使用Tomcat Native提升Tomcat IO效率
热门推荐
程序那些事
12-11 1万+
IO有很多种，从最开始的Block IO，到nonblocking IO，再到IO多路复用和异步IO，一步一步的将IO的性能提升做到极致。 今天我们要介绍一下怎么使用Tomcat Native来提升Tomcat IO的效率。
FastDFS（提升磁盘IO性能的几个技巧& FastDFS 5.04之IO读事件）
荒野求生的博客
09-14 986
提升磁盘IO性能的几个技巧 https://www.cnblogs.com/derekchen/archive/2012/04/04/2431573.html 目前磁盘都是机械方式运作的，主要体现在磁盘读写前寻找磁道的过程。磁盘自带的读写缓存大小，对于磁盘读写速度至关重要。读写速度快的 磁盘，通常都带有较大的读写缓存。磁盘的寻道过程是机械方式，决定了其随机读写速度将明显低于顺序读写。在我们做系统设计和实现时，需要考虑到磁盘的这一 特性。 　　FastDFS是一个开源的高效分布式文件系统，它最...
YUV视频文件IO
01-15
以下是关于YUV视频文件IO的一些关键知识点： 1. **文件打开**：使用编程语言如C++或Python，我们可以调用特定的库函数来打开YUV文件，例如`fopen()`（C++）或`open()`（Python）。打开文件时，需要指定文件路径和...
分享提高ASP.NET Web应用性能的技巧
10-22
以下是一些关键的技巧，可以帮助提升ASP.NET Web应用的性能： 1. **禁用Debug模式**：在开发完成后，务必在`web.config`文件中将`<compilation>`元素的`debug`属性设置为`false`。这将禁止编译时的详细信息输出，...
提升你的Java应用性能改善数据处理Java开发Java经
11-22
避免不必要的文件读写，使用流式处理，以及合理配置缓冲区大小，都能提升IO性能。 7. **设计模式**：良好的设计模式可以帮助编写出易于维护且性能优秀的代码。例如，单例模式可以避免频繁创建对象，工厂模式可以...
Factory IO.rar
07-18
在压缩包"Factory IO.rar"中，包含了完整的Factory IO软件安装文件，用户只需解压并按照指导进行安装，即可开始探索这个充满无限可能的虚拟工厂世界。不论是自学提升，还是项目实践，Factory IO都将是你不可或缺的...
Java编程性能优化技巧有哪些共7页.pdf.zip
10-29
这份名为"Java编程性能优化技巧有哪些共7页.pdf.zip"的压缩文件很可能包含了关于Java性能优化的精华内容，尽管实际的文件列表中仅提及了"赚钱项目"，但我们可以通过对Java性能优化的一般性理解和实践来探讨相关知识...
Python中的null是什么？
最新发布
分享Python、数据分析、人工智能前沿知识
07-11 136
null正确的发音是/n^l/，有点类似四声‘纳儿’，在计算机中null是一种类型，代表空字符，没有与任何一个值绑定并且存储空间也没有存储值。检查 None 的唯一性，它返回某一对象的唯一标识符，如果两个变量的 id 相同，那么它们实际上指向的是同一个对象。Python中其实没有null这个词，取而代之的是None对象，即特殊类型NoneType，代表空、没有。在Python中，None的用处有很多，比如作为变量初始值、作为函数默认参数、作为空值等等。总得来说，None是一个对象，而null是一个类型。
[AHK V2]AHK能取消正常窗口的双击标题栏最大化事件吗？
liuyukuan的专栏
07-08 192
这段脚本首先定义了消息拦截，然后创建了一个函数OnNcLbuttonDblclk 来处理WM_ NCLBUTTONDBLCLK事件。当双击标题栏时，这个函数会被调用，并且通过返回0来阻止窗口最大化的默认行为。AutoHotkey (AHK)是一个强大的脚本语言，可以用来自定义键盘快捷键、鼠标操作等。如果你想阻止双击Windows标题栏进行最大化操作，你可以编写一个脚本来拦截这个动作。请注意，这个脚本需要在AutoHotkey中运行，并且可能需要根据你的具体需求进行调整。
list的模拟实现
Liufan____的博客
07-11 330
首先，C++中用struct定义是可不加struct，重点是这里用了一个类模板，类模板的类名不是真正的类型且类模板不支持自动推类型，即_list_node不是真正的类型，定义变量时，_list_node<T>这种才是真正的类型，也就是用类模板定义变量时必须指定对应的类型。注：结构体模板或类模板在定义时可不加<T>,但使用时必须加<T>。
LeetCode LCR027.回文链表 C写法
m0_63816268的博客
07-11 188
通过快慢指针找到中间结点，再将中间结点后的所有结点反转。如果是回文链表那么中间结点往后的值与头结点到中间结点的值都相等，如果有不相等的就不是回文链表。
io知识和系统性能深度调优全解(第2版)
08-07
《io知识和系统性能深度调优全解(第2版)》是一本关于输入/输出（IO）知识和系统性能优化的书籍...读者可以通过学习和应用书中的知识和技巧，提高系统的IO性能，使系统能够更高效地处理IO操作，进而提升系统的整体性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值