linux IPC-互斥锁和条件变量

已于 2024-06-03 14:37:40 修改
阅读量1.5k 收藏 15
点赞数
分类专栏： linux IPC 文章标签： linux
于 2021-08-29 22:01:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37932504/article/details/119981906
版权

目录

1、互斥锁

1.1、PTHREAD_MUTEX_INITIALIZER

1.2、pthread_mutex_init()函数

1.3、pthread_mutex_destroy()函数

1.4、互斥锁类型

1.5、pthread_mutexattr_gettype()函数

1.6、pthread_mutexattr_settype()函数

1.7、pthread_mutexattr_init()函数

1.8、pthread_mutexattr_destroy()函数

1.9、pthread_mutexattr_getpshared()函数

1.10、pthread_mutexattr_setpshared()函数

1.11、pthread_mutex_lock()函数

1.12、pthread_mutex_trylock()函数

1.13、pthread_mutex_unlock()函数

2、条件变量

2.1、PTHREAD_COND_INITIALIZER

2.2、pthread_cond_init()函数

2.3、pthread_cond_destroy()函数

2.4、pthread_condattr_init()函数

2.5、pthread_condattr_destroy()函数

2.6、pthread_condattr_getpshared()函数

2.7、pthread_condattr_setpshared()属性

2.8、pthread_cond_wait()函数

2.9、pthread_cond_timedwait()函数

2.10、条件变量时钟

2.10.1、pthread_condattr_getclock()函数

2.10.2、pthread_condattr_setclock()函数

2.11、pthread_cond_signal()函数

2.12、pthread_cond_broadcast()函数

3、持有锁期间进程终止

4、死锁

1、互斥锁

互斥锁保护的是临界区，实际上保护的是在临界区中被操纵的数据。也就是说，互斥锁通常用于保护由多个线程或进程分享的共享数据。

互斥锁是协作性锁。这就是说，如果共享数据是一个链表，那么操纵该链表的所有线程都必须在实际操纵前获取该互斥锁。不过也没办法防止某个线程不首先获取该互斥量就操纵该链表。

1.1、PTHREAD_MUTEX_INITIALIZER

使用常量PTHREAD_MUTEX_INITIALIZER静态初始化互斥锁。

1.2、pthread_mutex_init()函数

互斥锁一个初始化。

#include<pthread.h>

int pthread_mutex_init(pthread_mutex_t *restrict mutex,  const pthread_mutexattr_t *restrict attr);

参数 mutex：要初始化的互斥锁。

参数 attr：指定互斥锁属性。如果该参数为空指针，那就使用默认属性。

返回值：成功则为0，出错则为正的Exxx值。

1.3、pthread_mutex_destroy()函数

摧毁一个互斥锁。

#include<pthread.h>

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数mutex：要摧毁的互斥锁。

返回值：成功则为0，出错则为正的Exxx值。

1.4、互斥锁类型

PTHREAD_MUTEX_NORMAL一种标准的互斥锁类型，不做任何的错误检查或死锁检测。如果线程试图对已经由自己锁定的互斥锁再次进行加锁，则发生死锁；互斥锁处于未锁定状态，或者已由其它线程锁定，对其解锁会导致不确定结果。
PTHREAD_MUTEX_ERRORCHECK

此类互斥锁会提供错误检查（这类互斥锁运行起来比较慢，因为它需要做错误检查，不过可将其作为调试工具，以发现程序哪里违反了互斥锁使用的基本原则）。

譬如这三种情况都会导致返回错误：

1）线程试图对已经由自己锁定的互斥锁再次进行加锁（同一线程对同一互斥锁加锁两次）

2）线程对由其它线程锁定的互斥锁进行解锁；

3）线程对处于未锁定状态的互斥锁进行解锁。

PTHREAD_MUTEX_RECURSIVE此类互斥锁允许同一线程在互斥锁解锁之前对该互斥锁进行多次加锁，然后维护互斥锁加锁的次数，把这种互斥锁称为递归互斥锁，但是如果解锁次数不等于加锁次数，则是不会释放锁的；所以，如果对一个递归互斥锁加锁两次，然后解锁一次，那么这个 互斥锁依然处于锁定状态，对它再次进行解锁之前不会释放该锁。
 
PTHREAD_MUTEX_DEFAULT

此 类 互 斥 锁 提 供 默 认 的 行 为 和 特 性（此类锁意在为互斥锁的实现保留最大灵活性 ） 。 使 用 宏 PTHREAD_MUTEX_INITIALIZER 初 始 化 的 互 斥 锁 ， 或 者 调 用 参 数 arg 为 NULL 的 pthread_mutexattr_init()函数所创建的互斥锁，都属于此类型。

注：PTHREAD_MUTEX_DEFAULT 类 型 互 斥 锁 的 行 为 与 PTHREAD_MUTEX_NORMAL 类型相仿。

1.5、pthread_mutexattr_gettype()函数

获取互斥锁属性类型。

#include <pthread.h>

int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);

参数 attr :指向 pthread_mutexattr_t 类型对象。

参数 type:保存获取的互斥锁类型属性。

返回值：成功返回0，否则返回错误指示错误。

1.6、pthread_mutexattr_settype()函数

设置互斥锁属性类型。

#include <pthread.h>

int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);

参数 attr :指向 pthread_mutexattr_t 类型对象。

参数 type:设置互斥锁类型属性。

返回值：成功返回0，否则返回错误指示错误。

1.7、pthread_mutexattr_init()函数

初始化一个互斥锁属性。

#include<pthread.h>

int pthread_mutexattr_init(pthread_mutexattr_t *attr);

参数 attr：要初始化的互斥锁的属性。

返回值：成功则为0，出错则为正的Exxx值。

1.8、pthread_mutexattr_destroy()函数

摧毁一个互斥锁属性。

#include<pthread.h>

int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

参数 attr：要摧毁的互斥锁的属性。

返回值：成功则为0，出错则为正的Exxx值。

1.9、pthread_mutexattr_getpshared()函数

获取互斥锁共享属性值。

#include<pthread.h>

int pthread_mutexattr_getpshared(const pthread_mutexattr_t
           *restrict attr, int *restrict pshared);

参数 attr：属性值。

参数 pshared：获取的共享属性值（返回值为PTHREAD_PROCESS_PRIVATE或PTHREAD_PROCESS_SHARED）。

返回值：成功则为0，出错则为正的Exxx值。

1.10、pthread_mutexattr_setpshared()函数

设置互斥锁共享属性值。

#include<pthread.h>

int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
    int pshared);

参数 attr：属性值。

参数 pshared：要设置的共享属性值，PTHREAD_PROCESS_PRIVATE或PTHREAD_PROCESS_SHARED

返回值：成功则为0，出错则为正的Exxx值

1.11、pthread_mutex_lock()函数

如果尝试给一个已由另外线程锁住的互斥锁上锁，那么将阻塞到该互斥锁解锁为止。

#include<pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);

参数 mutex：互斥锁 。

返回值：若成功，返回0，否则，返回错误编号。

1.12、pthread_mutex_trylock()函数

尝试获取互斥锁，如果互斥锁已锁住，那就返回一个EBUSY错误。

#include<pthread.h>

int pthread_mutex_trylock(pthread_mutex_t *mutex);

参数 mutex：互斥锁 。

返回值：若成功，返回0，否则，返回错误编号。

1.13、pthread_mutex_unlock()函数

释放一个互斥锁。

#include<pthread.h>

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数 mutex：互斥锁 。

返回值：若成功，返回0，否则，返回错误编号。

2、条件变量

条件变量用于等待。条件变量通常搭配互斥锁来使用， 是因为条件的检测是在互斥锁的保护下进行的， 也就是说条件本身是由互斥锁保护的， 线程在改变条件状态之前必须首先锁住互斥锁， 不然就可能引发线程不安全的问题。

给条件变量发送信号的代码大体如下：

pthread_mutex_lock(mutex);
设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(mutex);

测试条件并进入睡眠以等待该条件变为真的代码大体如下：

pthread_mutex_lock(mutex);
while(条件为假)
    pthread_cond_wait(cond,mutex);
修改条件
pthread_mutex_unlock(mutex);

2.1、PTHREAD_COND_INITIALIZER

使用常量PTHREAD_COND_INITIALIZER静态初始化条件变量。

2.2、pthread_cond_init()函数

初始化条件变量。

#include<pthread.h>

 int pthread_cond_init(pthread_cond_t *restrict cond,
           const pthread_condattr_t *restrict attr);

参数 cond：要初始化的条件变量

参数 attr：条件变量的属性。

返回值：成功则为0，出错则为正的Exxx值。

2.3、pthread_cond_destroy()函数

摧毁一个条件变量。

#include<pthread.h>

int pthread_cond_destroy(pthread_cond_t *cond);

参数 cond：要摧毁的条件变量

返回值：成功则为0，出错则为正的Exxx值。

2.4、pthread_condattr_init()函数

初始化条件变量属性值

#include<pthread.h>

int pthread_condattr_init(pthread_condattr_t *attr);

参数 attr：要初始化的条件变量属性

返回值：成功则为0，出错则为正的Exxx值。

2.5、pthread_condattr_destroy()函数

摧毁一个条件变量属性值。

#include<pthread.h>

int pthread_condattr_destroy(pthread_condattr_t *attr);

参数 attr：要摧毁的条件变量属性。

返回值：成功则为0，出错则为正的Exxx值。

2.6、pthread_condattr_getpshared()函数

获取条件变量的共享属性。

#include<pthread.h>

 int pthread_condattr_getpshared(const pthread_condattr_t *restrict attr,
           int *restrict pshared);

参数 attr：要获取的条件变量共享属性。

参数 pshared：用获取的共享属性值，PTHREAD_PROCESS_PRIVATE或PTHREAD_PROCESS_SHARED。

返回值：成功则为0，出错则为正的Exxx值。

2.7、pthread_condattr_setpshared()属性

设置条件变量的共享属性。

#include<pthread.h>

int pthread_condattr_setpshared(pthread_condattr_t *attr,
           int pshared);

参数 attr：要设置的条件变量属性。

参数 pshared：设置的共享属性值，PTHREAD_PROCESS_PRIVATE或PTHREAD_PROCESS_SHARED。

返回值：成功则为0，出错则为正的Exxx值。

2.8、pthread_cond_wait()函数

该函数原子的执行以下2个动作：

1）给互斥量解锁

2）把调用线程投入睡眠，直到另外某个线程就奔条件变量调用pthread_cond_signal。

注：pthread_cond_wait在返回前重新给互斥锁上锁！！！

注：pthread_cond_wait返回时，总是再次测试相应条件成立与否，因为可能发生虚假的唤醒：期待的条件尚不成立时的唤醒。

#include <pthread.h>

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);

参数 cond：要等待的条件变量

参数 mutex：对应的互斥锁

返回值：成功则为0，出错则为正的Exxx值。

2.9、pthread_cond_timedwait()函数

此函数允许线程就阻塞时间设置一个限制值。如果发生超时情况，该函数就返回ETIMEDOUT错误。

#include <pthread.h>

int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,const struct timespec *restrict abstime);

参数 cond：条件变量

参数 mutex：对应的互斥锁

参数 abstime：timespec结构，时间值是绝对时间。

返回值：成功则为0，出错则为正的Exxx值。

注：使用绝对时间而不是时间差的好处是，如果函数过早的返回了（也许是因为捕获了某个信号），那么同一个函数无需改变其参数中timespec结构的内容就能再次被调用。

2.10、条件变量时钟

CLOCK_REALTIME实时系统时间
CLOCK_MONONIC不带负跳数的实时系统时间
CLOCK_PROCESS_CPUTIME_ID调用进程的CPU时间
CLOCK_THREAD_CPUTIME_ID调用线程的CPU时间

2.10.1、pthread_condattr_getclock()函数

获取条件变量的时钟属性。

#include <pthread.h>

int pthread_condattr_getclock(const pthread_condattr_t *attr, clockid_t *id);

2.10.2、pthread_condattr_setclock()函数

设置条件变量的时钟属性。

#include <pthread.h>

int pthread_condattr_setclock(pthread_condattr_t *attr, clockid_t id);

2.11、pthread_cond_signal()函数

只唤醒等待在相应条件变量上的一个线程。

#include <pthread.h>

int pthread_cond_signal(pthread_cond_t *cond);

返回值：成功则为0，出错则为正的Exxx值。

2.12、pthread_cond_broadcast()函数

唤醒阻塞在相应条件变量上的所有线程。

注：考虑条件变量信号单播发送与广播发送的一种候选方式时坚持使用广播发送。如果所有等待者代码都编写确切，只有一个等待者需要唤醒，而且唤醒哪一个等待者无关紧要，那么可以使用为这些情况而优化的单播发送。所有其他情况下都必须使用广播发送。

#include <pthread.h>

int pthread_cond_broadcast(pthread_cond_t *cond);

返回值：成功则为0，出错则为正的Exxx值。

3、持有锁期间进程终止

当在进程间共享一个互斥锁时，持有该互斥锁的进程在持有锁期间终止（也许时非自愿的）的可能总是有的。没有办法让系统在进程终止时自动释放所持有的锁（读写锁和Posix信号量也具备这种属性）。进程终止时内核总是自动清理的唯一同步锁类型是fcntl记录锁。使用System V信号量时，应用程序可以选择进程终止时内核是否自动清理某个信号量锁（SEM_UNDO特性）

4、死锁

互斥锁无法解除同时也无法加持，导致程序可能会无限阻塞的情况称为死锁。
1）在互斥锁默认属性的情况下，在同一个线程中不允许对同一互斥锁连续进行加锁操作，因为之前锁处于未解除状态，如果再次对同一个互斥锁进行加锁，那么必然会导致程序无限阻塞等待。
2）多个线程对多个互斥锁交叉使用，每一个线程都试图对其他线程所持有的互斥锁进行加锁。

// 线程 A
pthread_mutex_lock(mutex1);
pthread_mutex_lock(mutex2);

// 线程 B
pthread_mutex_lock(mutex2);
pthread_mutex_lock(mutex1);

注：一个线程中操作多个互斥锁时，加锁与解锁的顺序一定是相反的，否则也会导致错误。
 

邻居家的小南瓜
关注
  • 0
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux—互斥锁
weixin_61701822的博客
04-02 428
互斥锁的使用包括初始化互斥锁、互斥锁上锁、互斥锁解锁、互斥锁释放
线程同步之互斥量加锁解锁 死锁
FHNCSDN
09-29 820
与互斥锁相关API       互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运
【Linux】线程互斥 -- 互斥锁 | 死锁 | 线程安全
DEXTERFUTIAN的博客
07-30 1058
互斥锁、互斥量mutex、锁原理解析、可重入VS线程安全、STL中的容器是否是线程安全的?、死锁
Linux学习之系统编程篇：条件变量（pthread_cond_init / wait / signal / broadcast / destroy）
weixin_42374938的博客
07-29 1843
一、条件变量的认识 （1）条件变量的引出： 各个线程访问共享资源，比如说共享资源是一个空资源，那么，各线程的访问其实都是无效访问，因此需要一个机制，首先阻塞线程，以免其错误访问，待条件满足时（比如 共享资源不为空了），告知各线程开始访问共享资源即，在不满足某种条件下，我希望代码阻塞一会，待满足某种条件后，再让各线程工作，所谓某种条件就是条件变量。 （2）条件变量不是锁！但条件变量能够阻塞线程。 （3）如何实现线程同步 ： 与锁配合使用：条件变量（引起阻塞）+ 互斥锁（保护一块共享数据）。 （4）条件变量的两
C++ 多线程pthread 学习笔记
空之境界
11-07 7563
本篇是我在学习C++多线程的时候做的笔记，主要记录的是基础的流程，部分代码实例，以及部分重点函数的说明。 pthread 入口函数类型说明 void * func1(void * t) void* 表示无类型指针 void*作为函数参数，表示函数接收一个指针，不管是什么类型的指针都可以，但是传递之前要强制转换为无类型指针。 基础流程 pthread_t t1;//声明一个线程 pthread_c...
linux无亲缘关系进程间通信(互斥锁+条件变量+共享内存)
07-07
在给定的`server.c`和`client.c`代码中，服务器进程可能会创建一块共享内存，设置互斥锁和条件变量，然后在其中存储数据。客户端进程则通过连接共享内存，使用互斥锁保护数据，当数据满足预设条件时，服务器进程会...
linux进程间通信同步与互斥
07-05
测试环境：64位ubuntu 13LTS 功能说明：使用互斥锁+条件变量+共享内存的方式实现进程（或线程）间的通信示例
linux ipc 带有信号量同步互斥方式的进程间通信
04-14
它是一个整型变量，可以用来计数，也可以作为互斥锁。在多线程或多进程中，当一个进程修改了共享资源后，可以通过减信号量来表示资源已被占用；而其他试图访问该资源的进程则会通过尝试加信号量来获取权限，如果信号...
Linux多线程-相关手写笔记
02-06
`pthread_mutex_init()`和`pthread_mutex_lock()`/`pthread_mutex_unlock()`用于初始化和控制互斥锁。 2. **读写锁（Read-Write Locks）**：在多读少写的场景下，读写锁允许多个读取线程同时访问资源，但写入操作仍...
linux-c-function-manual.zip_linux manual
09-20
7. **信号与同步**：介绍了信号处理函数（signal、raise）、互斥锁（mutex）、条件变量（condition variable）和信号量（semaphore）等多线程同步机制。 8. **目录与文件系统操作**：如mkdir、rmdir用于目录管理，...
UNIX环境高级编程——线程控制
qq_38154295的博客
05-21 770
UNIX环境高级编程——线程控制
pthread_mutex_init等多线程函数的使用总结
Ataraxia的专栏
09-19 1万+
线程按照其调度者可以分为用户级线程和核心级线程两种 用户级线程主要解决的是上下文切换的问题，它的调度算法和调度过程全部由用户自行选择决定，在运行时不需要特定的内核支持； 我们常用基本就是用户级线程，所以就只总结一下POSIX提供的用户级线程接口； 基本线程操作相关的函数： 1线程的建立结束 2线程的互斥和同步 3使用信号量控制线程 4线程的基本属性配置 基本线程操作：
linux线程安全篇之----互斥
weixin_45897952的博客
05-14 762
目录 1.多线程造成的安全隐患： 2.互斥 2.1互斥: 2.1.1互斥概念 2.1.2互斥锁: 2.1.3互斥锁的计数器当中如何保证原子性 3.互斥锁的接口 3.1.初始化互斥锁的接口 3.1.1动态初始化: 3.1.2静态初始化(直接用宏来初始化互斥锁): 3.2.加锁接口 3.3.解锁接口 3.4.销毁接口 1.多线程造成的安全隐患： 2.互斥 2.1互斥: 2.1.1互斥概念 互斥的要做的事情:控制线程的访问时序。 当多 个线程..
Linux 多线程编程，使用c语言简单实现一个类似android handler线程切换机制
weixin_39660616的博客
06-15 459
最近开始用c写程序，作为一个一直从事Android应用开发的程序猿，这对我来说是一个困难的事情，很多编程习惯和以前有很大不同，特别是在面对多线程开发的时候。对于已经习惯使用Android Handler机制的我来说，这简直是噩梦般的存在，为此特地实现了一个类似Handler机制的工具，以方便多线程开发使用。 一、使用系统函数简介 pthread_create() : 创建线程 在Unix、Linux、Mac OS X等操作系统中使用pthread_create()函数进行线程创...
Linux——什么是互斥与互斥锁
weixin_61857742的博客
01-28 1213
所谓互斥，其实就是在某一时刻只能有一个线程访问临界区，且完整的使用临界资源没有其他线程打扰，即原子性。简单来说就是当前线程使用完临界资源后其他线程才能来使用。互斥锁通俗来讲就是用来完成互斥行为的对象，锁住的范围一般就是临界区。需要互斥操作的多线程共享一个互斥锁，当一个线程获得互斥锁后，其他线程会阻塞等待，直到当前线程归还互斥锁后，其他线程争抢互斥锁，谁获得了谁能进入临界区执行代码。
pthread_mutex_init线程互斥锁的使用
kayshi的博客
09-22 6123
pthread_mutex_init 头文件： #include <pthread.h> 函数原型： int pthread_mutex_init(pthread_mutex_t *restrict_mutex,const pthread_mutexattr_t *restrict_attr); pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 示例对比 下面代码是创建了两个现象，线程1对全局变量gnum自增3次，线程2对其自增5次 1
pthread_attr_init线程属性
热门推荐
CodeAllen嵌入式
07-12 3万+
1．线程属性 线程具有属性，用pthread_attr_t表示，在对该结构进行处理之前必须进行初始化，在使用后需要对其去除初始化。我们用pthread_attr_init函数对其初始化，用pthread_attr_destroy对其去除初始化。 名称:： pthread_attr_init/pthread_attr_destroy 功能： 对线程属性初始化/去除初始化 头文件： #inclu
pthread_cond_destroy()函数的使用
北唐盛世
06-03 6077
NAME pthread_cond_destroy, pthread_cond_init - destroy and initialize condition variables SYNOPSIS [THR] #include pthread.h> int pthread_cond_destroy(pthread_cond_t *cond); int pthread_cond
线程控制(三)
dongmengyuan1020的博客
08-02 545
线程同步互斥锁＊互斥锁通过锁机制来实现线程间的同步．在同一时刻它通常只允许一个线程执行一个关键部分的代码． 　　　　　 　　　　　　　　　互斥锁函数 ＊使用互斥锁前，必须先进行初始化操作．初始化有两种方式： 　＞1．静态赋值法，将宏结构常量PTHREAD_MUTEX_INITIALIZER赋给互斥锁，操作语句为：pthread_mutex_t mutex = PTHREAD_MUTEX_IN
PTHREAD_COND_INITIALIZER
最新发布
02-04
PTHREAD_COND_INITIALIZER是一个宏定义，用于初始化pthread_cond_t类型的条件变量。它是在pthread.h头文件中定义的。 使用PTHREAD_COND_INITIALIZER可以方便地初始化条件变量，而不需要手动编写初始化代码。它会将条件变量的所有字段设置为默认值，以确保条件变量的正确使用。 需要注意的是，使用PTHREAD_COND_INITIALIZER只能在定义条件变量时进行初始化，不能在后续的代码中再次使用该宏进行初始化。 下面是一个示例代码，展示了如何使用PTHREAD_COND_INITIALIZER初始化条件变量： ```c #include <pthread.h> pthread_cond_t cond = PTHREAD_COND_INITIALIZER; int main() { // 使用条件变量cond进行相关操作 // ... return 0; } ``` 在上述示例中，我们定义了一个名为cond的条件变量，并使用PTHREAD_COND_INITIALIZER进行初始化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值