Linux系统编程之回收子进程

已于 2022-05-16 14:47:09 修改
阅读量498 收藏 1
点赞数 1
分类专栏： Linux系统编程 文章标签： linux ubuntu bash
于 2022-05-02 22:17:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51029592/article/details/124529459
版权

回收子进程

孤儿进程

在这里插入图片描述

/*
 *  @file           orphan.c
 *  @brief          父进程比子进程先结束，子进程变成了孤儿进程，由init进程回收
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>

int main(void)
{
        pid_t pid;

        pid = fork();
        if (pid == 0)           //子进程
        {
                while(1)        //循环打印让父进程先结束，子进程变成孤儿进程
                {
                        printf("I am child,my parent pid = %d\n", getppid());
                        sleep(1);
                }
        }
        else if (pid > 0)       //父进程
        {
                printf("I am parent,my pid is %d\n", getpid());
                sleep(5);
                printf("-------parent going to die---------\n");
        }
        else if (pid == -1)     //创建子进程失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

刚开始的父进程是11872，后来父进程11872先结束了，子进程就变成孤儿进程了，父进程变成1了，即是init进程，由这个init进程进行子进程的回收
在这里插入图片描述

僵尸进程

在这里插入图片描述

/*
 *  @file           zoom.c
 *  @brief          子进程结束了，父进程也没有回收回收残留的资源，就变成僵尸进程了
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
        pid_t pid;

        pid = fork();
        if (pid == 0)           //子进程
        {
                printf("I am child, my parent %d, going to sleep 10s\n", getppid());
                sleep(10);
                printf("-----------child die-------------\n");
        }
        else if (pid > 0)       //父进程
        {
                while(1)        //子进程结束后，父进程并没有对子进程进行回收，导致子进程变成僵尸进程
                {
                        printf("I am parent, pid = %d,myson = %d\n", getpid(), pid);
                        sleep(1);
                }
        }
        else if (pid == -1)     //子进程创建失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

子进程结束了，父进程也没有回收回收残留的资源，就变成僵尸进程了在这里插入图片描述
这里看到的括号括起来的zoom就是僵尸态了在这里插入图片描述

wait函数

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

在这里插入图片描述
wait函数

在这里插入图片描述

用wait函数阻塞等待子进程结束，再由父进程粗略回收，但不知道子进程结束的状态

/*
 *  @file           zoom_wait.c
 *  @brief          用wait函数阻塞等待子进程结束，再由父进程粗略回收，但不知道子进程结束的状态
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
        pid_t pid;
        pid_t wpid;

        //创建一个子进程
        pid = fork();
        if (pid == 0)           //子进程
        {
                printf("I am child, my parent %d, going to sleep 10s\n", getppid());
                sleep(10);
                printf("-----------child die-------------\n");
        }
        else if (pid > 0)       //父进程
        {
                wpid = wait(NULL);              //阻塞等待子进程结束，回收子进程
                if(wpid == -1)                  //回收子进程失败
                {
                        perror("wait error");
                        exit(1);
                }
                while(1)                        //这里子进程已经被回收，弄一个while，方便去查看是否还有僵尸进程
                {
                        printf("I am parent, pid = %d,myson = %d\n", getpid(), pid);
                        sleep(1);
                }
        }
        else if (pid == -1)     //创建子进程失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

在这里插入图片描述
这样子父进程就可以回收到子进程了，就不会留下子进程的残留了
在这里插入图片描述

用wait函数阻塞等待子进程结束，再执行父进程，这里精确回收，得到了子进程结束的状态，子进程正常结束

/*
 *  @file           wait1.c
 *  @brief          用wait函数阻塞等待子进程结束，再执行父进程，这里精确回收，得到了子进程结束的状态，子进程正常结束
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
        pid_t pid;
        pid_t wpid;
        int status;

        //创建一个子进程
        pid = fork();
        if (pid == 0)           //子进程
        {
                printf("I am child, my parent %d, going to sleep 10s\n", getppid());
                sleep(10);
                printf("-----------child die-------------\n");
                exit(76);       //进程正常结束
        }
        else if (pid > 0)       //父进程
        {
                wpid = wait(&status);           //阻塞等待子进程结束，回收子进程
                if (wpid == -1)                 //回收子进程失败
                {
                        perror("wait error");
                        exit(1);
                }
                if (WIFEXITED(status))          //子进程正常结束
                {
                        printf("child exit with %d\n", WEXITSTATUS(status));            //打印输出exit的参数
                }
                while(1)        //这里子进程已经被回收，弄一个while，方便去查看是否还有僵尸进程
                {
                        printf("I am parent, pid = %d,myson = %d\n", getpid(), pid);
                        sleep(1);
                }
        }
        else if (pid == -1)     //创建子进程失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

在这里插入图片描述
用wait函数阻塞等待子进程结束，再执行父进程，这里精确回收，得到了子进程结束的状态，子进程异常结束

/*
 *  @file           wait2.c
 *  @brief          用wait函数阻塞等待子进程结束，再执行父进程，这里精确回收，得到了子进程结束的状态，子进程异常结束
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
        pid_t pid;
        pid_t wpid;
        int status;

      	//创建一个子进程
        pid = fork();
        if (pid == 0)           //子进程
        {
                printf("I am child, my parent %d, going to sleep 10s\n", getppid());
                sleep(60);              //这里阻塞60s，留着去kill子进程
                printf("-----------child die-------------\n");
                exit(76);
        }
        else if (pid > 0)       //父进程
        {
                wpid = wait(&status);           //阻塞等待子进程结束，回收子进程
                if (wpid == -1)                 //回收子进程失败
                {
                        perror("wait error");
                        exit(1);
                }
                if (WIFEXITED(status))          //子进程正常结束
                {
                        printf("child exit with %d\n", WEXITSTATUS(status));
                }
                if (WIFSIGNALED(status))        //子进程异常结束
                {
                        printf("child killed by %d\n", WTERMSIG(status));
                }
                while (1)
                {
                        printf("I am parent, pid = %d,myson = %d\n", getpid(), pid);
                        sleep(1);
                }
        }
        else if (pid == -1)     //创建子进程失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

这里用kill杀死子进程
在这里插入图片描述
wait函数得到了子进程结束的状态
在这里插入图片描述
在这里插入图片描述
回收多个子进程
上面已经用过wait函数来回收一个子进程，现在用wait函数来回收多个子进程

/*
 *  @file           wait3.c
 *  @brief          用wait函数来回收多个子进程
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(void)
{
        int i;
        pid_t pid;

        //创建5个子进程
        for (i = 0; i < 5; i++)
        {
                pid = fork();
                if (pid == 0)           //父进程继续循环，直到循环结束，子进程退出循环
                {
                        break;
                }
        }

        //判断是父进程还是子进程
        if(i < 5)
        {
                sleep(i);
                printf("I am %d child, pid = %u\n", i+1, getpid());
        }
        else
        {
                sleep(i);
                printf("I am parent\n");
                while (wait(NULL));             //循环回收多个子进程
        }

        return 0;
}

在这里插入图片描述

waitpid函数

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

用waitpid函数回收指定子进程
waitpid函数的第三个参数为0是阻塞回收，跟wait函数一样

/*
 *  @file           waitpid1.c
 *  @brief          用waitpid函数回收指定子进程
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(void)
{
        int i;
        pid_t pid;
        pid_t p;

        //循环创建5个子进程
        for (i = 0; i < 5; i++)
        {
                pid = fork();
                if (pid == 0)
                {
                        break;
                }
                else if (i == 3)
                {
                        p = pid;
                }
        }

        if (i < 5)
        {
                sleep(i);
                printf("I am %d child, pid = %u\n", i+1, getpid());
        }
        else
        {
                sleep(i);
                printf("I am parent\n");
                waitpid(p, NULL, 0);            //阻塞等待回收指定的子进程
                while (1);
        }

        return 0;
}

可以看出指定回收的第四个子进程已经被回收了
在这里插入图片描述
用waitpid函数回收多个子进程

/*
 *  @file           waitpid2.c
 *  @brief          用waitpid函数回收多个子进程
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(void)
{
        int i;
        pid_t pid;

        //循环创建5个子进程
        for (i = 0; i < 5; i++)
        {
                pid = fork();
                if (pid == 0)
                {
                        break;
                }
        }

        if (i < 5)
        {
                sleep(i);
                printf("I am %d child, pid = %u\n", i+1, getpid());
        }
        else
        {
                sleep(i);
                printf("I am parent\n");
                while (waitpid(-1, NULL, 0));           //等价于while(wait(NULL));
        }

        return 0;
}

可以看到所有子进程都被回收了
在这里插入图片描述
当waitpid函数的第三个参数为WNOHANG，为轮询回收子进程，子进程正在运行的时候，返回值为0
轮询回收多个子进程

/*
 *  @file           waitpid3.c
 *  @brief          用waitpid函数轮询回收多个子进程
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(void)
{
        int i;
        int n = 5;
        pid_t pid;
        pid_t wpid;

        //循环创建5个子进程
        for (i = 0; i < 5; i++)
        {
                pid = fork();
                if (pid == 0)
                {
                        break;
                }
        }

        if (i < 5)
        {
                sleep(i);
                printf("I am %d child, pid = %u\n", i+1, getpid());
        }
        else
        {
                sleep(i);
                printf("I am parent\n");
                do
                {
                        wpid = waitpid(-1, NULL, WNOHANG);              //轮询回收子进程
                        if (wpid > 0)
                        {
                                n--;
                        }
                        sleep(1);
                }while (n > 0);

                while (1);
        }

        return 0;
}

子进程已全部回收
在这里插入图片描述

是北豼不太皮吖
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
linux操作系统之进程 子进程回收
小白杨的博客
04-18 983
回收子进程主要有两个函数：wait(),waitpid()。 一个进程在终止时会关闭所有文件描述符，释放在用户空间分配的内存，但它的PCB还保留着，内核在其中保存了一些信息：如果是正常终止则保存着退出状态，如果是异常终止则保存着导致该进程终止的信号是哪个。这个进程的父进程可以调用wait或waitpid获取这些信息，然后彻底清除掉这个进程。我们知道一个进程的退出状态可以在Shell中用特殊变量$...
linux popen函数
Gino的专栏
07-24 944
函数原型FILE *popen(const char *command, const char *type); int pclose(FILE *stream);函数说明 popen()函数通过创建一个管道，调用fork()产生一个子进程，执行一个shell以运行命令来开启一个进程。这个管道必须由pclose()函数关闭，而不是fclose()函数。pclose()函数关闭标准I/O流，等待命令执
linux系统编程之线程.zip
05-05
线程概念 什么是线程 LWP：light weight process 轻量级的进程，本质仍是进程(在Linux环境下) 进程：独立地址空间，拥有PCB 线程：也有PCB，但没有独立的地址空间(共享) 区别：在于是否共享地址空间。 独居(进程)；合租(线程)。 Linux下： 线程：最小的执行单位 进程：最小分配资源单位，可看成是只有一个线程的进程。 Linux内核线程实现原理 类Unix系统中，早期是没有“线程”概念的，80年代才引入，借助进程机制实现出了线程的概念。因此在这类系统中，进程和线程关系密切。 1. 轻量级进程(light-weight process)，也有PCB，创建线程使用的底层函数和进程一样，都是clone 2. 从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的 3. 进程可以蜕变成线程 4. 线程可看做寄存器和栈的集合 5. 在linux下，线程最是小的执行单位；进程是最小的分配资源单位 察看LWP号：ps –Lf pid 查看指定线程的lwp号。 三级映射：进程PCB --> 页目录(可看成数组，首地址位于PCB中) --> 页表 --> 物理页面 --> 内存单元 参考：《Linux内核源代码情景分析》 ----毛德操 对于进程来说，相同的地址(同一个虚拟地址)在不同的进程中，反复使用而不冲突。原因是他们虽虚拟址一样，但，页目录、页表、物理页面各不相同。相同的虚拟址，映射到不同的物理页面内存单元，最终访问不同的物理页面。 但！线程不同！两个线程具有各自独立的PCB，但共享同一个页目录，也就共享同一个页表和物理页面。所以两个PCB共享一个地址空间。 实际上，无论是创建进程的fork，还是创建线程的pthread_create，底层实现都是调用同一个内核函数clone。 如果复制对方的地址空间，那么就产出一个“进程”；如果共享对方的地址空间，就产生一个“线程”。 因此：Linux内核是不区分进程和线程的。只在用户层面上进行区分。所以，线程所有操作函数 pthread_* 是库函数，而非系统调用。 线程共享资源 1.文件描述符表 2.每种信号的处理方式 3.当前工作目录 4.用户ID和组ID 5.内存地址空间 (.text/.data/.bss/heap/共享库) 线程非共享资源 1.线程id 2.处理器现场和栈指针(内核栈) 3.独立的栈空间(用户空间栈) 4.errno变量 5.信号屏蔽字 6.调度优先级 线程优、缺点 优点： 1. 提高程序并发性 2. 开销小 3. 数据通信、共享数据方便 缺点： 1. 库函数，不稳定 2. 调试、编写困难、gdb不支持 3. 对信号支持不好 优点相对突出，缺点均不是硬伤。Linux下由于实现方法导致进程、线程差别不是很大。 线程控制原语 pthread_self函数 获取线程ID。其作用对应进程中 getpid() 函数。 pthread_t pthread_self(void); 返回值：成功：0； 失败：无！ 线程ID：pthread_t类型，本质：在Linux下为无符号整数(%lu)，其他系统中可能是结构体实现 线程ID是进程内部，识别标志。(两个进程间，线程ID允许相同) 注意：不应使用全局变量 pthread_t tid，在子线程中通过pthread_create传出参数来获取线程ID，而应使用pthread_self。 pthread_create函数 创建一个新线程。 其作用，对应进程中fork() 函数。 int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); 返回值：成功：0； 失败：错误号 -----Linux环境下，所有线程特点，失败均直接返回错误号。 参数： pthread_t：当前Linux中可理解为：typedef unsigned long int pthread_t; 参数1：传出参数，保存系统为我们分配好的线程ID 参数2：通常传NULL，表示使用线程默认属性。若想使用具体属性也可以修改该参数。 参数3：函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。 参数4：线程主函数执行期间所使用的参数。 在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。star
system函数遇到的问题
yuan
02-25 1338
system函数遇到的问题 这几天调程序(嵌入式linux),发现程序有时就莫名其妙的死掉,每次都定位在程序中不同的system()函数,直接在shell下输入system()函数中调用的命令也都一切正常.就没理这个bug,以为是其他的代码影响到这个,或是内核驱动文件系统什么的异常导致,昨天有出现了这个问题,就随手百了一下度,问题出现了,很多人都说system()函数要慎用要少用要能不用则不用,system()函数不稳定? 下面是system函数百度的介绍: 进程管理之system 详解 system定义
调研popen/system, 理解这两个函数和fork的区别.
xiaodu655的博客
03-27 621
. 调研popen/system, 理解这两个函数和fork的区别. ： system()函数 函数原型 #include &lt;stdlib.h&gt; int system(const char *command); system()会调用fork()产生子进程，由子进程来调用/bin/sh-c string来执行参数string字符串所代表的命令，此命令执行完后随即返回原调用的...
【博客148】Linux程序中获取shell运行结果—popen
qq_43684922的博客
12-13 549
内容： 我们在执行shell的时候可以选择system或者popen函数，但是它们是有差别的 system与popen区别： popen是不堵塞的，也就是说不会等待子进程的结束并杀死子进程，即不会管理进程。这样就需要人为的去 杀死或忽略子进程等操作。还有就是popen会将执行的结果返回到buffer中。在执行期间调用进程会一直等 待shell命令执行完成。popen ：没有对信号做任何的处理。po...
linux进程怎么被回收的,linux 多进程并发服务__关于子进程回收的方法
weixin_31486383的博客
05-05 153
以TCPServ 服务程序来说：１)父进程:负责系统初始化，以及监听(listen),接受连接请求(accept);其中accept 默认阻塞调用。２)每接受一个连接请求，动态新建(fork)一个子进程，任务完成或客户端断开，服务子进程需要退出并收回系统资源。３)根据linux的设计子进程的收回需要父进程参与(wait调用)，而此时附进程主要服务工作在监听客户端连接请求，同时阻塞在(accept)...
Linux之回收子进程
qq_41033011的博客
07-23 480
回收子进程 孤儿进程 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为 init 进程，称为 init进程(进程ID为1)领养孤儿进程 【验证孤儿进程】 #include <stdio.h> #include <unistd.h> int main() { pid_t pid; pid = fork(); if(pid < 0) { perror("fork error\n"); return -1; } else if(pid > 0
Linux回收子进程
usstmiracle的博客
07-17 239
孤儿进程 孤儿进程: 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。 #include <stdio.h> #include <unistd.h> #include <sys/wait.h> int main(void) { pid_t pid; pid = fork(); if (pid == 0) { while (1) { print
Linux——子进程回收
一个小孩
03-18 507
exec函数族 fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。 将当前进程的.text、.data替...
《Linux系统编程、网络编程》第5章 进程控制
06-12
课程内容：进程与程序、进程PID与三个特殊进程、fork函数的作用、父子进程对文件的共享、execve加载函数、system函数、进程的资源回收、wait函数、进程状态、java进程、进程关系、守护进程，return/exit/_exit、环境...
02-Linux系统编程-进程
03-25
Linux进程，进程创建，进程的结束，进程的回收等相关的介绍。
linux系统下多线程编程文档资料
10-25
四、posix有名信号灯应用于多进程 27 五、基于内存的信号灯 29 第四章 互斥量 39 一、什么是互斥锁 39 二、初始化/回收互斥锁 40 三、对互斥量加减锁 40 四、互斥锁属性 45 五、应用互斥量需要注意的几点 48 第五章 ...
linux编程白皮书
07-18
本书对Linux操作系统及其编程作了整体的介绍，以支持用于开发软件的公开源码模型。对内存管理、进程及其通信机制、PCI、内核模块编程及内核系统结构作了详细的解释，且附有很多程序代码实例。对深入研究Linux下的...
LINUX编程白皮书
04-07
本书对Linux操作系统及其编程作了整体的介绍，以支持用于开发软件的公开源码模型。对内存管理、进程及其通信机制、PCI、内核模块编程及内核系统结构作了详细的解释，且附有很多程序代码实例。对深入研究Linux下的...
有关于死循环子线程引起的bug，linux下Popen子进程退出后的poll状态依旧是None，僵尸进程处理
weixin_44359953的博客
07-30 1692
关于主进程、子进程，主线程，子线程停止结束的关系： 对于linux： 对于程序来说，如果主进程在子进程还未结束时就已经退出，那么Linux内核会将子进程的父进程ID改为1（也就是init进程），当子进程结束后会由init进程来回收该子进程。 主线程退出后子线程的状态依赖于它所在的进程，如果进程没有退出的话子线程依然正常运转。如果进程退出了，那么它所有的线程都会退出，所以子线程也就退出了。 主线程退出，进程等待所有子线程执行完毕后才结束 进程启动后会默认产生一个主线程，默认情况下主线程创建的子线程都不是守护线
【Linux】Linux进程控制
如风逝去
04-03 343
1. 学习进程创建, 等待, 终止. 使用代码实现. （1）进程创建进程创建有两种方式，一种是使用fork()函数，另一种是使用vfork()函数下来对这两个函数进行逐一介绍：fork函数介绍：在linux中fork()函数是一种非常重要的函数，它从已有的函数中创建一个新的进程。新进程为子进程，而原进程为父进程。函数原型：#include&lt;unistd.h&gt;pid_t fork(voi...
Linux 进程回收
qq_40944811的博客
03-16 247
wait
Linux系统【三】回收子进程
T_T233333333的博客
03-26 248
孤儿进程 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，则称init进程领养孤儿进程。 系统中有两个init进程，一个是root用户的，一个是当前用户的，root用户的init进程编号一般是１ 僵尸进程 进程终止，父进程不进行回收，自己成残留资源(PCB)存放在内核中，变成僵尸进程。 子进程死亡以后会将自己占用的内存（4G）释放，但是会将死亡信息放在自己的PCB中，希...
linux 强制回收fd,深入学习fd泄露问题
最新发布
06-02
在 Linux 中，每个进程都有一个文件描述符表（File Descriptor Table），该表用于管理进程打开的文件及其 I/O 操作。当进程使用完一个文件描述符后，应该及时关闭该文件描述符，否则会出现文件描述符泄露的问题。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

是北豼不太皮吖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值