Linux 进程信号

最新推荐文章于 2023-08-16 20:41:54 发布
最新推荐文章于 2023-08-16 20:41:54 发布
阅读量410 收藏
点赞数
分类专栏： Linux 操作系统 文章标签： linux c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sky_Lee_1/article/details/131379112
版权

Linux 进程信号

查看信号列表的方式

可以使用 kill -l指令查看信号列表：

在这里插入图片描述

信号的产生

通过终端按键产生信号

常见的按键组合和相应的信号：

  • Ctrl+C (SIGINT): 发送SIGINT信号
  • Ctrl+\ (SIGQUIT): 发送SIGQUIT信号，通常用于终止程序，并 生成core dump文件。
  • Ctrl+Z (SIGTSTP): 发送SIGTSTP信号，用于挂起程序的执行，将其放入后台运行。
  • Ctrl+D (EOF): 发送EOF（End of File）信号，表示输入流已经结束。
CoreDump

Core Dump（核心转储）是指在程序发生严重错误时，操作系统将程序的内存状态保存到一个特殊的文件中，以便进行后续的调试和分析。核心转储文件通常称为core文件。

当程序发生严重错误，比如段错误（Segmentation Fault）或其他致命错误时，操作系统会捕获这些错误，并生成一个core文件。该文件包含了导致程序崩溃的内存状态，包括程序代码、堆栈信息、寄存器状态以及其他相关的调试信息。

由于 coredump 中可能会包含敏感信息，不安全，并且生成 coredump 文件还会占据很大的磁盘空间，因此，生成 coredump 文件默认是禁用的

在开发时，可以通过设置ulimit来启用。通常情况下，core文件会被保存在当前工作目录下，并以core或者core.<进程ID>的文件名格式命名。

在这里插入图片描述

可以看到，此时的 core file size = 0，可以使用 ulimit -c 指令来设置文件的大小：

在这里插入图片描述

实例

编写一个访问空指针的程序：

int main(void)
{
    int *p = NULL;
    *p = 1;
}

运行后，查看 coredump 文件：

在这里插入图片描述

由软件条件产生的信号

在 Linux 进程通信 中，介绍过 SIGPIPE 信号，它是一种软件条件产生的信号

接下来主要介绍 SIGALRM 信号

alarm 系统调用

alarm 函数是一个用于设置定时器的系统调用。它允许我们在指定的时间间隔后接收一个SIGALRM信号，从而可以在程序中实现定时操作。

使用alarm函数需要包含头文件<unistd.h>。函数原型如下：

unsigned int alarm(unsigned int seconds);

  • seconds参数指定定时器的时间间隔，单位为秒。当定时器到期时，将发送一个SIGALRM信号给调用进程。

  • alarm函数的返回值为之前设置的定时器剩余的时间。

void sigHandler(int signum)
{
    printf("Received SIG signal\n");
}

int main(void)
{
    signal(SIGALRM, sigHandler);
    unsigned s0 = alarm(10); // 0
    printf("%d\n", s0);

    unsigned s1 = alarm(3);  // s1 = 10，重设闹钟
    printf("%d\n", s1);
    sleep(1);

    unsigned s2 = alarm(1); // 3 - 1 = 2
    printf("%d\n", s2);
    
    time_t startTime = time(NULL);
    sleep(10); // 在睡了 1s 后，内核发出 SIGALRM 信号给进程，进程被唤醒
    time_t endTime = time(NULL);
    printf("Sleeped for %lf seconds.\n", difftime(endTime, startTime));
    return 0;
}

输出：

在这里插入图片描述

信号捕捉

在刚才的例子中，有一个 void sigHandler(int signum) 函数，它是一个用于捕捉信号的函数

但是，光有这个函数是不能捕捉到信号的，还需要「注册」

怎么注册捏？

signal 系统调用

signal函数是一个用于处理信号的系统调用。它允许我们为特定的信号指定信号处理函数，以定义在接收到信号时需要执行的操作。

使用signal函数需要包含头文件<signal.h>。函数原型如下：

void (*signal(int signum, void (*handler)(int)))(int);

  • signum参数指定要处理的信号的编号，可以是预定义的信号宏（如SIGINT、SIGALRM等）或自定义的信号。

  • handler参数是一个函数指针，指向用户定义的信号处理函数。信号处理函数的原型为void handler(int signum)，其中signum是接收到的信号编号。

  • signal函数返回一个函数指针，指向之前注册的信号处理函数。如果之前没有注册过该信号的处理函数，则返回SIG_DFL（默认的信号处理行为）。

使用signal函数的一般流程如下：

  1. 调用signal函数，并传递要处理的信号编号和相应的信号处理函数，这一步就是前面提到的「注册」

  2. 当程序接收到指定的信号时，操作系统会调用相应的信号处理函数。

  3. 信号处理函数执行特定的操作，可以是自定义的任何有效函数。

  4. 信号处理函数执行完毕后，程序 将继续执行原来的流程。

由硬件异常产生信号

下面是一个空指针异常（也就是硬件异常）产生 SIGSEGV 信号的例子：

void sigHandler(int signum)
{
    sleep(1);
    printf("Received SIG signal\n");
}

int main(void)
{
    printf("[%d]\n", getpid());
    signal(SIGSEGV, sigHandler);
    sleep(1);

    int *p = NULL;
    *p = 1;

    while(1); // 会一直输出 "Received SIG signal"，因为 SIGSEGV 是一种严重错误
    // 操作系统会反复发送SIGSEGV信号，以确保程序得到处理。
    return 0;
}

输出：

在这里插入图片描述

信号集

信号的状态

一般来说，信号有两种状态：

  • 未决态（Pending），即信号从产生到递达之间的状态
  • 递达态（Delivery）

其中：

  • 进程可以阻塞（Block）一个信号
  • 一个信号若被阻塞，则其在产生时就处于未决状态
  • 阻塞与忽略不同，只要信号被阻塞，就不会递达，而忽略是信号 递达以后 ，进程可以选择的操作

信号在内核的表示

在这里插入图片描述

在这张图中：

  • 每个信号均有一个 block 位，pending 位，还有一个 hander 位，这个 hander 是一个指向处理当前信号的函数指针
  • 一个信号产生时，OS 会将 pending 位「置位」，直到该信号递达时，将 pending 位「复位」
  • 对于图中的 SIGHUP，它没有阻塞，也没有产生过，处理函数为默认函数 SIG_DFL
  • 对于图中的 SIGINT，它被阻塞，且产生过，因此处于未决态，处理函数为 SIG_IGN，即忽略该信号
  • 对于图中的 SIGQUIT，它被阻塞，但没有产生过，一旦产生，将处于未决态，直到进程主动取消对它的阻塞，处理函数为用户自定义的函数，即 sighandler

sigset_t 类型

从上面的分析，我们发现：无论是 未决 还是 阻塞，对于一个信号，只需要一个 bit 位就能反应该信号是否处于 未决（或阻塞）态，因此，一个进程的 阻塞信号集 和 未决信号集 都可以用 sigset_t 这种数据类型（其实就是无符号整型）来存储

在这里插入图片描述

注意： 不要试图直接打印一个 sigset_t 类型的数据，这通常是没有任何意义的

信号集操作函数

常见的信号集操作函数如下：

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember(const sigset_t *set, int signo);
  • sigemptyset 函数用于将信号集 set 复位，表示不含任何信号
  • sigfillset 函数用于将信号集 set 置位，表示包含所有系统支持的信号
  • sigaddset 函数用于添加一个信号到 set 中，signo 是要添加的信号的编号
  • sigdelset 函数用于在 set 中删除一个信号，signo 是要删除的信号的编号
  • sigismember 函数用于判断一个信号是否在信号集 set 中，signo 是要查询的信号的编号
sigprocmask

sigprocmask 函数用于设置或修改进程的屏蔽信号集。

函数原型：

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

参数说明：

  • how：用于指定信号屏蔽字的设置方式，可取三个值：
    • SIG_BLOCK：将 set 中的信号添加到当前信号屏蔽字中，相当于 |= 操作。
    • SIG_UNBLOCK：从当前信号屏蔽字中移除 set 中的信号，相当于 mask = mask & ~set。
    • SIG_SETMASK：将当前信号屏蔽字替换为 set，相当于 mask = set。
  • set：指向一个 sigset_t 类型的数据结构，用于设置新的信号屏蔽字。
  • oldset：可选参数，用于获取调用该函数前的旧信号屏蔽字。

函数返回值：

  • 成功：返回 0。
  • 失败：返回 -1，并设置相应的错误码。

使用 sigprocmask 函数可以实现以下操作：

  • 阻塞或解除阻塞特定信号：通过设置信号屏蔽字，可以选择阻塞或解除阻塞某些信号的传递。
  • 保护临界区：在进入临界区前，通过设置信号屏蔽字来阻塞某些信号，以避免在关键时刻被中断。
  • 防止竞态条件：通过阻塞某些信号来避免并发执行引起的竞态条件。

注意： sigprocmask 函数只会影响当前进程的信号屏蔽字，对其他进程无影响。

sigpending

sigpending 函数用于读取进程的未决信号集

#include <signal.h>
int sigpending(sigset_t *)

实例

void printSigset(sigset_t sigSet)
{
    char buff[33];
    // 1 ~ 31
    // for (int curSig = SIGHUP; curSig <= SIGUSR2; ++curSig) // 不同的机器，SIGUSER2 的编号不同，在 macOS 上，该信号的编号为 31
    for (int curSig = 1; curSig <= 31; ++curSig)
    {
        // if ((sig >> curSig) & 1)
        if(sigismember(&sigSet, curSig))
            buff[curSig] = '1';
        else buff[curSig] = '0';
    }
    buff[0] = '0';
    buff[32] = '\0';
    printf("%s\n", buff);
}

int main(void)
{
    sigset_t blockSigSet, oldSigSet;
    sigemptyset(&blockSigSet); // 初始化信号，置 0

    sigaddset(&blockSigSet, SIGINT); // 将 SIGINT（中断信号）加入至阻塞信号集
    // 将当前进程的阻塞信号集设置为 blockSigSet ，并将进程原来的阻塞信号集存放在 oldSigSet 中
    sigprocmask(SIG_BLOCK, &blockSigSet, &oldSigSet);

    printf("Original block signal set: ");
    printSigset(oldSigSet); // 0000 ...
    printf("Current block signal set: ");
    printSigset(blockSigSet); // 0010 ...

    sigset_t pendingSigSet;
    while (1)
    {
        sigpending(&pendingSigSet); // 获取未决信号集
        printSigset(pendingSigSet);
        sleep(1);
    }
}

输出：

在这里插入图片描述

捕捉信号再探

内核捕捉信号的过程

在这里插入图片描述
引用自 博主Mindtechnist

例如，用户程序注册了 SIGQUIT 信号的处理函数 sigaction_user。

当前正在执行 main函数,这时发生中断或异常 切换到内核态 。

在 中断处理完毕 后要返回用户态的main函数之前 检查到有信号 SIGQUIT递达 。

内核决定 返回用户态 后不是恢复main函数的上下文继续执行,而是 执行 sigaction_user 函数 。

sigaction_user 和 main 函数使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程。

sigaction_user 函数返回后自动 执行特殊的系统调用 sigreturn 再次进入内核态 。

如果没有新的信号要递达,这次再 返回用户态就是恢复 main函数的上下文继续执行 了。

可以发现，如果使用默认的信号处理函数，状态切换两次

如果使用自定义的信号处理函数，状态切换四次

引入信号集

void printSigset(sigset_t sigSet);

void sigHandler(int signum)
{
    printf("---In function sigHander---\n");
    if(signum == SIGINT)
        printf("Received SIGINT signal\n");
    else if(signum == SIGSEGV)
        printf("Received SIGSEGV signal\n");

    sigset_t curBlockSet;
    sigset_t curPendingSet;

    sigemptyset(&curBlockSet);
    sigemptyset(&curPendingSet);

    sigprocmask(SIG_BLOCK, NULL, &curBlockSet); // 由于不修改阻塞信号集，因此获取的是当前阻塞信号集
    sigpending(&curPendingSet);

    printf("Cur Block Signal Set:\n");
    printSigset(curBlockSet);
    printf("Cur Pending Signal Set:\n");
    printSigset(curPendingSet);
    sleep(3);
    // exit(0);
}

void printSigset(sigset_t sigSet)
{
    char buff[33];
    // 1～31
    // for (int curSig = SIGHUP; curSig <= SIGUSR2; ++curSig) // 不同的机器，SIGUSER2 的编号不同，在 macOS 上，该信号的编号为 31
    for (int curSig = 1; curSig <= 31; ++curSig)
    {
        // if ((sig >> curSig) & 1)
        if(sigismember(&sigSet, curSig))
            buff[curSig] = '1';
        else buff[curSig] = '0';
    }
    buff[0] = '0';
    buff[32] = '\0';
    printf("%s\n", buff);
}

int main(void)
{
    printf("---In function main---\n");
    signal(SIGSEGV, sigHandler); // 注册 SIGSEGV 信号
    signal(SIGINT, sigHandler);  // 注册 SIGINT 信号

    sigset_t curBlockSet;
    sigemptyset(&curBlockSet);
    sigprocmask(SIG_BLOCK, NULL, &curBlockSet);
    printf("Cur Block Signal Set:\n");
    printSigset(curBlockSet);
    sleep(1);

    int *p = NULL;
    *p = 1;

    while(1);

    return 0;
}

输出：

在这里插入图片描述

为什么发出 SIGINT 信号后，在 sigHandler 函数中，阻塞信号集包含 SIGINT 信号，即使我们之前并没有将其添加到阻塞信号集中？

原因是，当信号处理函数执行时，内核会自动将相应的信号添加到阻塞信号集中，以防止同一信号的重复递送。这样做是 为了保护信号处理函数不会被同一信号中断 。因此，当 SIGINT 信号处理函数 sigHandler 执行时，阻塞信号集中可能包含 SIGINT 信号

现在请你结合之前讲的内容，分析一下，在 sigHandler 函数中，为什么 SIGSEGV 一直出现在阻塞信号集中？

此外，为什么未决信号集中，始终不包含 SIGINT 和 SIGSEGV 信号？

你想想，为什么会从 main 函数切换到 sigHandler 函数？肯定是因为程序收到了 SIGINT 或者 SIGSEGV 信号啊，而未决信号集是指：从信号产生到信号递达到过程

在打印未决信号集的时候，信号已经递达了，内核会自动将该信号从未决信号集中移除。这样做是为了确保每个信号只被处理一次，防止信号的重复触发。

所以，打印的未决信号集不包含这两个信号

Volatile 关键字

volatile 是一个关键字，用于 告诉编译器不要对被修饰的变量进行优化。它通常 用于修饰那些可能被程序之外的因素修改的变量，以确保每次访问该变量都从内存中读取最新的值，而不是使用缓存的值。

来看一个与信号相关的例子：

int flag = 0;

void sigHandler(int signum)
{
    printf("Changing flag from 0 to 1\n");
    flag = 1;
}

int main(void)
{
    time_t startTime = time(NULL);
    signal(SIGINT, sigHandler);
    while(!flag);
    time_t endTime = time(NULL);
    printf("Process quit normaly with running time %lf s.\n", difftime(endTime, startTime));
    return 0;
}

可以看出，只要我们不向该进程发出 SIGINT 信号，它就会一直执行，直到我们发出 SIGINT 信号，被 sigHander 捕获

在这里插入图片描述

如果我们在编译时，加上 -O2 选项（优化）呢？

在这里插入图片描述

可以发现，无论怎么发出 SIGINT 信号，进程都不会退出！

为啥？

编译器在进行优化时，会尽力利用各种优化策略来提高程序的执行效率。其中一项优化策略是基于所谓的局部性原理，即认为在某个时间段内访问的数据很可能在不久的将来再次被访问。

在循环中使用的变量，如果编译器能够确定它们在循环体内部不会被修改，就可以将其缓存到寄存器或者CPU的高速缓存中，以减少对内存的读取操作。这样可以提高程序的执行效率，因为访问寄存器或高速缓存比访问内存要快得多。

在这里，编译器判断 flag 并不会在循环中改变，因此，会把 flag 放在寄存器中缓存，以换取更快的执行速度

这种优化行为导致了信号处理函数中对全局变量的修改无法被循环条件及时检测到，因为 循环条件使用了被缓存的旧值 ，而 不是从内存中读取最新的值 。

即使信号处理函数修改了全局变量的值，由于是在内存修改，寄存器的 flag 仍然是一开始缓存的 0，因此，循环仍然会继续执行。

通过使用 volatile 关键字修饰变量，可以告诉编译器不要对这个变量进行优化，每次访问都从内存中读取最新的值。这样可以确保循环条件能够及时检测到变量的变化，从而正确退出循环。

加上 volatile 关键字，即 volatile int flag = 0;：

在这里插入图片描述

Sky_Lee_1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Linux 信号
sqjddb的博客
03-17 1353
>>认识信号 >>产生信号 >>处理信号 >>信号在内核中的表示 >>信号集处理函数 >>信号捕捉
Linux进程信号
CL2426的博客
10-29 906
还有一点点东西
【Linux篇】进程退出
m0_66492811的博客
08-05 297
进程退出
Linux内核：进程管理——进程异常退出
m0_74282605的博客
04-11 3518
第二类情况是进程非法操作触发处理器异常，然后异常处理函数在内核态向进程发送信号，这种情况下发送的信号是同步信号，信号的到来与进程的运行是同步的。外设中断是系统外围设备发送给处理器的中断，它通知处理器 I/O 操作的状态，这种异常是外设的异步异常，与具体进程无关，所以它们不会造成进程的异常退出。本文讨论的异常是指 soft interrupts，是进程非法操作所导致的处理器异常，这类异常是进程执行非法操作所产生的同步异常，比如内存保护异常，除 0 异常，缺页异常等等。这类问题中最常见的就是内存非法访问。
Linux——进程退出
weixin_69283129的博客
05-30 2123
了解Linux种进程的退出的3种方式，退出码的意义
Linux 进程信号：信号的概念、生命周期、产生流程、阻塞
01-09
我们在linux下常用的kill命令就是通过向进程发送一个信号来使进程中断，我们可以通过kill -l来查看信号的种类 信号的种类 可以看到32和33号信号是不存在的，并且1-31是有具体名称的，而34号及之后的都是以SIGTMIN+...
Linux进程通信之信号
最新发布
01-07
sigaction函数的具体介绍
打印linux进程信号信息。_Python_下载.zip
04-27
打印linux进程信号信息。_Python_下载.zip
Linux下的进程信号处理过程
01-27
键盘产生键盘产生的信号只能发送给前台进程。例如：[Ctrl+C]… 程序异常除0错误。除0错误会导致硬件错误。 coredumped（核心转储）：当进程异常退出时，操作系统会将该进程发生异常退出之前在内存中的数据存储至硬盘...
Linux进程间通信–使用信号
01-11
同样的功能在Linux上是通过生成信号和捕获信号来实现的，运行中的进程捕获到这个信号然后作出一定的操作并最终被终止。 信号是UNIX和Linux系统响应某些条件而产生的一个事件，接收到该信号的进程会相应地采取一些...
linux——signal信号（SIGHUP、SIGINT、SIGQUIT、SIGILL、SIGTR
u011029104的专栏
07-02 1万+
SIGHUP /* hangup */ SIGHUP，hong up ，挂断。本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各个作业, 这时它们与控制终端不再关联。 登录Linux时，系统会分配给登录用户一个终端(Session)。在这个终端运行的所有程序，包括前台进程组和 后台进程组，一般都属于这个 Session。当用户退出Linux登录时，前台进程组和后台有对终端输出的进程将会收到SIGHUP...
SIGTERM、SIGKILL、SIGINT和SIGQUIT的区别
热门推荐
Do one thing at a time, and do well.
12-11 4万+
1. SIGQUIT： 在POSIX兼容的平台，SIGQUIT是其控制终端发送到进程，当用户请求的过程中执行核心转储的信号。 SIGQUIT通常可以ctrl+ \。在Linux上，人们还可以使用Ctrl-4或虚拟控制台，SysRq yek。 2. SIGTERM： SIGTERM是杀或的killall命令发送到进程默认的信号。它会导致一过程的终止，但是SIGKILL信号不同，它
进程的终止和等待
u014801954的博客
01-01 867
目录 进程终止 如何获取退出码呢？ 进程退出方法有哪些？ 对于进程退出，内核OS做了什么？ 进程等待 为什么要进行进程等待？ 如何进行进程等待？ 什么是阻塞和非阻塞等待？
Linux中进程的退出
weixin_61701822的博客
02-02 3658
Linux进程退出
进程正常退出的条件是什么，如果不正常退出会引发什么问题
jijie_ming的博客
04-27 419
文件资源关闭器不能打开
Linux SIGQUIT 捕获
斧冰
12-15 400
test.c #include <stdio.h> #include <signal.h> void quit_handler(); int main(int argc, char ** argv) { sigset( SIGQUIT, quit_handler ); printf( "Process_pid=[%d]\n", getpid() ); while(1); return 0; } void quit_handler() {
Linux下的各种信号
qq_53395528的博客
08-16 704
（31）：错误的系统调用信号，在进程执行错误的系统调用时产生。（24）：超出 CPU 时间限制信号，在进程超出 CPU 时间限制时产生。（5）：跟踪/断点陷阱信号，当进程执行单步调试或遇到断点时产生。（21）：后台读取终端信号，在后台进程从控制终端读取数据时产生。（22）：后台写入终端信号，在后台进程向控制终端写入数据时产生。（25）：超出文件大小限制信号，在进程超出文件大小限制时产生。（7）：总线错误信号，当进程访问无效内存地址时产生。（8）：浮点异常信号，当进程执行浮点运算错误时产生。
Linux进程信号（上）
phenix_417的博客
04-23 408
argc和argv在环境变量章节有讲到(后面补)，是命令行的参数个数，和命令行分割后的结果 ，需要使用c语言的atoi把命令行参数变为整形的（pid和signo）。生活中有很多信号：红绿灯，闹钟，警灯，外卖员的电话等等。将二号信号的动作更改为我们用户自定义的动作，而二号信号就是ctrl +c，或者kill -2，当输入ctrl+c的时候没有终止进程，而是执行我们的动作。Linux中采用位图，用0和1表示信号的有无，通过不同的比特位为1表示不同的信号。共61个信号，没有0信号，32信号，33信号。
Linux进程被信号杀死后退出状态码(exit code)的分析
二进制模----细微行动改变影响世界
10-24 3207
https://blog.csdn.net/halfclear/article/details/72783900
linux进程检测关机信号
06-07
在Linux中，进程可以通过注册信号处理程序来处理不同类型的信号。当系统接收到关机信号（例如SIGINT、SIGTERM或SIGKILL）时，进程可以通过信号处理程序来捕获该信号并执行必要的清理操作。 为了检测关机信号，进程可以使用如下代码： ``` #include <signal.h> void shutdown_handler(int signal) { // 执行清理操作 } int main() { // 注册信号处理程序 signal(SIGINT, shutdown_handler); signal(SIGTERM, shutdown_handler); signal(SIGKILL, shutdown_handler); // 程序主逻辑 // ... return 0; } ``` 在上面的代码中，我们使用signal函数来注册信号处理程序。我们将SIGINT、SIGTERM和SIGKILL信号绑定到shutdown_handler函数。当系统接收到这些信号时，就会执行该函数中的代码。 在shutdown_handler函数中，我们可以编写必要的清理操作，例如关闭文件、释放内存等。这样，在进程接收到关机信号时，就可以执行这些清理操作，确保程序正常关闭。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值