Java并发编程——多线程间的同步控制和通信

多线程间的同步控制和通信 用多线程并发处理,目的是为了让程序更充分地利用CPU ,好能加快程序的处理速度和用户体验。如果每个线程各自处理的部分互不相干,那真是极好的,我们在程序主线程要做的同步控制最多也就是等待几个工作线程的执行完毕,如果不 Care 结果的话,连同步等待都能省去,主线程撒开手让这些线程干就行了。不过,现实还是很残酷的,大部分情况下,多个线程是会有竞争操作同一个对象的情况的,这个时候就会导致并发常见的一个问题--数据竞争(Data Racing)。这篇文章我们就来讨论一下这个并发导致的问题,以及多线程间进行同步控制和 阅读详情

使用多线程并发处理,目的是为了让程序更充分地利用CPU ,好能加快程序的处理速度和用户体验。如果每个线程各自处理的部分互不相干,那真是极好的,我们在程序主线程要做的同步控制最多也就是等待几个工作线程的执行完毕,如果不 Care 结果的话,连同步等待都能省去,主线程撒开手让这些线程干就行了。

不过,现实还是很残酷的,大部分情况下,多个线程是会有竞争操作同一个对象的情况的,这个时候就会导致并发常见的一个问题--数据竞争(Data Racing)。

这篇文章我们就来讨论一下这个并发导致的问题,以及多线程间进行同步控制和通信的知识,本文大纲如下:

 

并发导致的Data Racing问题

怎么理解这个问题呢,拿一个多个线程同时对累加器对象进行累加的例子来解释吧。

package com.learnthread;

public class DataRacingTest {
    
    public static void main(String[] args) throws InterruptedException {
        final DataRacingTest test = new DataRacingTest();
        // 创建两个线程,执行 add100000() 操作
        // 创建Thread 实例时的 Runnable 接口实现,这里直接使用了 Lambda
        Thread th1 = new Thread(()-> test.add100000());
        Thread th2 = new Thread(()-> test.add100000());
        // 启动两个线程
        th1.start();
        th2.start();
        // 等待两个线程执行结束
        th1.join();
        th2.join();
        System.out.println(test.count);
    }

    private long count = 0;

    // 想复现 Data Racing,去掉这里的 synchronized
    private  void add100000() {
        int idx = 0;
        while(idx++ < 100000) {
            count += 1;
        }
    }
}
复制代码

上面这个例程,如果我们不启动 th2 线程,只用 th1 一个线程进行累加操作的话结果是 100000。按照这个思维,如果我们启动两个线程那么最后累加的结果就应该是 200000。 但实际上并不是,我们运行一下上面的例程,得到的结果是:

168404

Process finished with exit code 0
复制代码

当然这个在每个人的机器上的结果是不一样的,而且也是有可能恰好等于 200000,需要多运行几次,或者是多开几个线程执行累加,出现 Data Racing 的几率才高。

程序出现 Data Racing 的现象,就意味着最终拿到的数据是不正确的。那么为了避免这个问题就需要通过加锁来解决了,让同一时间只有持有锁的线程才能对数据对象进行操作。当然针对简单的运算、赋值等操作我们也能直接使用原子操作实现无锁解决 Data Racing, 我们为了示例足够简单易懂才举了一个累加的例子,实际上如果是一段业务逻辑操作的话,就只能使用加锁来保证不会出现 Data Racing了。

加锁,只是线程并发同步控制的一种,还有释放锁、唤醒线程、同步等待线程执行完毕等操作,下面我们会逐一进行学习。

同步控制--synchronized

开头的那个例程,如果想避免 Data Racing,那么就需要加上同步锁,让同一个时间只能有一个线程操作数据对象。 针对我们的例程,我们只需要在 add100000 方法的声明中加上 synchronized 即可。

    // 想复现 Data Racing,去掉这里的 synchronized
    private synchronized void add100000() {
        int idx = 0;
        while(idx++ < 100000) {
            count += 1;
        }
    }
复制代码

是不是很简单,当然 synchronized 的用法远不止这个,它可以加在实例方法、静态方法、代码块上,如果使用得不对,就不能正确地给需要同步锁保护的对象加上锁。

synchronized 是 Java 中的关键字,是利用锁的机制来实现互斥同步的。 synchronized 可以保证在同一个时刻,只有一个线程可以执行某个方法或者某个代码块。 如果不需要 Lock 、读写锁ReadWriteLock 所提供的高级同步特性,应该优先考虑使用synchronized 这种方式加锁,主要原因如下:

  • Java 自 1.6 版本以后,对 synchronized 做了大量的优化,其性能已经与 JUC 包中的 Lock 、ReadWriteLock 基本上持平。从趋势来看,Java 未来仍将继续优化 synchronized ,而不是 ReentrantLock 。
  • ReentrantLock 是 Oracle JDK 的 API,在其他版本的 JDK 中不一定支持;而 synchronized 是 JVM 的内置特性,所有 JDK 版本都提供支持。

synchronized 可以应用在实例方法、静态方法和代码块上:

  • 用 synchronized 关键字修饰实例方法,即为同步实例方法,锁是当前的实例对象。
  • 用 synchronized 关键字修饰类的静态方法,即为同步静态方法,锁是当前的类的 Class 对象。
  • 如果把 synchronized 应用在代码块上,锁是 synchronized 括号里配置的对象,synchronized(this) {..} 锁就是代码块所在实例的对象,synchronized(类名.class) {...} ,锁就是类的 Class 对象。

同步实例方法和代码块

上面我们已经看过怎么给实例方法加 synchronized 让它变成同步方法了。下面我们看一下,synchronized 给实例方法加锁时,不能保证资源被同步锁保护的例子。

class Account {
  private int balance;
  // 转账
  synchronized void transfer(Account target, int amt){
    if (this.balance > amt) {
      this.balance -= amt;
      target.balance += amt;
    }
  }
}
复制代码

在这段代码中,临界区内有两个资源,分别是转出账户的余额 this.balance 和转入账户的余额 target.balance,并且用的是一把实例对象的锁。问题就出在 this 这把锁上,this 这把锁可以保护自己的余额 this.balance,却保护不了别人的余额 target.balance,就像你不能用自家的锁来保护别人家的资产一个道理。

应该保证使用的锁能保护所有应受保护资源。我们可以使用Account.class 作为加锁的对象。Account.class 是所有 Account 类的对象共享的,而且是 Java 虚拟机在加载 Account 类的时候创建的,保证了它的全局唯一性。

class Account {
  private int balance;
  // 转账
  void transfer(Account target, int amt){
    synchronized(Account.class) {
      if (this.balance > amt) {
        this.balance -= amt;
        target.balance += amt;
      }
    }
  }
}
复制代码

用 synchronized 给 Account.class 加锁,这样就保证出账、入账两个 Account 对象在同步代码块里都能收到保护。

当然我们也可以使用这笔转账的交易对象作为加锁的对象,保证只有这比交易的两个 Account 对象受保护,这样就不会影响到其他转账交易里的出账、入账 Account 对象了。

class Account {
  private Trans trans;
  private int balance;
  private Account();
  // 创建 Account 时传入同一个 交易对象作为 lock 对象
  public Account(Trans trans) {
    this.trans = trans;
  }
  // 转账
  void transfer(Account target, int amt){
    // 此处检查所有对象共享的锁
    synchronized(trans) {
      if (this.balance > amt) {
        this.balance -= amt;
        target.balance += amt;
      }
    }
  }
}
复制代码

通过解决上面这个问题我们顺道就把 synchronized 修饰同步代码块的知识点学了, 现在我们来看 synchronized 的最后一个用法--修饰同步静态方法。

同步静态方法

静态方法的同步是指,用 synchronized 修饰的静态方法,与使用所在类的 Class 对象实现的同步代码块,效果类似。因为在 JVM 中一个类只能对应一个类的 Class 对象,所以同时只允许一个线程执行同一个类中的静态同步方法。

对于同一个类中的多个静态同步方法,持有锁的线程可以执行每个类中的静态同步方法而无需等待。不管类中的哪个静态同步方法被调用,一个类只能由一个线程同时执行。

package com.learnthread;

public class SynchronizedStatic implements Runnable {

    private static final int MAX = 100000;

    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        SynchronizedStatic instance = new SynchronizedStatic();
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        // 等待工作线程执行结束
        t1.join();
        t2.join();
        System.out.println(count);
    }

    @Override
    public void run() {
        for (int i = 0; i < MAX; i++) {
            increase();
        }
    }

    /**
     * synchronized 修饰静态方法
     */
    public synchronized static void increase() {
        count++;
    }

}

复制代码

线程挂起和唤醒

上面我们看了使用 synchronized 给对象加同步锁,让同一时间只有一个线程能操作临界区的控制。接下来,我们看一下线程的挂起和唤醒,这两个操作使用被线程成功加锁的对象的 wait 和 notify 方法来完成,唤醒除了notify 外还有 notifyAll方法用来唤醒所有线程。下面我们先看一下这几个方法的解释。

  • wait - wait 会自动释放当前线程占有的对象锁,并请求操作系统挂起当前线程,让线程从 Running 状态转入 Waiting 状态,等待被 notify / notifyAll 来唤醒。如果没有释放锁,那么其它线程就无法进入对象的同步方法或者同步代码块中,那么就无法执行 notify 或者 notifyAll 来唤醒挂起的线程,会造成死锁。
  • notify - 唤醒一个正在 Waiting 状态的线程,并让它拿到对象锁,具体唤醒哪一个线程由 JVM 控制 。
  • notifyAll - 唤醒所有正在 Waiting 状态的线程,接下来它们需要竞争对象锁。

这里有两点需要各位注意的地方, 第一个是 wait、notify、notifyAll 都是 Object 类中的方法,而不是 Thread 类的。

 

因为 Object 是始祖类,是不是意味着所有类的对象都能调用这几个方法呢?是,也不是... 因为 wait、notify、notifyAll 只能用在 synchronized 方法或者 synchronized 代码块中使用,否则会在运行时抛出
IllegalMonitorStateException。换句话说,只有被 synchronized 加上锁的对象,才能调用这三个方法。

为什么 wait、notify、notifyAll 不定义在 Thread 类中?为什么 wait、notify、notifyAll 要配合 synchronized 使用? 理解为什么这么设计,需要了解几个基本知识点:

  • 每一个 Java 对象都有一个与之对应的监视器(monitor)
  • 每一个监视器里面都有一个 对象锁 、一个 等待队列、一个 同步队列

了解了以上概念,我们回过头来理解前面两个问题。

为什么这几个方法不定义在 Thread 中?

  • 由于每个对象都拥有对象锁,让当前线程等待某个对象锁,自然应该基于这个对象(Object)来操作,而非使用当前线程(Thread)来操作。因为当前线程可能会等待多个线程释放锁,如果基于线程(Thread)来操作,就非常复杂了。

为什么 wait、notify、notifyAll 要配合 synchronized 使用?

  • 如果调用某个对象的 wait 方法,当前线程必须拥有这个对象的对象锁,因此调用 wait 方法必须在 synchronized 方法和 synchronized 代码块中。

下面看一个 wait、notify、notifyAll 的一个经典使用案例,实现一个生产者、消费者模式:

package com.learnthread;

import java.util.PriorityQueue;

public class ThreadWaitNotifyDemo {

    private static final int QUEUE_SIZE = 10;
    private static final PriorityQueue<Integer> queue = new PriorityQueue<>(QUEUE_SIZE);

    public static void main(String[] args) {
        new Producer("生产者A").start();
        new Producer("生产者B").start();
        new Consumer("消费者A").start();
        new Consumer("消费者B").start();
    }

    static class Consumer extends Thread {

        Consumer(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == 0) {
                        try {
                            System.out.println("队列空,等待数据");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notifyAll();
                        }
                    }
                    queue.poll(); // 每次移走队首元素
                    queue.notifyAll();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 从队列取走一个元素,队列当前有:" + queue.size() + "个元素");
                }
            }
        }
    }

    static class Producer extends Thread {

        Producer(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == QUEUE_SIZE) {
                        try {
                            System.out.println("队列满,等待有空余空间");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notifyAll();
                        }
                    }
                    queue.offer(1); // 每次插入一个元素
                    queue.notifyAll();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 向队列取中插入一个元素,队列当前有:" + queue.size() + "个元素");
                }
            }
        }
    }
}
复制代码

上面的例程有两个生产者和两个消费者。生产者向队列中放数据,每次向队列中放入数据后使用 notifyAll 唤醒消费者线程,当队列满后生产者会 wait 让出线程,等待消费者取走数据后再被唤醒 (消费者取数据后也会调用 notifyAll )。同理消费者在队列空后也会使用 wait 让出线程,等待生产者向队列中放入数据后被唤醒。

线程等待--join

与 wait 和 notify 方法一样,join 是另一种线程间同步机制。当我们调用线程对象 join 方法时,调用线程会进入等待状态,它会一直处于等待状态,直到被引用的线程执行结束。在上面的几个例子中,我们已经使用过了 join 方法

   ...
	public static void main(String[] args) throws InterruptedException {
        SynchronizedStatic instance = new SynchronizedStatic();
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        // 等待工作线程执行结束
        t1.join();
        t2.join();
        System.out.println(count);
    }
复制代码

这个例子里,主线程调用 t1 和 t2 的 join 方法后,就会一直等待,直到他们两个执行结束。如果 t1 或者 t2 线程处理时间过长,调用它们 join 方法的主线程将一直等待,程序阻塞住。为了避免这些情况,可以使用能指定超时时间的重载版本的 join 方法。

    t2.join(1000); // 最长等待1s
复制代码

如果引用的线程被中断,join方法也会返回。在这种情况下,还会触发 InterruptedException。所以上面的main方法为了演示方便,直接选择抛出了 InterruptedException。

总结

同步控制的一大思路就是加锁,除了本问学习到的 sychronized 同步控制,Java 里还有 JUC 的可重入锁、读写锁这种加锁方式,这个我们后续介绍 JUC 的时候会给大家讲解。

另外一种思路是不加锁,让线程和线程之间尽量不要使用共享数据,ThreadLocal 就是这种思路,下篇我们介绍 Java 的线程本地存储 -- ThreadLocal。

【Java篇】多线程详解 Java系统在语言层次上对多线程直接提供支持,多线程的主要目的是将一个程序中的各个程序段并发化,在在通常情况下,Java程序各部分是按顺序一次执行的,由于某种原因,需要将这些按顺序执行的程序段转化为并发执行,每个程序段在逻辑上是相互完整的代码段。实际上,在单处理器上,同一时刻只能执行一个代码,但是在同一时间段内,这些代码交替执行,所谓的“微观串行,宏观并行”。... 阅读详情

相关推荐

从隐私保护到生命守护:CPD技术中的传感器选择与权衡

本文探讨了智能座舱中儿童存在检测(CPD)技术的传感器选择与隐私保护平衡策略。通过分析毫米波雷达、UWB等先进技术的性能与隐私风险,揭示了如何在确保儿童安全的同时保护用户隐私。文章还展望了CPD技术与座舱生态系统的未来融合趋势,为汽车安全领域提供了重要参考。

weixin_29159441的博客 301

Java并发编程--多线程间的同步控制和通信

同步控制的一大思路就是加锁,除了本问学习到的 sychronized 同步控制,Java 里还有 JUC 的可重入锁、读写锁这种加锁方式,这个我们后续介绍 JUC 的时候会给大家讲解。另外一种思路是不加锁,让线程和线程之间尽量不要使用共享数据,ThreadLocal 就是这种思路,下篇我们介绍 Java 的线程本地存储 -- ThreadLocal。

BASK2311的博客 457

智能座舱通信技术解析:从CAN总线到车载以太网与V2X

在汽车电子与智能网联快速融合的背景下,座舱智能化已不再是简单的屏幕堆砌,而是依赖底层通信技术构建的复杂系统。CAN总线因高可靠性与确定性传输,持续承担车身控制与安全信号的传递;车载以太网则凭借高带宽优势,成为多屏高清视频与OTA升级的核心通道;V2X车路协同技术进一步将座舱与外界的实时信息互联。理解这些技术的分工协作,是掌握智能座舱架构、开展座舱测试与故障排查的关键。本文从实际测试经验出发,梳理不同总线在座舱内部及外部的应用逻辑,结合低成本的实验台架搭建指南,展示从信号采集、网关转发到多媒体流传输的完整链路

weixin_29284657的博客 345

数据争用(data race) 和竞态条件(race condition)

在有关多线程编程的话题中,数据争用(data race) 和竞态条件(race condition)是两个经常被提及的名词,它们两个有着相似的名字,也是我们在并行编程中极力避免出现的。但在处理实际问题时,我们应该能明确区分它们两个。 1.数据争用(data race) 定义:①多个线程对于同一个变量、②同时地、③进行读/写操作的现象并且④至少有一个线程进行写操作。(也就是说,如果所有线程都是只...

dwj_daiwenjie的博客 4926

001:InVEST学习——产水/水源涵养

InVEST产水模块介绍 前言 (一些碎碎念着急的可以忽略)最开始做inVEST模型是2020年中,应该说对这个软件有很特殊的感情,之前一直想出一个教程,但是因为事情多加上拖延加上懒就耽搁了,事实证明东西不用就确实荒废了,现在面对当初自己做的东西顶多也就能想起一些思路,很多细节都忘了,所以这个教程也相当于是一个备忘录吧。 ...

Victoriaac的博客 2万+

四十二、Fluent欧拉模型流化床模拟:从基础设置到颗粒动力学解析

本文详细解析了Fluent欧拉模型在流化床模拟中的应用,从基础概念到颗粒动力学设置全面覆盖。重点介绍了欧拉模型的颗粒温度概念、多相流配置技巧以及关键参数优化策略,帮助工程师准确模拟气固两相流动现象。通过实用案例演示了网格检查、求解器配置和边界条件设置的最佳实践。

weixin_27303545的博客 445

别混淆数据争用(data race) 和竞态条件(race condition)

本文介绍并对比解析数据争用和竞态条件这两个概念,并以实际代码情景进行分析,最后给出解决方案。

hyman.lu 1万+

大数据在电力行业的应用案例解析-【电力技术】(九)大数据在电力储能运维中的深度应用(含故障预测代码)

大数据技术为电力储能运维提供了“精准化、智能化、高效化”的解决方案,破解了传统运维的核心痛点,实现了储能系统从“被动抢修”到“主动运维”的转型,为新型电力系统建设提供了重要支撑。当前,随着储能产业的快速发展,大数据与储能运维的融合将更加深入,未来将结合人工智能、物联网、区块链等技术,实现储能运维的全流程智能化——从设备故障的提前预警,到寿命的精准预测,再到运维策略的自动优化、调度协同的实时响应,进一步提升储能系统的安全性、经济性与可靠性。

getusushu的博客 88

what is a data race?

什么是 data race?data race 发生的充分条件1.两个或者更多线程在一个程序中,并发的访问同一数据;2.至少一个访问是写操作;3.这些线程都不使用任何互斥锁来控制这些访问。#当上面这些条件发生时,访问的顺序是不确定的,并且基于这些不同的运行顺序会导致计算产生不同的结果(这些结果也是正确的)。一些data race 是良性的,但是更多的是会产生程序 的bug。 https://docs

This is Chuanqiz's Blog 1268

第二章:创建交互式地图

那么您应该已经有了一个安装了这些包的 conda 环境。否则,您需要创建一个新的 conda 环境并使用以下命令安装。

韩天放 4219

【教程4>第8章>第44节】本章整体思维导图与学习总结

本教程系列提供FPGA/MATLAB/Simulink学习资源,包含《MATLAB入门100例》、《FPGA入门100例》、《Simulink入门60例》等基础教程,以及《FPGA/MATLAB/Simulink联合开发》进阶教程和《人工智能基础应用研究》专题,适合不同层次的学习者系统掌握相关技术。

FPGA/MATLAB学习教程/源码/项目合作开发 450

Java并发简述(同步注解、发布和溢出、并发容器、工作窃取、锁等)

《Java并发编程实战》知识点抽取

weixin_43626356的博客 1269

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Lock和Condition实现线程同步通信

1>Lock:          Lock比传统线程模型中的Synchronied方式更加面向对象,与生活中的锁类似,锁本身也应该是一个对象.两个线程执行的代码段要实现同步互斥的效果,它们必须用同一个Lock对象,锁是在代表要操作的资源的类的内部方法中,而不是线程代码中.         上面的输出器Outputer类就可以这样改写: class Outputer2 {

shenjianxz的博客 438

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

三、重排序和多线程之间通讯

.前言一、synchronized与Volatile二、重排序三、as-if-serial四、volatile在重排序的应用五、wait和notify 前言 一、synchronized与Volatile volatile 可以保证可见性,不能保证原子性(线程安全问题) 禁止重排序 synchronized 既可以保证可见性,还可以保证原子性 没有禁止重排序 synchronized是阻塞式的,同一时刻保证只能有一个线程在访问 二、重排序 概念:cpu会对代码实现执行优化,不会对有依赖关系

qq23001186的博客 177

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

多线程详解

​​学习的最大理由是想摆脱平庸,早一天就多一份人生的精彩;迟一天就多一天平庸的困扰。各位小伙伴,如果您:想系统/深入学习某技术知识点…一个人摸索学习很难坚持,想组团高效学习…想写博客但无从下手,急需写作干货注入能量…热爱写作,愿意让自己成为更好的人…...

m0_65144570的博客 2063

多线程同步控制和通信

多线程同步控制和通信

weixin_51640076的博客 155

Java基础:多线程间的通信

多个线程在处理同一个资源,但是线程的任务却不相同。例如生产者和消费者模式。假设有这样的一个系统,系统要求存钱者和取钱者不断重复存钱和取钱的两个动作,每当存钱者将钱存入指定账户后,取钱者就立即取出这笔钱。如何实现这样的要求,则需要利用线程通信机制。 线程通信的方式: 传统的线程通信 传统的线程通信 借助Object类提供的wait()、notify()、notifyall()三个方法。 关于这三个方...

qq_34848299的博客 212

多线程sleep()和wait()的区别

Java多线程是一种抢占式的机制,线程主要有以下几种状态:可运行,运行,阻塞,死亡。抢占式机制指的是有多个线程处于可运行状态,但是只有一个线程在运行。当有多个线程访问共享数据的时候,就需要对线程进行同步。每个对象都有一个机锁来控制同步访问。Synchronized关键字可以和对象的机锁交互,来实现线程的同步。线程中的几个主要方法的比较: Thread类的方法:sleep(),yi...

摸金校尉的博客 2万+
上一篇: Redis缓存何以一枝独秀?以及热门面试题中Redis的核心特性
下一篇: 膜拜!清华大佬整理Java开发岗面试题,成功拿下美团电商部offer
Java佳佳
博客等级 码龄4年 216粉丝 286原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值