C# 多线程十 信号量Semaphore/SemaphoreSlim的简单理解与运用

最新推荐文章于 2024-04-22 07:50:51 发布
最新推荐文章于 2024-04-22 07:50:51 发布
阅读量3.8k 收藏 12
点赞数 5
分类专栏： C#基础知识 # 线程 Thread 文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SmillCool/article/details/127368822
版权

一.继承

Semaphore-> WaitHandle->->MarshalByRefObject
SemaphoreSlim->IDisposable

从继承上来看Semaphore是MarshalByRefObject的孙子类
我们前几篇了解到 互斥Mutex和事件AutoResetEvent/ManualResetEvent往上追溯会发现都继承了MarshalByRefObject

二.应用程序域中的对象的通信方式

一种是跨应用程序域边界传输对象副本。按值封送（marshal by value）
一种是使用代理交换消息。按引用封送（marshal by reference）

由此 我们了解了Mutex和AutoResetEvent/ManualResetEvent 跨进程的原因
因此 Semaphore也是可以跨进程的

三.定义

Semaphore 限制可同时访问某一资源或资源池的线程数。
SemaphoreSlim对可同时访问资源或资源池的线程数加以限制的 Semaphore 的轻量替代。
SemaphoreSlim 类表示一个轻量、快速的信号量，可在等待时间预计很短的情况下用于在单个进程内等待

四.理解

Semaphore/SemaphoreSlim 就像是一扇大门
构造函数 就是指定每次开门 只允许通过多少人
WaitOne  就是打开大门 开始计算出去了几个人 一旦人数达到 大门关闭 不再允许访问WaitOne后面的逻辑
Release  就是抹掉当前第一个出去的人的记录，让大门口排队的一个人可以出去接着走门外的逻辑
Release(Int32) 可以指定抹掉多少人的记录

五.Semaphore/SemaphoreSlim的区别

Semaphore表示一个命名（系统范围内）或本地信号量。它是对 Win32 信号量对象的封装，Win32 信号量是计数信号量，其可用于控制对资源池的访问,可以跨进程的
 SemaphoreSlim 类为一个轻量、快速的信号量，可在等待时间预计很短的情况下，用于在单个进程内的等待

六.方法

注：下面所有解释均来自.Net api 个人只做了代码解释

一.Semaphore

1.构造函数

Semaphore(Int32, Int32)     
初始化 Semaphore 类的新实例，并指定初始入口数和最大并发入口数。

Semaphore(Int32, Int32, String)     
初始化 Semaphore 类的新实例，并指定初始入口数和最大并发入口数，可以选择指定系统信号量对象的名称。

Semaphore(Int32, Int32, String, Boolean)     
初始化 Semaphore 类的新实例，并指定初始入口数和最大并发入口数，还可以选择指定系统信号量对象的名称，以及指定一个变量来接收指示是否创建了新系统信号量的值。

2.方法：

Release()     
退出信号量并返回前一个计数。

Release(Int32)     
以指定的次数退出信号量并返回前一个计数。

WaitOne()     
阻止当前线程，直到当前 WaitHandle 收到信号。
(继承自 WaitHandle)

WaitOne(Int32)     
阻止当前线程，直到当前 WaitHandle 收到信号，同时使用 32 位带符号整数指定时间间隔（以毫秒为单位）。
(继承自 WaitHandle)

WaitOne(Int32, Boolean)     
阻止当前线程，直到当前的 WaitHandle 收到信号为止，同时使用 32 位带符号整数指定时间间隔，并指定是否在等待之前退出同步域。
(继承自 WaitHandle)

WaitOne(TimeSpan)     
阻止当前线程，直到当前实例收到信号，同时使用 TimeSpan 指定时间间隔。
(继承自 WaitHandle)

WaitOne(TimeSpan, Boolean)     
阻止当前线程，直到当前实例收到信号为止，同时使用 TimeSpan 指定时间间隔，并指定是否在等待之前退出同步域。
(继承自 WaitHandle)


二.SemaphoreSlim

1.构造函数

SemaphoreSlim(Int32)     
初始化 SemaphoreSlim 类的新实例，以指定可同时授予的请求的初始数量。

SemaphoreSlim(Int32, Int32)     
初始化 SemaphoreSlim 类的新实例，同时指定可同时授予的请求的初始数量和最大数量。

2.方法

Release()     
释放 SemaphoreSlim 对象一次。

Release(Int32)     
释放 SemaphoreSlim 对象指定的次数。

Wait()     
阻止当前线程，直至它可进入 SemaphoreSlim 为止。

Wait(CancellationToken)     
阻止当前线程，直至它可进入 SemaphoreSlim 为止，同时观察 CancellationToken。

代码：

static Dictionary<int, string> dic = new Dictionary<int, string>();
    static List<Task> tasks = new List<Task>();
    static void Main(string[] args) {
        CancellationTokenSource srcToken = new CancellationTokenSource();
        SemaphoreSlim semaphoreSlim = new SemaphoreSlim(0);
        for(int i = 0; i < 10; i++) {
            dic.Add(i, i.ToString());
        }
        foreach(var i in dic) {
            tasks.Add(Task.Run(() => {
                Thread.Sleep(100 * i.Key);
                Console.WriteLine($"task:{i.Value} task线程ID：{Thread.CurrentThread.ManagedThreadId}");
                semaphoreSlim.Release();
            }, srcToken.Token));
        }
        for(int i = 0; i < 10; i++) {
            semaphoreSlim.Wait(srcToken.Token);
            Console.WriteLine($"for:{i} 线程ID：{Thread.CurrentThread.ManagedThreadId}");
            if(i == 9) srcToken.Cancel();
        }

        Console.ReadKey();
    }

打印：

由打印可以看出

当我设置SemaphoreSlim semaphoreSlim = new SemaphoreSlim(0)的时候 需要等待semaphoreSlim.Release()后 才会走入semaphoreSlim.Wait(srcToken.Token)后的逻辑
且阻塞了线程1

提前结束： 

static Dictionary<int, string> dic = new Dictionary<int, string>();
    static List<Task> tasks = new List<Task>();
    static void Main(string[] args) {
        CancellationTokenSource srcToken = new CancellationTokenSource();
        SemaphoreSlim semaphoreSlim = new SemaphoreSlim(0);
        for(int i = 0; i < 10; i++) {
            dic.Add(i, i.ToString());
        }
        foreach(var i in dic) {
            tasks.Add(Task.Run(() => {
                Thread.Sleep(100 * i.Key);
                Console.WriteLine($"task:{i.Value} task线程ID：{Thread.CurrentThread.ManagedThreadId}");
                semaphoreSlim.Release();
            }, srcToken.Token));
        }
        srcToken.Cancel();
        for(int i = 0; i < 10; i++) {
            semaphoreSlim.Wait(srcToken.Token);
            Console.WriteLine($"for:{i} 线程ID：{Thread.CurrentThread.ManagedThreadId}");
        }

        Console.ReadKey();
    }

打印：

Wait(Int32)     
阻止当前线程，直至它可进入 SemaphoreSlim 为止，同时使用 32 位带符号整数来指定超时。

代码：

static Dictionary<int, string> dic = new Dictionary<int, string>();
    static List<Task> tasks = new List<Task>();
    static void Main(string[] args) {
        CancellationTokenSource srcToken = new CancellationTokenSource();
        SemaphoreSlim semaphoreSlim = new SemaphoreSlim(3);
        for(int i = 0; i < 10; i++) {
            dic.Add(i, i.ToString());
        }
        foreach(var i in dic) {
            tasks.Add(Task.Run(() => {
                Thread.Sleep(100 * (i.Key + 1));
                Console.WriteLine($"task:{i.Value} task线程ID：{Thread.CurrentThread.ManagedThreadId}");
                semaphoreSlim.Release();
            }, srcToken.Token));
        }
        for(int i = 0; i < 10; i++) {
            semaphoreSlim.Wait(1000);
            Console.WriteLine($"for:{i} 线程ID：{Thread.CurrentThread.ManagedThreadId}");
        }

        Console.ReadKey();
    }

打印：

由打印可以看出

当SemaphoreSlim semaphoreSlim = new SemaphoreSlim(3)

初始允许 for走了三次之后才开始阻塞线程

修改一下超时检测值：

static Dictionary<int, string> dic = new Dictionary<int, string>();
    static List<Task> tasks = new List<Task>();
    static void Main(string[] args) {
        CancellationTokenSource srcToken = new CancellationTokenSource();
        SemaphoreSlim semaphoreSlim = new SemaphoreSlim(3);
        for(int i = 0; i < 10; i++) {
            dic.Add(i, i.ToString());
        }
        foreach(var i in dic) {
            tasks.Add(Task.Run(() => {
                Thread.Sleep(100 * (i.Key + 1));
                Console.WriteLine($"task:{i.Value} task线程ID：{Thread.CurrentThread.ManagedThreadId}");
                semaphoreSlim.Release();
            }, srcToken.Token));
        }
        for(int i = 0; i < 10; i++) {
            semaphoreSlim.Wait(1);
            Console.WriteLine($"for:{i} 线程ID：{Thread.CurrentThread.ManagedThreadId}");
        }

        Console.ReadKey();
    }

 打印：

超时之后也会释放掉


Wait(Int32, CancellationToken)     
阻止当前线程，直至它可进入 SemaphoreSlim 为止，并使用 32 位带符号整数来指定超时，同时观察 CancellationToken。

Wait(TimeSpan)     
阻止当前线程，直至它可进入 SemaphoreSlim 为止，同时使用 TimeSpan 来指定超时。

代码：

static Dictionary<int, string> dic = new Dictionary<int, string>();
    static List<Task> tasks = new List<Task>();
    static void Main(string[] args) {
        CancellationTokenSource srcToken = new CancellationTokenSource();
        SemaphoreSlim semaphoreSlim = new SemaphoreSlim(3);
        for(int i = 0; i < 10; i++) {
            dic.Add(i, i.ToString());
        }
        foreach(var i in dic) {
            tasks.Add(Task.Run(() => {
                Thread.Sleep(100 * (i.Key + 1));
                Console.WriteLine($"task:{i.Value} task线程ID：{Thread.CurrentThread.ManagedThreadId}");
                semaphoreSlim.Release();
            }, srcToken.Token));
        }
        for(int i = 0; i < 10; i++) {
            semaphoreSlim.Wait(TimeSpan.FromSeconds(1));
            Console.WriteLine($"for:{i} 线程ID：{Thread.CurrentThread.ManagedThreadId}");
        }

        Console.ReadKey();
    }

 打印：

修改一下释放值：

static Dictionary<int, string> dic = new Dictionary<int, string>();
    static List<Task> tasks = new List<Task>();
    static void Main(string[] args) {
        CancellationTokenSource srcToken = new CancellationTokenSource();
        SemaphoreSlim semaphoreSlim = new SemaphoreSlim(3);
        for(int i = 0; i < 10; i++) {
            dic.Add(i, i.ToString());
        }
        foreach(var i in dic) {
            tasks.Add(Task.Run(() => {
                Thread.Sleep(100 * (i.Key + 1));
                Console.WriteLine($"task:{i.Value} task线程ID：{Thread.CurrentThread.ManagedThreadId}");
                semaphoreSlim.Release(5);
            }, srcToken.Token));
        }
        for(int i = 0; i < 10; i++) {
            semaphoreSlim.Wait(TimeSpan.FromSeconds(1));
            Console.WriteLine($"for:{i} 线程ID：{Thread.CurrentThread.ManagedThreadId}");
        }

        Console.ReadKey();
    }

 打印：

可以发现 尽管我初始化的时候设定了3 可是当修改每次释放5个后 允许for走了5次之后才开始阻塞线程

Wait(TimeSpan, CancellationToken)     
阻止当前线程，直至它可进入 SemaphoreSlim 为止，并使用 TimeSpan 来指定超时，同时观察 CancellationToken。

注：使用Wait时是同步的 即一旦开始阻止会阻塞当前线程


WaitAsync()     
输入 SemaphoreSlim 的异步等待。

WaitAsync(CancellationToken)     
在观察 CancellationToken 时，输入 SemaphoreSlim 的异步等待。

WaitAsync(Int32)     
输入 SemaphoreSlim 的异步等待，使用 32 位带符号整数度量时间间隔。

WaitAsync(Int32, CancellationToken)     
在观察 CancellationToken 时，输入 SemaphoreSlim 的异步等待，使用 32 位带符号整数度量时间间隔。

WaitAsync(TimeSpan)     
输入 SemaphoreSlim 的异步等待，使用 TimeSpan 度量时间间隔。

WaitAsync(TimeSpan, CancellationToken)     
在观察 SemaphoreSlim 时，输入 TimeSpan 的异步等待，使用 CancellationToken 度量时间间隔。

注：使用WaitAsync时是异步的 不阻塞当前线程

代码：

static Dictionary<int, string> dic = new Dictionary<int, string>();
    static List<Task> tasks = new List<Task>();
    static void Main(string[] args) {
        CancellationTokenSource srcToken = new CancellationTokenSource();
        SemaphoreSlim semaphoreSlim = new SemaphoreSlim(0);
        for(int i = 0; i < 10; i++) {
            dic.Add(i, i.ToString());
        }
        foreach(var i in dic) {
            tasks.Add(Task.Run(() => {
                Thread.Sleep(100 * (i.Key + 1));
                Console.WriteLine($"task:{i.Value} task线程ID：{Thread.CurrentThread.ManagedThreadId}");
                semaphoreSlim.Release();
            }, srcToken.Token));
        }
        for(int i = 0; i < 10; i++) {
            semaphoreSlim.WaitAsync();
            Console.WriteLine($"for:{i} 线程ID：{Thread.CurrentThread.ManagedThreadId}");
        }

        Console.ReadKey();
    }

打印：

 

修改之后发现并没有阻塞线程 而是开了一个线程去等待

验证一下：

static Dictionary<int, string> dic = new Dictionary<int, string>();
    static List<Task> tasks = new List<Task>();
    static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(0);
    static void Main(string[] args) {
        CancellationTokenSource srcToken = new CancellationTokenSource();

        for(int i = 0; i < 10; i++) {
            dic.Add(i, i.ToString());
        }
        foreach(var i in dic) {
            tasks.Add(Task.Run(() => {
                Thread.Sleep(100 * (i.Key + 1));
                Console.WriteLine($"task:{i.Value} task线程ID：{Thread.CurrentThread.ManagedThreadId}");
                semaphoreSlim.Release();
            }, srcToken.Token));
        }
        DoSth();
        Console.WriteLine($"主线程ID：{Thread.CurrentThread.ManagedThreadId}");
        Console.ReadKey();
    }

    static async void DoSth() {
        for(int i = 0; i < 10; i++) {
            await semaphoreSlim.WaitAsync();
            Console.WriteLine($"for:{i} 线程ID：{Thread.CurrentThread.ManagedThreadId}");
        }
    }

 打印：

注：

使用semaphoreSlim.Wait(CancellationToken cancellationToken);等待时如果cancellationToken提前释放会抛出System.OperationCanceledException异常


使用semaphoreSlim.Wait(int millisecondsTimeout); -1 表示无限期超时 非-1的负数会抛出 System.ArgumentOutOfRangeException异常

至此：关于多线程算是告一段落了，当然没有全部囊括，只是写了一些自己比较常用了，以后有时间接着更。

如果有不对的地方希望能指出来 感激不尽。

另外，不熟悉的代码一定要写一下加深记忆 只用看的记不了太久。

一梭键盘任平生
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C#多线程之Semaphore用法详解
01-21
Semaphore：可理解为允许线程执行信号的池子，池子中放入多少个信号就允许多少线程同时执行。 private static void MultiThreadSynergicWithSemaphore() { //0表示创建Semaphore时，拥有可用信号量数值 //1表示Semaphore中，最多容纳信号量数值 Semaphore semaphore = new Semaphore(0, 1); Thread thread1 = new Thread(() => { //线程首先WaitOne等待一个可用的信号量 semaphore.W
C#：多线程--信号量（Semaphore）
SSS_369
01-20 6107
百度百科：Semaphore,是负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。也是操作系统中用于控制进程同步互斥的量。 1. Semaphore常用的方法有两个WaitOne()和Release()， Release()的作用是退出信号量并返回前一个计数， 而WaitOne()则是阻止当前线程，直到当前线程的WaitHandle 收到信号。 这里我举一个例子让大家更容易理解：...
理解Semaphore及其用法详解
热门推荐
flyingdon的专栏
12-31 7万+
Mutex是一把钥匙，一个人拿了就可进入一个房间，出来的时候把钥匙交给队列的第一个。一般的用法是用于串行化对critical section代码的访问，保证这段代码不会被并行的运行。Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。对于N=1的情况，称为binary semaphore。一般的用法是，用于限制对于某一资源的同时访问。Binary sem
C# 信号量（Semaphore）详细使用案例
qqrrjj2011的博客
02-04 1712
在C#中，信号量（Semaphore）是.NET框架提供的一个同步类，位于命名空间下，用于控制并发访问特定资源的线程数量。它是一种更灵活的线程同步机制，通过维护一个计数器来管理资源的可用性。
使用SemaphoreSlim实现异步等待
黄腾霄的博客
02-24 1898
Semaphore大家应该都很熟悉，一个能够指定最大并发个数的同步锁。 实际上.NET还有一个轻量级的信号量实现SemaphoreSlim，其不但能够更加高效的实现信号量的功能，还提供了一个异步等待的API。 我们首先回忆下SemaphoreSlim同步等待时的情况。 class Program { private static SemaphoreSlim sem...
c# Semaphore（信号量）
Spades_J 的博客
10-12 1843
参考： http://blog.csdn.net/feilongzaitianhehe/article/details/51460529 http://www.cnblogs.com/tianzhiliang/archive/2010/08/31/1813635.html信号量说简单点就是为了线程同步，或者说是为了限制线程能运行的数量。那它又是怎么限制线程的数量的哩？是因为它内部有个计数器，比如
操作系统之信号量（Semaphore）以及再C#中的应用，通过信号量实现资源共享，互斥锁，和线程同步操作。
csdn2990的博客
06-09 2172
信号量（Semaphore） 是一种比互斥锁更强大的同步工具，它可以提供更高级的方法来同步并发进程或线程。它本质上是一个类型的整数，。而信号量的原子操作，一般就2个一个是表示test另一个是表示增加，简单点理解就是P内部执行等待和测试操作，V内部代码执行添加操作。可以通过信号量控制线程的并发同步操作，并且也可以通过信号量解决互斥锁的问题。下面将通过简单的例子分别介绍当信号量初始化值为0 OR >1 OR .........
C#【多线程-线程同步】-SemaphoreSlim业务应用场景
刘欢的博客
04-02 689
SemaphoreSlim业务应用场景 一.首先说一下SemaphoreSlim 1.什么是SemaphoreSlim？ 官网上面解释：对可同时访问资源或资源池的线程数加以限制的Semaphore的轻量替代。 个人理解：对同一个资源，多个线程同时并发访问，起到对线程数控制的作用。 二.业务场景进行理解 比如，售票窗口，需要开两个窗口售票，买票人员只能在...
c#多线程中使用SemaphoreSlim
故里2130
01-12 1178
4.我们对比方法一和方法二发现，他们的结果都是一样的，但是lock似乎比SemaphoreSlim更加的高效，是的，lock解决此业务的确比SemaphoreSlim高效。SemaphoreSlim是一个用于同步和限制并发访问的类，和它类似的还有Semaphore，只是SemaphoreSlim更加的轻量、高效、好用。当我们在第1步，只需要增加一句话，不增加lock和SemaphoreSlim，依然可以使得计算的结果准确，那就是增加。当我们增加SemaphoreSlim后，不管运行几次，结果都是正确的。
多线程之旅(6)_Semaphore和SemaphoreSlim关于WaitOne、Release的用法详解——附C#源码
AI量化交易实验室
05-16 3540
Semaphore、WaitOne、Release三者组成了一个互斥信号量的完整体系结构。Semaphore、WaitOne、Release究竟和AutoResetEvent/ManualResetEvent、WaitOne、Set、Reset有什么区别呢？我们往下看。 GitHub源码地址：https://github.com/yangwohenmai/TEST/tree/master/Sem...
semaphore-scheduling:SemaphoreSlim的实现可用于计划项目中的任务许可（它提供了功能来处理线程或任务是否可以继续其处理或执行次数受到限制？）
03-19
semaphore-scheduling:SemaphoreSlim的实现可用于计划项目中的任务许可（它提供了功能来处理线程或任务是否可以继续其处理或执行次数受到限制？）
python线程信号量semaphore使用解析
01-20
多线程同时运行，能提高程序的运行效率，但是并非线程越多越好，而semaphore信号量可以通过内置计数器来控制同时运行线程的数量，启动线程(消耗信号量)内置计数器会自动减一，线程结束(释放信号量)内置计数器会自动...
JAVA 多线程之信号量(Semaphore)实例详解
08-31
主要介绍了JAVA 多线程之信号量(Semaphore)实例详解的相关资料,需要的朋友可以参考下
C#信号量，用于多线程
10-26
Semaphore,是负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。也是操作系统中用于控制进程同步互斥的量。
C#语法知识之循环语句
AMrss的博客
04-20 487
5、循环语句。
C#中的Task：异步编程的瑞士军刀
qq_35320456的博客
04-19 1589
C#中的Task：异步编程的瑞士军刀
学生选课及成绩查询管理系统的设计与开发C#(winform + sqlserver)
最新发布
小张微说的博客
04-22 1926
源码来自网络 技术栈： C#的窗体程序开发 本系统未采用C#实现MDI——多文档窗口，因为考虑到C#的该技术与java类似，而暑期java实训时，曾用过类似的方法做过停车场管理系统，所以想为这次的系统注入一点新鲜的血液，所以本系统设计的主题采用了了C#的C#TreeView 实现。 Sql server数据库 关注公众号【DotNet微说】，发送：学生选课及成绩查询管理系统，便可获取源码。 个人微信：iotzzh 公众号：DotNet微说 个人网站：www.iotzzh.com 登录界面 管理员主页
C# Lazy
大黄鸭在发光的专栏
04-20 231
在 C# 中，Lazy<T>类型用于支持延迟初始化。延迟初始化是一种优化策略，它允许推迟创建对象或执行某些昂贵计算的过程，直到实际需要其值的时刻。这有助于提高应用程序的启动速度和运行效率，特别是在处理资源密集型对象时。以下是关于Lazy<T>
c# 如何使用信号量挂起线程
05-30
在 C# 中，可以使用 `System.Threading.Semaphore` 类来实现信号量来挂起线程。下面是一个简单的示例： ```csharp using System; using System.Threading; class SemaphoreExample { static Semaphore sem = new Semaphore(0, 1); // 初始化计数器为 0，最大计数器为 1 static void Worker() { Console.WriteLine("Worker start"); sem.WaitOne(); // 等待信号量计数器不为 0 Console.WriteLine("Worker end"); } static void Main() { Thread t = new Thread(Worker); t.Start(); Thread.Sleep(1000); // 等待 1 秒 Console.WriteLine("Main notify"); sem.Release(); // 增加信号量计数器 t.Join(); } } ``` 在上面的示例中，`Semaphore` 类中初始化计数器为 0，最大计数器为 1。在 `Worker()` 方法中，线程会在 `WaitOne()` 方法处被挂起，直到计数器不为 0。在 `Main()` 方法中，主线程会等待 1 秒后调用 `Release()` 方法增加计数器，通知子线程继续执行。输出结果为： ``` Worker start Main notify Worker end ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一梭键盘任平生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值