【JUC】2.多线程锁

最新推荐文章于 2024-04-24 10:45:09 发布
最新推荐文章于 2024-04-24 10:45:09 发布
阅读量571 收藏 2
点赞数 2
分类专栏： JUC 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51146329/article/details/127139006
版权

文章目录

1. 乐观锁与悲观锁

什么是悲观锁呢？

悲观锁就是认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的数据的时候会先枷锁，确保数据不会被别的线程修改

根据悲观锁的定义，不难看出，悲观锁适合写操作多的场景，先加锁可以保证操作时数据的正确

一个一个人来写，这样就不会写乱了

常见的悲观锁有

  • synchronized关键字
  • Lock的实现类

那么什么是乐观锁呢？

乐观锁则认为自己在使用数据的时候，不会有别的线程修改数据和资源，所以不会添加锁

在Java中是通过无所编程来实现的，只有在更新数据的时候去判断，之前有没有别的线程更新数据

  • 如果这个数据没有被更新，当前线程将自己修改的数据成功写入
  • 如果这个数据已经被其他线程更新，则根据不同的实现方式执行不同的操作，比如放弃修改或者重试抢锁等等

根据乐观锁的定义。乐观锁适合读操作多的场景，不加锁的特点就是能够使得读操作性能大幅度提升

简而言之，乐观锁是一个佛系锁。

乐观锁判断规则

  • 版本号机制Version
  • 常见采用CAS算法，Java原子类中的递增操作就通过CAS自旋实现的

2. 从8种锁的案例理解锁

①标准访问ab两个线程，请问先打印邮件还是短信

class Phone{
    //发邮件
    public synchronized void sendEmail(){
        System.out.println("Send Email ~~~~");
    }
    //发短信
    public synchronized void sendSMS(){
        System.out.println("Send SMS ~~~");
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //休眠200毫秒
        try {
            TimeUnit.MICROSECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone.sendSMS();
        }, "b").start();

    }
}

在这里插入图片描述

答案是先打印邮件后打印短信

原因是因为两个方法都有synchronized关键字，而两个进程发短信和发邮件使用的都是同一个对象，所以存在竞争关系

由于synchronized属于悲观锁，因此当a线程使用这个对象，这个实例对象就会锁住了，其他线程想调用实例的方法需要等待其他线程用完

简而言之，同一个实例对象，只要有一个线程调用一个synchronized方法，其他线程就必须等待

②sendEmail方法加入暂停3秒，打印邮件还是短信

class Phone{
    //发邮件
    public synchronized void sendEmail(){
        try {
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send Email ~~~~");
    }
    //发短信
    public synchronized void sendSMS(){
        System.out.println("Send SMS ~~~");
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //休眠200毫秒
        try {
            TimeUnit.MICROSECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone.sendSMS();
        }, "b").start();

    }
}

在这里插入图片描述

从这个案例中，更能提现第一个案例的解释了

更能提现出锁的是new出来的Phone实例对象

③添加一个普通方法hello，先打印邮件还是短信

class Phone{
    //发邮件
    public synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send Email ~~~~");
    }
    //发短信
    public synchronized void sendSMS(){
        System.out.println("Send SMS ~~~");
    }

    public void hello(){
        System.out.println("hello ~~");
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //休眠200毫秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone.hello();
        }, "b").start();

    }
}

在这里插入图片描述

加了普通方法后则与同步锁无关，因此不存在竞争关系

④ 用两台手机，请问先打印邮件还是短信

class Phone{
    //发邮件
    public synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send Email ~~~~");
    }
    //发短信
    public synchronized void sendSMS(){
        System.out.println("Send SMS ~~~");
    }

    public void hello(){
        System.out.println("hello ~~");
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //休眠200毫秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone1.sendSMS();
        }, "b").start();

    }
}

在这里插入图片描述

换成两个对象后，因为不是同一把锁了，所以先打印短信后打印邮件

同一个对象的时候使用的是该实例做锁

⑤有两个静态同步方法，有一部手机，请问打印的是邮件还是短信

class Phone{
    //发邮件
    public static synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send Email ~~~~");
    }
    //发短信
    public static synchronized void sendSMS(){
        System.out.println("Send SMS ~~~");
    }

    public void hello(){
        System.out.println("hello ~~");
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //休眠200毫秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone.sendSMS();
        }, "b").start();

    }
}

在这里插入图片描述

和第二种例子一样，先打印邮件再打印短信

在这里是看不出区别，先看看下面的这种情况

⑥有两个静态方法，有两部手机，请问先打印邮件还是短信

class Phone{
    //发邮件
    public static synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send Email ~~~~");
    }
    //发短信
    public static synchronized void sendSMS(){
        System.out.println("Send SMS ~~~");
    }

    public void hello(){
        System.out.println("hello ~~");
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //休眠200毫秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone1.sendSMS();
        }, "b").start();

    }
}

在这里插入图片描述

还是先打印邮件后打印短信，这是为什么呢？

这是因为对于普通同步方法，锁的对象是当前实例对象，通常指this，具体的一部手机，所有普通同步方法都是同一把锁，也就是实例对象本身

而对于静态同步方法，锁的对象是当前类的class对象，如Phone.class文件，也就是每new一个对象，这多个对象对应的都是同一把锁

对于同步方法块，锁的是synchronized括号内对象

synchronized(o) {
    
}

⑦有一个静态同步方法，有一个普通同步方法，有一部手机，请问先打印邮件还是短信

class Phone{


    //发邮件
    public static synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send Email ~~~~");
    }
    //发短信
    public synchronized void sendSMS(){
        System.out.println("Send SMS ~~~");
    }

    public void hello(){
        System.out.println("hello ~~");
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //休眠200毫秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone.sendSMS();
        }, "b").start();

    }
}

在这里插入图片描述

前面说到所有普通同步方法用的都是同一把锁——实例对象，就是new出来的实例对象本身。本类this

也就是说如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放后才能获取锁

所有静态同步方法用的同一把锁——类对象本身，就是我们说过的唯一模板class

具体实例对象this和唯一模板class，这两把锁是不同对象，所以静态方法和普通同步方法之间是不会有竞态关系的，但是一旦一个静态同步方法获取锁后，其他静态同步方法就必须等待该方法释放锁后才能获取锁

⑧有一个静态同步方法，有一个普通同步方法，两台手机，请问先打印邮件还是短信

class Phone{


    //发邮件
    public static synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Send Email ~~~~");
    }
    //发短信
    public synchronized void sendSMS(){
        System.out.println("Send SMS ~~~");
    }

    public void hello(){
        System.out.println("hello ~~");
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();

        new Thread(() -> {
            phone1.sendEmail();
        }, "a").start();

        //休眠200毫秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            phone.sendSMS();
        }, "b").start();

    }
}

在这里插入图片描述

无论是一台手机还是多台手机，静态同步方法和普通同步方法不存在竟态关系

3. 公平锁与非公平锁

公平锁：指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到

非公平锁：指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。在高并发情况下，有可能造成优先级反转和饥饿现象

而在java.util.concurrent.locks.ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁。其默认为非公平锁

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

为什么会有公平锁/非公平锁的设计？（为什么默认非公平锁）

  • 恢复挂起线程到真正锁的获取还是有时间差的，从开发人员来看这个时间微乎其微，但是从CPU的角度来看，这个时间差存在的还是比较明显的。所以非公平锁能更加充分利用CPU的时间片，尽量减少CPU空闲状态的时间
  • 使用多线程很重要的考量点是线程切换的开销，当使用非公平锁的时候，当一个线程请求锁获得同步状态然后释放同步状态，所以刚释放锁的线程在此刻再次获得锁状态概率变大，所以减少了线程开销

总而言之，非公平锁的效率比公平锁的效率要高

既然有两种锁，那么什么时候用公平锁？什么时候用非公平锁呢？

前面说到非公平锁的效率比公平锁的效率要高，所以如果是为了更高的吞吐量，很显然非公平锁更加合适，因为节省了很多线程切换时间，吞吐量自然就上去了。否则那就使用公平锁，大家公平使用。

4. 可重入锁（递归锁）

可重入锁是指同一线程再外层方法获取锁的时候，再次进入该线程内层会自动获取锁（前提，锁的对象是同一个锁），不会因为之前已经获取过还没有释放而阻塞。

如果没有可重入锁，当内外层锁对象是一样的话，准备进入内部的时候需要获取该锁对象，但是该锁对象在进入外层的时候就已经获取了，需要等待自己释放最外层的锁才可以获取内层的锁，这就会出现自我阻塞

Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是在一定程度上避免了死锁

4.1使用synchronized实现（隐式锁）

隐式锁支持同步块和同步方法

同步块

public class ReEntryLockDemo {
    public static void main(String[] args) {
        final Object object = new Object();

        new Thread(() -> {
            synchronized (object){
                System.out.println(Thread.currentThread().getName() + "\t---外层调用");
                synchronized (object){
                    System.out.println(Thread.currentThread().getName() + "\t---中层调用");
                    synchronized (object){
                        System.out.println(Thread.currentThread().getName() + "\t---内层调用");
                    }
                }
            }
        }).start();
    }
}

同步方法

public class ReEntryLockDemo {
    public static void main(String[] args) {
        new ReEntryLockDemo().m1();
    }

    public synchronized void m1(){
        System.out.println(Thread.currentThread().getName() + "\t---come in m1");
        m2();
        System.out.println(Thread.currentThread().getName() + "\t---end in m1");
    }

    public synchronized void m2(){
        System.out.println(Thread.currentThread().getName() + "\t---come in m2");
        m3();
    }

    public synchronized void m3(){
        System.out.println(Thread.currentThread().getName() + "\t---come in m3");
    }

}

4.2 使用ReentrantLock实现（显式锁）

public class ReEntryLockDemo {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t---外层调用");
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t---中层调用");
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + "\t---内层调用");
                } finally {
                    lock.unlock();
                }
            } finally {
                lock.unlock();
            }
        } finally {
            lock.unlock();
        }
    }
}

5. 死锁

5.1 什么是死锁？？？

死锁只是两个或两个以上的线程在执行过程中，因争夺资源而造成的一种相互等待的现象；若无外力干涉那么他们无法推进下去，如果系统资源充足，进程资源请求都得到满足，死锁出现的可能性就会很低，否则就会因争夺有限资源而陷入死锁

在这里插入图片描述

5.2 尝试写出一个死锁

public class DeadLockDemo {
    public static void main(String[] args) {
        final Object objectA = new Object();
        final Object objectB = new Object();

        new Thread(() -> {
            synchronized (objectA){
                System.out.println(Thread.currentThread().getName() + "\t自己持有A锁，希望获得B锁");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (objectB){
                    System.out.println(Thread.currentThread().getName() + "\t成功获得B锁");
                }
            }
        }, "A").start();

        new Thread(() -> {
            synchronized (objectB){
                System.out.println(Thread.currentThread().getName() + "\t自己持有B锁，希望获得A锁");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (objectA){
                    System.out.println(Thread.currentThread().getName() + "\t成功获得A锁");
                }
            }
        }, "B").start();
    }
}

5.3 死锁产生的原因

  • 系统资源不足
  • 进程运行推进的顺序不合适
  • 资源分配不当

5.4 如何排除死锁

有两种方法

使用命令行，我这里使用idea，需要以管理员身份运行idea

然后在命令行输入

jps -l

然后就可以查看到进程编号

在这里插入图片描述

再使用另一个命令查看进行信息

jstack 进程号

在这里插入图片描述

输出显示发现一个死锁

还有一种方法就是通过图形化

首先win + r输入jconsole

在这里插入图片描述

找到进程进行连接

在这里插入图片描述

点击线程，下面有个检测死锁的按钮

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

起名方面没有灵感
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java——聊聊JUC中的锁（synchronized & Lock & ReentrantLock）
java_lujj的博客
09-12 330
这篇文章是关于锁的，是入门级别的文章，后续还会有更深入、更底层的JUC，我会慢慢更新的。。。
多线程之 JUC下的一些同步锁
qq_34548229的博客
11-20 169
![在这里插入图片描述](https://img-blog.csdnimg.cn/20191120000659604.png)
java多线程--“锁”总览
节至
07-01 2254
根据锁的添加到Java中的时间，Java中的锁，可以分为"同步锁"和"JUC包中的锁"。 同步锁 　　即通过synchronized关键字来进行同步，实现对竞争资源的互斥访问的锁。Java 1.0版本中就已经支持同步锁了。 　　同步锁的原理是，对于每一个对象，有且仅有一个同步锁；不同的线程能共同访问该同步锁。但是，在同一个时间点，该同步锁能且只能被一个线程获取到。这样，获取到同步锁的线程就能
Java JUC 源码分析 - 线程死锁、饥饿、活锁
最新发布
qq_33240556的博客
04-24 278
Java并发编程中的线程死锁、饥饿和活锁是多线程环境下可能出现的活跃性问题，虽然它们不是JUC（Java Util Concurrency）包中具体的类或方法，但在使用JUC包内的同步工具时，理解和预防这些问题是非常关键的。下面分别对这三种现象进行简要说明，并结合JUC相关特性探讨如何在源码层面分析和避免这些问题。
JUC编程-多线程锁
m0_49760452的博客
04-11 452
文章目录1.公平锁及非公平锁公平锁实现方式：优点缺点非公平锁优点缺点2.可重入锁3.死锁什么是死锁？产生死锁原因： 1.公平锁及非公平锁 公平锁 按照线程等待顺序获取锁，一般将获取锁失败的线程放入等待队列中，每次从FIFO队列的队头取出线程获取锁。这种方式会造成性能低下，大量的时间花费在线程调度上。 实现方式： ReentrantLock lock=new ReentrantLock(true);//true表示获取公平锁 优点 雨露均沾 缺点 效率相对较低 非公平锁 不管等待顺序，每个线程获取
【JUC】多线程锁
ly甲烷的博客
03-07 366
synchronized锁的对象 Java中每个对象都可以作为锁。具体表现为以下三种形式： 对于普通同步方法，锁是当前实例对象this 对于静态同步方法，锁是当前类字节码，Class对象 对于同步方法块，锁是synchronized括号里配置的对象 公平锁和非公平锁 ...
JUC多线程学习个人笔记
07-08
JUC（Java Util Concurrent）是Java中用于并发编程的工具包，提供了一组接口和类，用于处理多线程和并发操作。JUC提供了一些常用的并发编程模式和工具，如线程池、并发集合、原子操作等。 JUC的主要特点包括： ...
多线程基础、JUC锁、同步容器、线程池
07-11
多线程基础、JUC锁、同步容器、线程池
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
多线程源码JUC以及多线程和高并发
01-22
多线程源码JUC以及多线程和高并发 https://blog.csdn.net/u011488009 主要是根据 https://blog.csdn.net/u011488009/category_9678616.html 专栏来讲解的源码，都可以作为高并发的学习，练手用，主要是看这个源码...
JUC相关知识和底层实现原理分析.jpg
09-02
JUC底层实现原理分析，结构多线程更加贯彻同步知识
JUC并发编程——多把锁
m0_56188609的博客
03-07 596
线程1按AB的顺序加锁，先获得锁A，线程2也是按AB的顺序进行加锁，线程2此时想获取对象A的锁时获取失败（进入对象A的EntryList中阻塞），这时线程1再尝试获取B对象的锁。死锁是两个线程持有对方需要的锁，导致线程都无法继续向下运行，两个线程均陷入阻塞；● 使两个线程的执行时间有一定的交错（不集中在一起执行/设置睡眠的时间为一个随机数===>将其指令交错开，第一个线程很快运行完，第二个线程将没有机会改变对方的结束条件）现在小南要学习，小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低。
JUC-多线程锁
思变的博客
12-27 186
1.可重入锁，可重入锁有 synchronized、ReentrantLock 某个线程已经获得某个锁，可以再次获取锁而不会出现死锁 public class WhatReentrant { public static void main(String[] args) { new Thread(() -> { synchronized (WhatReentrant.class) { System.out.println
JUC线程8锁
yhw_1125的博客
08-12 125
JUC : java.util.concurrent 1.线程 操作 资源（类） 2.高内聚 低耦合 lock代替synchronized; synchronized : 锁提供了对共享资源的独占访问,一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁 ; lock提供了更加功能的锁； lock = synchroizesd++ Lock 实现提供了比使用 synchron...
JUC并发编程之集合的线程安全、多线程锁
maxker的博客
12-28 167
集合的线程安全问题以及解决方法、死锁发生的场景、原因以及其对应的判断方法、如何手写死锁
JUC学习之线程8锁
dyt443733328的博客
04-20 743
本文为看视频学习资料，若有错误，请指正，谢谢！介绍线程8锁围绕一个题目展开，题目：打印的是“one”还是“two”？1.两个普通同步方法，两个线程，打印？public class TestThread8Monitor { public static void main(String[] args){ Number number = new Number(); ...
JUC-Lock接口概述和实现案例
兴趣是最好的老师
09-16 178
JUC-Lock接口概述和实现案例
JUC学习：多线程锁的种类
qq_45266399的博客
10-13 138
多线程编程锁的相关知识点
JUC-多线程锁的范围
qq_42296117的博客
08-11 197
synchronized实现同步的基础：Java中的每一个对象都可以作 为锁。 三种形式： 1：对于静态同步方法，锁是当前类的Class对象。 public static synchronized void xxx() 静态同步方法锁的是当前类的Class对象：比如有3个Person的实例，第一个实例如果先进入了这个对象没出来，其他两个实例都无法进入这个静态同步方法，因为这个静态同步方法锁的是Class对象 2:：普通同步方法，其锁是当前实例对象 public synchronized void x
java多线程锁面试题
09-21
Java多线程中的锁有两类，分别是synchronized关键字和Lock接口。synchronized关键字是Java中最基本的线程同步机制，通过在方法或代码块上加锁来实现线程的同步。Lock接口是Java并发包（JUC）中提供的一种更加灵活和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

起名方面没有灵感

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

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

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

打赏作者

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

抵扣说明：

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

余额充值