iopp替换iotop工具

最新推荐文章于 2025-08-22 17:43:36 发布
转载 最新推荐文章于 2025-08-22 17:43:36 发布 · 158 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/zhangxc73912/blog/755183
文章标签：

#git #python

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

复制下面代码 iopp.cc

然后放到服务器上，gcc -o iopp iopp.c 编译一下

运行  ./iopp -i -k -c 1 > io.log 这个命令就可以把实时的io信息打印出来啦

打印出来的各项含义：

  • pid 进程ID
  • rchar 将要从磁盘读取的字节数
  • wchar 已经写入或应该要写入磁盘的字节数
  • syscr 读I/O数
  • syscw 写I/O数
  • rbytes 真正从磁盘读取的字节数
  • wbytes 真正写入到磁盘的字节数
  • cwbytes 因为清空页面缓存而导致没有发生操作的字节数
  • command 执行的命令

代码如下：

#include <stdio.h>  
#include <sys/types.h>  
#include <dirent.h>  
#include <ctype.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
#include <unistd.h>  
#include <string.h>  
#include <stdlib.h>  
#include <getopt.h>  
   
#define PROC "/proc"  
   
#define GET_VALUE(v) \  
        p = strchr(p, ':'); \  
        ++p; \  
        ++p; \  
        q = strchr(p, '\n'); \  
        length = q - p; \  
        if (length >= BUFFERLEN) \  
        { \  
            printf("ERROR - value is larger than the buffer: %d\n", __LINE__); \  
            exit(1); \  
        } \  
        strncpy(value, p, length); \  
        value[length] = '\0'; \  
        v = atoll(value);  
   
#define BTOKB(b) b >> 10  
#define BTOMB(b) b >> 20  
   
#define BUFFERLEN 255  
#define COMMANDLEN 1024  
#define VALUELEN 63  
   
#define NUM_STRINGS 8  
   
struct io_node  
{  
    int pid;  
    long long rchar;  
    long long wchar;  
    long long syscr;  
    long long syscw;  
    long long read_bytes;  
    long long write_bytes;  
    long long cancelled_write_bytes;  
    char command[COMMANDLEN + 1];  
    struct io_node *next;  
};  
   
struct io_node *head = NULL;  
int command_flag = 0;  
int idle_flag = 0;  
int mb_flag = 0;  
int kb_flag = 0;  
int hr_flag = 0;  
   
/* Prototypes */  
char *format_b(long long);  
struct io_node *get_ion(int);  
struct io_node *new_ion(char *);  
void upsert_data(struct io_node *);  
   
char *  
format_b(long long amt)  
{  
    static char retarray[NUM_STRINGS][16];  
    static int  index = 0;  
    register char *ret;  
    register char tag = 'B';  
   
    ret = retarray[index];  
    index = (index + 1) % NUM_STRINGS;  
   
    if (amt >= 10000) {  
        amt = (amt + 512) / 1024;  
        tag = 'K';  
        if (amt >= 10000) {  
            amt = (amt + 512) / 1024;  
            tag = 'B';  
            if (amt >= 10000) {  
                amt = (amt + 512) / 1024;  
                tag = 'G';  
            }  
        }  
    }  
   
    snprintf(ret, sizeof(retarray[index]) - 1, "%lld%c", amt, tag);  
   
    return (ret);  
}  
   
int  
get_cmdline(struct io_node *ion)  
{  
    int fd;  
    int length;  
    char filename[BUFFERLEN + 1];  
    char buffer[COMMANDLEN + 1];  
    char *p;  
    char *q;  
   
   
    length = snprintf(filename, BUFFERLEN, "%s/%d/cmdline", PROC, ion->pid);  
    if (length == BUFFERLEN)  
        printf("WARNING - filename length may be too big for buffer: %d\n",  
                __LINE__);  
    fd = open(filename, O_RDONLY);  
    if (fd == -1)  
        return 1;  
    length = read(fd, buffer, sizeof(buffer) - 1);  
    close(fd);  
    buffer[length] = '\0';  
    if (length == 0)  
        return 2;  
    if (command_flag == 0)  
    {  
        /* 
         * The command is near the beginning; we don't need to be able to 
         * the entire stat file. 
         */  
        p = strchr(buffer, '(');  
        ++p;  
        q = strchr(p, ')');  
        length = q - p;  
    }  
    else  
        p = buffer;  
    length = length < COMMANDLEN ? length : COMMANDLEN;  
    strncpy(ion->command, p, length);  
    ion->command[length] = '\0';  
    return 0;  
}  
   
struct io_node *  
get_ion(int pid)  
{  
    struct io_node *c = head;  
   
    while (c != NULL)  
    {  
        if (c->pid == pid)  
            break;  
        c = c->next;  
    }  
    return c;  
}  
   
int  
get_tcomm(struct io_node *ion)  
{  
    int fd;  
    int length;  
    char filename[BUFFERLEN + 1];  
    char buffer[BUFFERLEN + 1];  
    char *p;  
    char *q;  
   
    length = snprintf(filename, BUFFERLEN, "%s/%d/stat", PROC, ion->pid);  
    if (length == BUFFERLEN)  
        printf("WARNING - filename length may be too big for buffer: %d\n",  
                __LINE__);  
    fd = open(filename, O_RDONLY);  
    if (fd == -1)  
        return 1;  
    length = read(fd, buffer, sizeof(buffer) - 1);  
    close(fd);  
    /* 
     * The command is near the beginning; we don't need to be able to 
     * the entire stat file. 
     */  
    p = strchr(buffer, '(');  
    ++p;  
    q = strchr(p, ')');  
    length = q - p;  
    length = length < BUFFERLEN ? length : BUFFERLEN;  
   
    strncpy(ion->command, p, length);  
    ion->command[length] = '\0';  
    return 0;  
}  
   
struct io_node *  
insert_ion(struct io_node *ion)  
{  
    struct io_node *c;  
    struct io_node *p;  
   
    /* Check the head of the list as a special case. */  
    if (ion->pid < head->pid)  
    {  
        ion->next = head;  
        head = ion;  
        return head;  
    }  
   
    c = head->next;  
    p = head;  
    while (c != NULL)  
    {  
        if (ion->pid < c->pid)  
        {  
            ion->next = c;  
            p->next = ion;  
            return head;  
        }  
        p = c;  
        c = c->next;  
    }  
   
    /* Append to the end of the list. */  
    if (c == NULL)  
        p->next = ion;  
   
    return head;  
}  
   
void  
get_stats()  
{  
    DIR *dir = opendir(PROC);  
    struct dirent *ent;  
    char filename[BUFFERLEN + 1];  
    char buffer[BUFFERLEN + 1];  
   
    char value[BUFFERLEN + 1];  
   
    /* Display column headers. */  
    if (hr_flag == 1)  
        printf("%5s %5s %5s %8s %8s %5s %6s %7s %s\n", "pid", "rchar", "wchar",  
                "syscr", "syscw", "reads", "writes", "cwrites", "command");  
    else if (kb_flag == 1)  
        printf("%5s %8s %8s %8s %8s %8s %8s %8s %s\n", "pid", "rchar", "wchar",  
                "syscr", "syscw", "rkb", "wkb", "cwkb", "command");  
    else if (mb_flag == 1)  
        printf("%5s %8s %8s %8s %8s %8s %8s %8s %s\n", "pid", "rchar", "wchar",  
                "syscr", "syscw", "rmb", "wmb", "cwmb", "command");  
    else  
        printf("%5s %8s %8s %8s %8s %8s %8s %8s %s\n", "pid", "rchar", "wchar",  
                "syscr", "syscw", "rbytes", "wbytes", "cwbytes", "command");  
   
    /* Loop through the process table and display a line per pid. */  
    while ((ent = readdir(dir)) != NULL)  
    {  
        int rc;  
        int fd;  
        int length;  
   
        char *p;  
        char *q;  
   
        struct io_node *ion;  
        struct io_node *old_ion;  
   
        long long rchar;  
        long long wchar;  
        long long syscr;  
        long long syscw;  
        long long read_bytes;  
        long long write_bytes;  
        long long cancelled_write_bytes;  
   
        if (!isdigit(ent->d_name[0]))  
            continue;  
   
        ion = new_ion(ent->d_name);  
   
        if (command_flag == 1)  
            rc = get_cmdline(ion);  
        if (command_flag == 0 || rc != 0)  
            /* If the full command line is not asked for or is empty... */  
            rc = get_tcomm(ion);  
   
        if (rc != 0)  
        {  
            free(ion);  
            continue;  
        }  
   
        /* Read 'io' file. */  
        length = snprintf(filename, BUFFERLEN, "%s/%s/io", PROC, ent->d_name);  
        if (length == BUFFERLEN)  
            printf("WARNING - filename length may be too big for buffer: %d\n",  
                    __LINE__);  
        fd = open(filename, O_RDONLY);  
        if (fd == -1)  
        {  
            free(ion);  
            continue;  
        }  
        length = read(fd, buffer, sizeof(buffer) - 1);  
        close(fd);  
        buffer[length] = '\0';  
   
        /* Parsing the io file data. */  
        p = buffer;  
        GET_VALUE(ion->rchar);  
        GET_VALUE(ion->wchar);  
        GET_VALUE(ion->syscr);  
        GET_VALUE(ion->syscw);  
        GET_VALUE(ion->read_bytes);  
        GET_VALUE(ion->write_bytes);  
        GET_VALUE(ion->cancelled_write_bytes);  
   
        old_ion = get_ion(ion->pid);  
   
        /* Display the pid's io data. */  
        if (old_ion != NULL)  
        {  
            rchar = ion->rchar - old_ion->rchar;  
            wchar = ion->wchar - old_ion->wchar;  
            syscr = ion->syscr - old_ion->syscr;  
            syscw = ion->syscw - old_ion->syscw;  
            read_bytes = ion->read_bytes - old_ion->read_bytes;  
            write_bytes = ion->write_bytes - old_ion->write_bytes;  
            cancelled_write_bytes = ion->cancelled_write_bytes -  
                    old_ion->cancelled_write_bytes;  
   
            if (kb_flag == 1 && hr_flag == 0)  
            {  
                rchar = BTOKB(rchar);  
                wchar = BTOKB(wchar);  
                syscr = BTOKB(syscr);  
                syscw = BTOKB(syscw);  
                read_bytes = BTOKB(read_bytes);  
                write_bytes = BTOKB(write_bytes);  
                cancelled_write_bytes = BTOKB(cancelled_write_bytes);  
            }  
            else if (mb_flag == 1 && hr_flag == 0)  
            {  
                rchar = BTOMB(rchar);  
                wchar = BTOMB(wchar);  
                syscr = BTOMB(syscr);  
                syscw = BTOMB(syscw);  
                read_bytes = BTOMB(read_bytes);  
                write_bytes = BTOMB(write_bytes);  
                cancelled_write_bytes = BTOMB(cancelled_write_bytes);  
            }  
   
            if (!(idle_flag == 1 && rchar == 0 && wchar == 0 && syscr == 0 &&  
                    syscw == 0 && read_bytes == 0 && write_bytes == 0 &&  
                    cancelled_write_bytes == 0)) {  
                if (hr_flag == 0)  
                    printf("%5d %8lld %8lld %8lld %8lld %8lld %8lld %8lld %s\n",  
                            ion->pid,  
                            rchar,  
                            wchar,  
                            syscr,  
                            syscw,  
                            read_bytes,  
                            write_bytes,  
                            cancelled_write_bytes,  
                            ion->command);  
                else  
                    printf("%5d %5s %5s %8lld %8lld %5s %6s %7s %s\n",  
                            ion->pid,  
                            format_b(rchar),  
                            format_b(wchar),  
                            syscr,  
                            syscw,  
                            format_b(read_bytes),  
                            format_b(write_bytes),  
                            format_b(cancelled_write_bytes),  
                            ion->command);  
            }  
        }  
        else if (idle_flag != 1)  
            /* 
             * No previous data, show 0's instead of calculating negatives 
             * only if we are shoring idle processes. 
             */  
            printf("%5d %8d %8d %8d %8d %8d %8d %8d %s\n",  
                    ion->pid, 0, 0, 0, 0, 0, 0, 0, ion->command);  
   
        upsert_data(ion);  
    }  
    closedir(dir);  
    return;  
}  
   
struct io_node *  
new_ion(char *pid)  
{  
    struct io_node *ion;  
   
    ion = (struct io_node *) malloc(sizeof(struct io_node));  
    bzero(ion, sizeof(struct io_node));  
    ion->pid = atoi(pid);  
   
    return ion;  
}  
   
void  
upsert_data(struct io_node *ion)  
{  
    struct io_node *n;  
   
    /* List is empty. */  
    if (head == NULL)  
    {  
        head = ion;  
        return;  
    }  
   
    /* Check if we have seen this pid before. */  
    n = head;  
    while (n != NULL)  
    {  
        if (n->pid == ion->pid)  
        {  
            n->rchar = ion->rchar;  
            n->wchar = ion->wchar;  
            n->syscr = ion->syscr;  
            n->syscw = ion->syscw;  
            n->read_bytes = ion->read_bytes;  
            n->write_bytes = ion->write_bytes;  
            n->cancelled_write_bytes = ion->cancelled_write_bytes;  
            /* 
             * If the pids wrap, then the command may be different then before. 
             */  
            strcpy(n->command, ion->command);  
            free(ion);  
            return;  
        }  
        n = n->next;  
    }  
   
    /* Add this pid to the list. */  
    head = insert_ion(ion);  
    return;  
}  
   
void  
usage()  
{  
    printf("usage: iopp -h|--help\n");  
    printf("usage: iopp [-ci] [-k|-m] [delay [count]]\n");  
    printf("            -c, --command display full command line\n");  
    printf("            -h, --help display help\n");  
    printf("            -i, --idle hides idle processes\n");  
    printf("            -k, --kilobytes display data in kilobytes\n");  
    printf("            -m, --megabytes display data in megabytes\n");  
    printf("            -u, --human-readable display data in kilo-, mega-, or giga-bytes\n");  
}  
   
int  
main(int argc, char *argv[])  
{  
    int c;  
   
    int delay = 0;  
    int count = 0;  
    int max_count = 1;  
   
    while (1)  
    {  
        int option_index = 0;  
        static struct option long_options[] = {  
                { "command", no_argument, 0, 'c' },  
                { "help", no_argument, 0, 'h' },  
                { "human-readable", no_argument, 0, 'u' },  
                { "idle", no_argument, 0, 'i' },  
                { "kilobytes", no_argument, 0, 'k' },  
                { "megabytes", no_argument, 0, 'm' },  
                { 0, 0, 0, 0 }  
        };  
   
        c = getopt_long(argc, argv, "chikmu", long_options, &option_index);  
        if (c == -1)  
        {  
            /* Handle delay and count arguments. */  
   
            if (argc == optind)  
                break; /* No additional arguments. */  
            else if ((argc - optind) == 1)  
            {  
                delay = atoi(argv[optind]);  
                max_count = -1;  
            }  
            else if ((argc - optind) == 2)  
            {  
                delay = atoi(argv[optind]);  
                max_count = atoi(argv[optind + 1]);  
            }  
            else  
            {  
                /* Too many additional arguments. */  
                usage();  
                return 3;  
            }  
            break;  
        }  
   
        switch (c)  
        {  
        case 'c':  
            command_flag = 1;  
            break;  
        case 'h':  
            usage();  
            return 0;  
        case 'i':  
            idle_flag = 1;  
            break;  
        case 'k':  
            kb_flag = 1;  
            break;  
        case 'm':  
            mb_flag = 1;  
            break;  
        case 'u':  
            hr_flag = 1;  
            break;  
        default:  
            usage();  
            return 2;  
        }  
    }  
   
    while (max_count == -1 || count++ < max_count)  
    {  
        get_stats();  
        if (count != max_count)  
            sleep(delay);  
    }  
    return 0;  
}

程序git地址：git@code.youkuaiyun.com:snippets/406028.git

代码地址：https://code.youkuaiyun.com/snippets/406028#nogo

转载于:https://my.oschina.net/zhangxc73912/blog/755183

Linux IO工具 iotop的替代品iopp
hytfly的专栏
06-25 4492
iotop无疑在linux IO检测上是个不错的工具，但苦于要求内核版本和Python版本，不少朋友放弃了，我也是。偶然间找到了iopp，用c写的，这个跟iotop是一个作用，nice！给大家分享下 安装方法很简单，首先复制下面源代码保存为iopp.c文件 #include #include #include #include #include #include #incl
linux 监控硬盘读写,干货｜监控硬盘读写
weixin_39611389的博客
05-04 2462
点击上方“中兴开发者社区”，关注我们每天读一篇一线开发者原创好文 监控硬盘读写系统运行过程中，一些进程会向硬盘中写入大量的数据，如果写入的数据量不做控制，总有一天硬盘会被写满，导致一些奇奇怪怪的问题。为了避免硬盘被写满，就需要监控硬盘的使用情况，例如需要感知到系统中写入了哪些文件，文件的大小有多少，最好能够跟踪到进程，查看进程打开的文件，并监控此进程读写硬盘的字节数。系统级文件操作监控Linux操...
Linux IO工具 iotop备择方案iopp
weixin_34186128的博客
07-13 250
iotop毫无疑问linux IO检测上是一个很好的工具，但苦于要求和内核版本Python版本号。我的很多朋友放弃了。我也是。无意中发现iopp，使用c书面，与此iotop它是一个作用。nice！一起分享 安装方法非常easy。首先复制以下源码保存为iopp.c文件 #include &lt;stdio.h&gt; #include &lt;sys/types.h&gt; #i...
iotop监测工具的使用
京东放养的爬虫
12-03 1735
iotop命令是一个用来监视磁盘I/O使用状况的top类工具。iotop具有与top相似的UI，其中包括PID、用户、I/O、进程等相关信息。Linux下的IO统计工具如iostat，nmon等大多数是只能统计到per设备的读写情况，如果你想知道每个进程是如何使用IO的就比较麻烦，使用iotop命令可以很方便的查看。  iotop使用Python语言编写而成，要求Python2.5（及以上版本）
Linux系统管理员应该了解的一些I/O统计工具
MiltonZhong
07-10 997
作为一个Linux系统管理员，统计各类IO是一项必不可少的工作。其统计工具中iostat显然又是最重要的一个统计手段。但是这里iostat不是本文的重点，因为这个工具的使用在网络上已经有大量的教程，可以供大家参考。这里主要是想介绍一些其他统计工具以来满足不同的需求。 iostat iostat的功能异常强大，输出项也特别多，比如下面这个例子： Device: rrqm/s  wrqm/s  
iopp:从进程的角度上报IO静态
06-29
iopp可能是一个开源工具或库，用于收集和分析进程级别的I/O操作统计数据。以下是对这个主题的详细解释： 在操作系统中，I/O操作是计算机与外部设备交互的关键部分，包括硬盘读写、网络通信、打印机输出等。通常，...
iopp: 进程级别IO静态报告工具
资源摘要信息:"iopp是一个以进程为单位来监测和上报IO静态的工具或库。它能够收集关于进程IO活动的数据，比如读取和写入操作的次数、传输的数据量等。这种方式对于理解特定进程的IO负载和性能特征非常有帮助，尤其在...
android监控io产生的应用,Android IO性能分析及排查
weixin_34053992的博客
06-04 1692
概述Android得IO问题实际上就是探究Linux得IO问题。本文主要是总结了网上各路大神得经验，写了一些实际操作中遇到得问题和解决方案。最近在搞性能优化方面得研究，研究使用Soloπ得io占用对性能得影响问题时，偶然发现了机器上IO很频繁。老大说去看看为啥io那么频繁吧，于是乎…走上了一条不归路啊T.T。内容网上搜来搜去基本就那几篇东西，大部分都是转来转去。而且多是针对linux系统得，专门针...
科研经历——8/1——第一次审稿教程
Blackoutdragon的博客
08-01 1332
具体文章的审核，这里就不放了，这里是贴了一个审核的教程，能力有限，并不能对文章提出一个很详细的审核，仅仅是借助GPT以及对于文章图表做一个初步的审核。 算是没有遗憾了，不过感觉在秋招之际，让我的审核文章，还是蛮急躁的，因为时间本来就不够用！ 四篇论文都修改了，然后全部都给了accept，写一篇文章不容易，而且我看图表画的都挺好的！
磁盘IO瓶颈分析
睨噷蹇蜣的博客
12-14 2768
磁盘IO瓶颈分析 https://www.w3xue.com/exp/article/201812/12432.html(iowait过高) 如果IO存在性能瓶颈，top工具中的%wa会偏高； 一、 首先分析是不是io引起的系统缓慢（top命令） [root@coolnull ~]# top top - 14:31:20 up 35 min, 4 users, load average: 2.25...
Android IO性能分析及排查
moxiouhao的专栏
08-22 9157
概述 Android得IO问题实际上就是探究Linux得IO问题。 本文主要是总结了网上各路大神得经验，写了一些实际操作中遇到得问题和解决方案。 最近在搞性能优化方面得研究，研究使用Soloπ得io占用对性能得影响问题时，偶然发现了机器上IO很频繁。老大说去看看为啥io那么频繁吧，于是乎…走上了一条不归路啊T.T。 内容 网上搜来搜去基本就那几篇东西，大部分都是转来转去。而且多是针对linux系统...
git 生成 Patch 和打 Patch
yutel的专栏
08-20 838
在程序员的日常开发与合作过程中，对于 code 的生成 patch 和打 patch (应用 patch) 成为经常需要做的事情。
发版混乱怎么规范
m0_64056556的博客
08-22 743
本文提出了一套简洁高效的代码管理标准，核心是两条主线（main/develop分支）加临时功能分支的策略。开发时从develop切功能分支，通过合并请求审查后合并；发布时从develop切发布分支测试，稳定后合并到main并打标签；线上问题从main切热修复分支处理。强调三大纪律：主分支保护、功能原子化、标签化发布。这套方案能确保主线稳定、并行开发互不干扰、发布内容清晰可追溯，同时简化流程便于执行。关键在于严格执行分支策略和标签管理，避免直接推送主分支和多功能混杂提交。
[特殊字符] 潜入深渊：探索 Linux 内核源码的奇幻之旅与生存指南
kernelguru的博客
08-22 653
Linux内核源码探索指南 Linux内核源码是驱动数字世界的核心工程杰作，全球开发者协作的典范。关键目录包括：arch/（CPU架构相关）、drivers/（硬件驱动）、fs/（文件系统）、kernel/（进程调度等核心功能）。建议开发者通过具体问题切入（如系统调用流程），善用cscope/ctags等工具，结合官方文档逐步深入。内核开发采用邮件列表协作模式，补丁需经严格审查。初学者应注重理解主线逻辑，从简单驱动开始实践，警惕并发问题。探索内核源码是理解计算机系统本质的绝佳途径，虽具挑战但收获巨大。
当 GitHub 宕机时，我们如何协作？
hfd1990的博客
08-20 1030
GitHub宕机应急协作方案 摘要：针对GitHub宕机影响开发流程的问题，本文提出了一套完整的应急协作方案。首先利用本地仓库通过补丁文件和局域网共享实现代码交换；其次介绍快速迁移至Gitee/GitLab等替代平台的方法；同时强调使用钉钉/企业微信等即时通讯工具和在线文档保持团队沟通；最后建议建立多平台托管和定期备份机制。方案覆盖代码管理、平台迁移、团队协作三个维度，确保在GitHub服务中断时开发工作能持续进行。实施要点包括：熟练掌握本地Git操作、提前注册备用平台账号、制定应急沟通规范、建立定期备份制
Git 2.15.0 64位安装步骤Windows详细教程从下载到验证（附安装包下载）
IDOlaoluo的博客
08-21 946
一、下载后双击运行。
Git 提交除某个文件外的其他所有文件
weixin_41716656的博客
08-22 179
这样 staging area（暂存区）里会去掉 bootstrap.yaml，其他文件都在。bootstrap.yaml’ 表示排除 bootstrap.yaml。方法二：先添加所有，再取消掉 bootstrap.yaml。会一个一个文件/区块地问你是否添加，按 y/n 选择。方法一：显式排除 bootstrap.yaml。方法三：交互式添加（适合控制多个文件）如果只有一个文件不想加，用方法二更快。. 表示添加当前目录所有文件。
git分支命名规范
最新发布
weixin_42221136的博客
08-22 222
【代码】git分支命名规范。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值