[ Linux ] 进程间通信之共享内存

最新推荐文章于 2024-02-29 11:25:21 发布
最新推荐文章于 2024-02-29 11:25:21 发布
阅读量1.2k 收藏 10
点赞数 8
分类专栏： Linux 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58325487/article/details/128031836
版权

在上篇博文我们了解了通过管道完成进程间通信，我们了解匿名管道和命名管道，并且通过编码模拟实现使用了匿名管道和命名管道。我们知道要让进程间完成通信必须让这两个进程首先看到同一份资源，因此给予这个前提，本篇博文我们了解另外一种可以进程间通信的方式 -- 共享内存。

目录

1.system V共享内存

1.1共享内存原理的理解

共享内存示意图

1.2 共享内存编码

1.2.1 共享内存函数

1.2.2 删除共享内存

1.2.3 使用共享内存完成进程间通信

1.2.4 Cli写字符 Ser获取

附录:

ipcShmCli.cc

ipcShmSer.cc

comm.hpp

Log.hpp

makefile

1.system V共享内存

system V是一套标准，这是系统级别的接口。我们知道进程间通信的前提是：先让不同的进程看到同一份资源！

1.1共享内存原理的理解

首先我们来了解一下共享内存的原理：

我们在之前知道了一个进程由自己的tast_struct和进程的地址空间，那么其中对我们来讲tast_struct有指向自己的地址空间。我们知道进程地址空间内有栈区，堆区，数据区等等.....我们在动静态库中也知道我们可以把磁盘中的库加在到内存中通过页表映射到我们进程的进程地址空间中的共享区。其中共享库就在这里。而进程间通信一定至少有两个进程（如下图），那么这两个进程是毫无关系的，每一个进程都有自己的页表，也可以通过页表映射到自己的地址空间。假设今天有一个特性的接口，首先能够在物理内存中创建一份空间，然后各进程调用这个接口，将这份空间通过页表映射到自己进程的地址空间上。那么进程就可以通过自己的地址空间看到物理内存中的这份空间。因此各进程都可以看到物理内存中的同一份资源。此时对我们来讲这种机制就是共享内存。

共享内存示意图

1.2 共享内存编码

1.2.1 共享内存函数

  • shmget函数

功能：shmget是用来创建共享内存的

参数：

  1. key : 这个共享内存段的名字
  2. size : 共享内存的大小 建议设置成页（4KB）的整数倍
  3. shmflg ：由9个权限标志构成，他们的用法和创建文件时使用的mode模式表示是一样的

返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1

IPC_CREAT：这个参数就和命名管道一样，如果存在就不用再创建了就获取，如果不存在就创建之。

IPC_EXCL : 要和IPC_CREAT一起使用（按位或 | ），如果不存在指定的共享内存，就创建之；如果存在指定的共享内存就出错返回。能够保证如果shmget函数调用成功一定是一个全新的share memory共享内存！

这个共享内存是存在内核中的 内核会给我们维护共享内存的结构！共享内存也要被内核管理起来，先描述再组织。下面就是共享内促的内核数据结构：

struct shmid_ds {
 struct ipc_perm shm_perm; /* operation perms */
 int shm_segsz; /* size of segment (bytes) */
 __kernel_time_t shm_atime; /* last attach time */
 __kernel_time_t shm_dtime; /* last detach time */
 __kernel_time_t shm_ctime; /* last change time */
 __kernel_ipc_pid_t shm_cpid; /* pid of creator */
 __kernel_ipc_pid_t shm_lpid; /* pid of last operator */
 unsigned short shm_nattch; /* no. of current attaches */
 unsigned short shm_unused; /* compatibility */
 void *shm_unused2; /* ditto - used by DIPC */
 void *shm_unused3; /* unused */
};

那么我怎么知道共享内存属于存在还是不存在呢？

我们在上面知道共享内存要被内核管理再组织->struct shmid_ds{} -> struct ipc_perm -> key(shmget) 共享内存的唯一值！而通过这个key我们就能表示这个共享内存。因此如果一个共享内存存在，就有一个key值，我们只要拿到这个key值，是不是就相当于拿到了共享内存。因此为了更好的进行控制，这个key值由我们的用户来提供。我们可以通过key值来标定这个共享内存，在内核中让不同的进程看到同一份共享内存做法是让他们拥有同一个key值即可。

这个key我们一般要使用ftok来生成。

我们使用一下来看看效果：

comm.hpp

#pragma once

#include <iostream>
#include <cstdio>
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

using namespace std;

#define PATH_NAME "/home/Lxy/code"
#define PROJ_ID 0x14
#define MEM_SIZE 4096



key_t CreatKey()
{
    key_t key = ftok(PATH_NAME,PROJ_ID);
    if(key < 0 )
    {
        cerr<< "ftok:" << strerror(errno) <<endl;
        exit(1);
    }

    return key;
}


IpcShmCli.cc

#include "comm.hpp"
#include "Log.hpp"

int main()
{
    key_t key = CreatKey();
    cout<<"key :" <<key << endl;
    return 0;
}


IpcShmSer.cc

#include "comm.hpp"
#include "Log.hpp"

//充当创建共享内存的角色
int main()
{
    key_t key = CreatKey();
    Log() << "key " << key <<endl;

    //创建一个全新的共享内存
    int shmid = shmget(key,MEM_SIZE,IPC_CREAT|IPC_EXCL);
    if(shmid < 0)
    {
        Log()<<"shmget:" << strerror(errno) << endl;
        return 2;
    }

    Log() << "creat shm success ,shmid: " << shmid << endl;

    return 0;
}


Log.hpp

#pragma once

#include <iostream>
#include <ctime>

std::ostream &Log()
{
    std::cout << "For Debug | " << "timestamp: " << (uint64_t)time(nullptr) << " ";
    return std::cout;
}


makefile

.PHONY:all
all: ipcShmCli ipcShmSer

ipcShmCli:IpcShmCli.cc
	g++ -Wall -o $@ $^ -std=c++11

ipcShmSer:IpcShmSer.cc
	g++ -Wall -o $@ $^ -std=c++11
	
.PHONY:clean
clean:
	rm -f ipcShmCli ipcShmSer

当我们第二次运行ipcShmSer时，此时共享内存已经存在了，因此IPC_EXCL会失败返回，我们查看退出码果然是2，因此system V下的共享内存生命周期是随内核的！而且共享内存如果不显示删除的话，只有等OS重启才能删除。因此接下来，我们要学习一个 共享内存的删除接口

1.2.2 删除共享内存

1.用指令来删除

要删除共享内存，首先我们要查看共享内存是否存在，我们可以在命令行输入

ipcs -m

当我们查看到我们当前系统所有的共享内存后我们在命令行输入下面这条指令就可以删除指定shmid的共享内存

ipcrm -m shmid

此时我们将共享内存删除后，我们再运行ipcShmSer就可以再次创建一个新的共享内存了

2.用系统接口来删除

  • shmctl

功能： 用于控制共享内存

参数：

  1. shmid : 由shmget返回的共享内存标识码
  2. cmd：将要采取的动作（有三个可取值） 其中IPC_RMID 为删除共享内存
  3. buf : 指向一个保存着共享内存的模式状态和访问权限的数据结构

返回值： 成功返回 0 ； 失败返回 -1

话不多说 我们直接把用在我们刚刚所写的ipcShmSer.cc中

#include "comm.hpp"
#include "Log.hpp"

//充当创建共享内存的角色
int main()
{
    key_t key = CreatKey();
    Log() << "key " << key <<endl;


    Log() << "create share memory begin! \n";
    sleep(5);
    //创建一个全新的共享内存
    int shmid = shmget(key,MEM_SIZE,IPC_CREAT|IPC_EXCL);
    if(shmid < 0)
    {
        Log()<<"shmget:" << strerror(errno) << endl;
        return 2;
    }

    Log() << "creat shm success ,shmid: " << shmid << endl;


    //使用
    sleep(5);


    //删除
    shmctl(shmid,IPC_RMID,nullptr);
    Log()<<"delete shm : " << shmid << "sucess \n";
    sleep(5);
    return 0;
}

为了能够主观感受到共享内存从创建到删除的全过程，我们写一个监控脚本来每隔1秒查看一下

while :; do ipcs -m; sleep 1; done

1.2.3 使用共享内存完成进程间通信

在上述的准备工作中，我们把共享内存的原理，已经共享内存的创建，删除都已经能够完成了，接下来到了最重要的地方，就是不同进程间要使用共享内存完成进程间通信.此时共享内存在内存中创建完成了，我们需要将物理内存中的共享内存挂接到进程的地址空间内。这里就需要使用另外一个函数

  • shmat

功能：将共享内存连接到进程地址空间

参数：

  1. shmid : 共享内存标识符
  2. shmaddr ：指定连接的地址
  3. shmflg ： 它的两个可能取值是SHM_RND 和 SHM_RDONLY

返回值： 成功返回一个指针，指向共享内存的第一个节；失败返回-1

那么我们直接在代码中使用：

//使用
    //1.将共享内存挂接到进程地址空间内
    char * str = (char*)shmat(shmid,nullptr,0);
    Log()<< " attach shm : " << shmid << "sucess !\n";

那么如果我们挂接之后不想用了我们要去关联，我们可以使用下面这个函数

  • shmdt函数

功能：将共享内存段与当前进程脱离

参数：

  1. shmaddr: 由shmat所返回的指针

返回值：成功返回0；失败返回-1

注意：将共享内存段与当前进程脱离不等于删除共享内存段

我们直接在代码中体现

//使用
    //1.将共享内存挂接到进程地址空间内
    char * str = (char*)shmat(shmid,nullptr,0);
    Log()<< " attach shm : " << shmid << "sucess !\n";
    
    //2.不想用就去关联
    shmdt(str);
    Log()<< " detach shm : " << shmid << "sucess !\n";
    sleep(5);

现在我们再来写ipcShmCli.cc

#include "comm.hpp"
#include "Log.hpp"

int main()
{
    //创建相同的Key值
    key_t key = CreatKey();
    Log() <<"key :" <<key << endl;

    //获取 shmid 
    int shmid = shmget(key,MEM_SIZE,IPC_CREAT);
    if(shmid < 0)
    {
        Log()<<"shmget:" << strerror(errno) << endl;
        return 2;
    }

    //获取成功之后挂接
    char* str = (char*)shmat(shmid,nullptr,0);

    //用它  
    sleep(5);


    //去关联
    shmdt(str);

    //不用删除共享内存 共享内存的创建和销毁全权由Ser管理
    return 0;
}

当我们同时将Cli和Ser同时挂接到了一个共享内存上时，此时保证了两个进程已经同时看到了同一份资源，接下来我们来写Cli的操作。这里需要注意的是，我们把共享内存是映射到了我们进程地址空间上了（堆栈之间），因此对于每一个进程来说，挂接到自己的上下文中的共享内存是属于自己的空间的。类似于堆空间或者栈空间，因此可以被用户直接使用，不需要调用任何的系统接口！

1.2.4 Cli写字符 Ser获取

当我们建立好共享内存并且同时挂接到两个进程之后，我们可以进行进程间通信了，我们首先可以完成一个较为简单的通信。我们让Cli往共享内存里面写26个英文字符，每个一秒写一个，让Ser每隔一秒读取一次共享内存里面的内容。这样当我们同时启动程序的时候，我们应该看到的现象是Ser每隔一秒在屏幕打印出英文字符（从A开始到Z），每隔一秒多一个字符并换行。我们运行起来看看结果：

   //用它  
    //没有使用任何的系统调用接口
    int cnt = 0;
    while(cnt <= 26)
    {
        str[cnt] = 'A' + cnt;
        ++cnt;
        str[cnt] = '\0';
        sleep(1);
    }

   //2.使用
    while(true)
    {
        printf("%s\n",str);
        sleep(1);
    }

运行结果：

因此共享内存因为自身的特性，没有任何访问控制！共享内存被进程双方直接看到，可以直接通信，属于用户双方，但是不安全！因此共享内存挂接到两个进程的时候，进程1向共享内存写入内容是，进程2立马就可以看到。因此共享内存是所有进程间通信中速度最快的！

完成上面的功能后，我们知道了在Cli中写入字符，Ser可以立马获取。因此我们只需要稍稍修改Cli的代码就可以传输我们自定义的信息了。我们一起来看看代码的实现。

#include "comm.hpp"
#include "Log.hpp"

int main()
{
    //创建相同的Key值
    key_t key = CreatKey();
    Log() <<"key :" <<key << endl;

    //获取 shmid 
    int shmid = shmget(key,MEM_SIZE,IPC_CREAT);
    if(shmid < 0)
    {
        Log()<<"shmget:" << strerror(errno) << endl;
        return 2;
    }

    //获取成功之后挂接
    char* str = (char*)shmat(shmid,nullptr,0);

    //自定义输入
    while(true)
    {
        printf("Please Enter# ");
        fflush(stdout);
        ssize_t s = read(0,str,MEM_SIZE);
        if(s > 0)
        {
            str[s] = '\0';
        }
    }



    //去关联
    shmdt(str);

    //不用删除共享内存 共享内存的创建和销毁全权由Ser管理
    return 0;
}

这种通信方式就是共享内存！

（本篇完）

附录:

ipcShmCli.cc

#include "comm.hpp"
#include "Log.hpp"

int main()
{
    //创建相同的Key值
    key_t key = CreatKey();
    Log() <<"key :" <<key << endl;

    //获取 shmid 
    int shmid = shmget(key,MEM_SIZE,IPC_CREAT);
    if(shmid < 0)
    {
        Log()<<"shmget:" << strerror(errno) << endl;
        return 2;
    }

    //获取成功之后挂接
    char* str = (char*)shmat(shmid,nullptr,0);

    while(true)
    {
        printf("Please Enter# ");
        fflush(stdout);
        ssize_t s = read(0,str,MEM_SIZE);
        if(s > 0)
        {
            str[s] = '\0';
        }
    }

    //用它  
    //没有使用任何的系统调用接口
    // int cnt = 0;
    // while(cnt <= 26)
    // {
    //     str[cnt] = 'A' + cnt;
    //     ++cnt;
    //     str[cnt] = '\0';
    //     sleep(1);
    // }


    //去关联
    shmdt(str);

    //不用删除共享内存 共享内存的创建和销毁全权由Ser管理
    return 0;
}

ipcShmSer.cc

#include "comm.hpp"
#include "Log.hpp"

//充当创建共享内存的角色
int main()
{
    key_t key = CreatKey();
    Log() << "key " << key <<endl;


    Log() << "create share memory begin! \n";
    //sleep(5);
    //创建一个全新的共享内存
    int shmid = shmget(key,MEM_SIZE,IPC_CREAT|IPC_EXCL | 0666);
    if(shmid < 0)
    {
        Log()<<"shmget:" << strerror(errno) << endl;
        return 2;
    }

    Log() << "creat shm success ,shmid: " << shmid << endl;

    sleep(2);
    //使用
    //1.将共享内存挂接到进程地址空间内
    char * str = (char*)shmat(shmid,nullptr,0);
    Log()<< " attach shm : " << shmid << "sucess !\n";
    //sleep(2);

    //2.使用
    while(true)
    {
        //有数据了再读
        printf("%s\n",str);
        //sleep(1);
    }
    
    //2.不想用就去关联
    shmdt(str);
    Log()<< " detach shm : " << shmid << "sucess !\n";

    
    sleep(2);


    //删除
    shmctl(shmid,IPC_RMID,nullptr);
    Log()<<"delete shm : " << shmid << "sucess \n";
    //sleep(5);
    return 0;
}

comm.hpp

#pragma once

#include <iostream>
#include <cstdio>
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

using namespace std;

#define PATH_NAME "/home/Lxy/code"
#define PROJ_ID 0x14
#define MEM_SIZE 4096



key_t CreatKey()
{
    key_t key = ftok(PATH_NAME,PROJ_ID);
    if(key < 0 )
    {
        cerr<< "ftok:" << strerror(errno) <<endl;
        exit(1);
    }

    return key;
}

Log.hpp

#pragma once

#include <iostream>
#include <ctime>

std::ostream &Log()
{
    std::cout << "For Debug | " << "timestamp: " << (uint64_t)time(nullptr) << " ";
    return std::cout;
}

makefile

.PHONY:all
all: ipcShmCli ipcShmSer

ipcShmCli:IpcShmCli.cc
	g++ -Wall -o $@ $^ -std=c++11

ipcShmSer:IpcShmSer.cc
	g++ -Wall -o $@ $^ -std=c++11
	
.PHONY:clean
clean:
	rm -f ipcShmCli ipcShmSer
小白又菜
关注
  • 8
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
详解Linux进程间通信——使用共享内存
09-15
共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。这篇文章主要介绍了详解Linux进程间通信——使用共享内存，有兴趣的可以了解一下。
Python进程间通信之共享内存详解
01-20
前一篇博客说了怎样通过命名管道实现进程间通信，但是要在windows是使用命名管道，需要使用python调研windows api，太麻烦，于是想到是不是可以通过共享内存的方式来实现。查了一下，Python中可以使用mmap模块来实现这一功能。 Python中的mmap模块是通过映射同一个普通文件实现共享内存的。文件被映射到进程地址空间后，进程可以像访问内存一样对文件进行访问。 不过，mmap在linux和windows上的API有些许的不一样，具体细节可以查看mmap的文档。 下面看一个例子： server.py 这个程序使用 test.dat 文件来映射内存，并且分配了1024字节的大小，
linux进程间通信【共享内存】
最新发布
weixin_45476980的博客
02-29 699
关于共享内存的知识复盘
Linux进程间通信之共享内存
07-26
本文主要介绍Linux进程间通信中共享内存的知识，感兴趣的朋友可以看看。
进程间通信之共享内存
m0_70749276的博客
07-01 2124
共享内存实现进程间通信
共享内存(进程间的通信方式)
m0_68210771的博客
07-31 5677
共享内存，函数接口定义及代码演示
【共享内存】共享内存（Shared Memory）与进程通信
crr411422的博客
06-29 5253
共享内存作为一种高效的进程间通信机制，以其独特的优势在多进程环境中发挥着重要的角色。它允许多个进程直接访问同一块内存区域，从而实现了数据的快速共享和交换，显著提高了系统性能。然而，这也带来了数据同步和并发控制的挑战。我们需要结合锁、信号量等同步技术来解决这些问题。 总的来说，共享内存是一种强大而灵活的工具，但需要谨慎、有效地使用，以确保程序的正确性和稳定性。
十二、进程间通信——共享内存
weixin_54447296的博客
05-09 1872
共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。共享内存是一种用于实现进程间通信（IPC）的方法，不同进程通过访问同一块内存区域实现数据共享和交互。每个进程可以将自身的虚拟地址映射到物理内存中的特定区域，当不同进程将相同的物理内存区域与各自的虚拟地址空间关联时，这些进程就能实现通过共享内存来完成IPC。若某进程更改了共享内存区的内容，其它进程都会觉察到该区域的更改。
进程间通信【共享内存】
weixin_53230235的博客
01-09 1552
进程间通信 共享内存
共享内存——进程间通信C++代码实例
weixin_45977690的博客
04-02 2400
C++实现不同进程之间的内存共享通讯
进程间通信之--------共享内存
weixin_42910705的博客
04-26 702
在linux中，想要两个进程相互通信，我们有若干种方式，其中较为经典的方法就是共享内存。在此之前，让我们回顾一下通信的本质，通信的本质是在双方都看得见的区域内读写。而共享内存通信的本质是个啥呢？让我们先上图：可以看到，我们在物理内存中开辟了一个内存区，然后通过页表映射，让两个进程都能看见这块内存区域。
进程间通信--共享内存详解【Linux】
Mclecak的博客
04-30 1401
本文详细讲解了共享内存的原理和使用，并且通过实例代码角度来深度理解共享内存，下面就让我们开始吧。
进程间通信--共享内存
weixin_51503941的博客
06-03 411
缺点是，数据写入进程或数据读出进程中，需要附加的数据结构控制。任何一个缓存的数据被更新后，由于其他处理器也可能要存取，共享内存就需要立即更新，否则不同的处理器可能用到不同的数据。2）为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间。3）进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。功能：映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问。的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝。
【Linux】进程间通信之共享内存
weixin_56916549的博客
08-17 268
共享内存原理 共享内存相关函数及命令 创建或获取共享内存函数 查看共享内存命令 删除共享内存命令 将共享内存附加到进程的虚拟地址空间 将共享内存与进程进行分离 操作共享内存
【Linux】进程间通信——共享内存
qq_53830608的博客
11-11 1680
例2：进程A从键盘循环获取数据并拷贝到共享内存中，进程b从共享内存中获取并打印数据。要求进程a输入一次，进程b输出一次，a不输入，b就不输出。一般给0代表可读可写，可以给SHM_RDONLY 为只读模式，其他为读写。例1：进程A向共享内存写入数据，进程B从共享内存中读取数据并显示。A（./main)未输入时，B（./test）不输出（阻塞着）而输出的时候一直输出S内的数据，没有控制，会一直循环输出。正确流程是写入一次读取一次，不写入不读取。A输入end,A,B退出。A输入一个，B读取一个。
进程间通信--共享内存篇
qq_63412763的博客
12-15 1654
共享内存字面理解就是进程间共同享有的存储空间，不同于管道通信，共享内存就像是进程自己的空间一样，不像管道文件还得使用文件描述符去访问文件，通过文件交流信息。共享内存则是实时信息交流，几乎不存在信息的中间转换。那么共享内存在哪里呢？就真的是在每个进程中都保留一份么？也不是，开辟的共享内存在整个内存空间中独一份，但是可以通过页表映射到不同的进程中去，让各个进程都能够看到这份资源，实现通信
进程间通信——共享内存
weixin_66831846的博客
09-14 312
单独使用IPC_CREAT: 创建一个共享内存，如果共享内存不存在，就创建之，如果已经存在，获取已经存在的共享内存并返回。IPC_CREAT | IPC_EXCL: 创建一个共享内存，如果共享内存不存在，就创建之, 如果已经存在，则立马出错返回 -- 如果创建成功，对应的shm，一定是最新的！关于shmget( )的第一个参数key,是用于标识共享内存的唯一性，通过调用ftok( )使用一定的算法生成的。注意：共享内存的创建只需一个进程进行即可，其余要进行通信的进程，则需要获取共享内存。
linux进程间通信之共享内存
04-20
共享内存是一种进程间通信的方式，可以让不同的进程访问同一块物理内存。在 Linux系统中，使用共享内存需要借助于系统调用shmget、shmat、shmdt等函数来进行。可以通过设置共享内存区域的访问权限、大小、标识符等参数来创建和控制共享内存区域。当一个进程访问共享内存时，它需要先将其附加到自己的虚拟地址空间，然后才能进行读写操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小白又菜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值