ReentrantLock重入锁详解

最新推荐文章于 2024-04-25 20:21:31 发布
最新推荐文章于 2024-04-25 20:21:31 发布
阅读量311 收藏 1
点赞数 1
分类专栏： java 多线程 文章标签： java 并发编程 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38209767/article/details/115410803
版权

ReentrantLock重入锁

Lock有很多锁的实现，但是直观的实现是ReentrantLock重入锁。

在这里插入图片描述

重入锁的设计目的

比如调用 demo 方法获得了当前的对象锁，然后在这个方法中再去调用demo2，demo2 中的存在同一个实例锁，这个时候当前线程会因为无法获得demo2 的对象锁而阻塞，就会产生死锁。重入锁的设计目的是避免线程的死锁。

ReentrantLock的使用

public class Demo {

    private static int i = 0;

    private static Lock lock = new ReentrantLock();

    public static void test(){
        lock.lock();
        try{
            i++;
        }finally {
            //一定要在finally中释放锁
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int j = 0; j < 1000; j++) {
            new Thread(() -> {
               test();
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(i);
    }
}

ReentrantReadWriteLock的使用

public class Demo1 {

    static Map<String, Object> cacheMap = new HashMap<>();
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock read = rwl.readLock();
    static Lock write = rwl.writeLock();

    public static final Object get(String key) {
        System.out.println("开始读取数据");
        read.lock(); //读锁
        try {
            return cacheMap.get(key);
        } finally {
            read.unlock();
        }
    }

    public static final Object put(String key, Object value) {
        System.out.println("开始写数据");
        write.lock();//写锁
        try {
            return cacheMap.put(key, value);
        } finally {
            write.unlock();
        }
    }
}

在这个案例中，通过 hashmap 来模拟了一个内存缓存，然后使用读写所来保证这个内存缓存的线程安全性。当执行读操作的时候，需要获取读锁，在并发访问的时候，读锁不会被阻塞，因为读操作不会影响执行结果。在执行写操作是，线程必须要获取写锁，当已经有线程持有写锁的情况下，当前线程会被阻塞，只有当写锁释放以后，其他读写操作才能继续执行。使用读写锁提升读操作的并发性，也保证每次写操作对所有的读写操作的可见性

  • 读锁与读锁可以共享

  • 读锁与写锁不可以共享（排他）

  • 写锁与写锁不可以共享（排他）

ReentrantLock的实现原理

实现锁要考虑的问题

  • 锁的互斥性：共享资源，标记
  • 没有抢占到锁的线程：阻塞，释放CPU资源，唤醒
  • 存储等待线程：队列 FIFO
  • 公平和非公平特性：能否插队
  • 重入特性：同一线程，在持有锁的情况下，再次获取锁，不需要阻塞
CAS 的实现原理
protected final boolean compareAndSetState(int 
expect, int update) {
 // See below for intrinsics setup to support this
 	return unsafe.compareAndSwapInt(this, stateOffset, 			expect, update);
}

通过 cas 乐观锁的方式来做比较并替换，这段代码的意思是，如果当前内存中的state 的值和预期值 expect 相等，则替换为 update。更新成功返回 true，否则返回 false.这个操作是原子的，不会出现线程安全问题，这里面涉及到Unsafe这个类的操作，以及涉及到 state 这个属性的意义。

加锁 lock.lock()

lock.lock()方法有两个实现，公平锁和非公平锁，先看非公平锁NonfairSync.lock()

假设有三个线程ThreadA、ThreadB、ThreadC抢占锁lock

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;
    final void lock() {
        //通过CAS 设置状态成功，标识当前线程获得锁 ThreadA
        //设置lock实例中 exclusiveOwnerThread为当前线程，state=1
        //然后直接返回，继续执行ThreadA中 lock.lock();之后的代码
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

此时线程ThreadB、ThreadC无法获得锁，进入到acquire(1)方法中

//该方法在AbstractQueuedSynchronizer类中
public final void acquire(int arg) {
    //arg = 1
    //tryAcquire(arg) 会再次尝试获取锁
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        //如果传递过来线程中断状态为true 则设置Thread.currentThread().interrupt();
        selfInterrupt();
}

//该方法在ReentrantLock.NonfairSync类中
protected final boolean tryAcquire(int acquires) {
	return nonfairTryAcquire(acquires);
}

//该方法在该方法在ReentrantLock.Sync类中
final boolean nonfairTryAcquire(int acquires) {
    //拿到当前线程 ThreadB
    final Thread current = Thread.currentThread();
    //得到lock的state值，
    //这一步有可能ThreadB进来时，ThreadA没有释放锁 ，而等到ThreadC进来时刚好释放锁，从而会让ThreadC插队
    int c = getState();
    if (c == 0) {
        //若state == 0，则直接获得锁，直接返回，直接执行ThreadB中lock.lock之后的代码
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //如果state!=0，但是 当前线程是lock中的exclusiveOwnerThread，则是同一线程，属于重入，不阻塞，将state++，然后直接返回
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    //以上情况都不是，说明未获得锁，返回false，执行acquireQueued方法 首先将执行addWaiter方法
    return false;
}

//该方法在AbstractQueuedSynchronizer类中
private Node addWaiter(Node mode) {
    //新建一个Node nextWaiter = EXCLUSIVE = null; thread = ThreadB
    Node node = new Node(Thread.currentThread(), mode);
    // 拿到链表尾部元素
    Node pred = tail;
    //如果不为null
    if (pred != null) {
        //设置该节点的上一个节点为尾节点，并且设置该节点为尾节点
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //如果tail为空 或者CAS替换尾部节点失败 进入enq方法
    enq(node);
    return node;
}

private Node enq(final Node node) {
    //传入的node thread = ThreadB nextWaiter = null
    for (;;) {
        //自旋
        Node t = tail;
        //如果尾节点为空 代表链表为空，需要初始化
        if (t == null) { // Must initialize
            //CAS设置head头结点（thread = null） 设置成功后 设置 tail=head
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //如果链表已经不为空 设置node的前一个节点为尾节点 且CAS替换尾节点为node
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

//添加到等待队列后 执行acquireQueued()方法
//进入到
final boolean acquireQueued(final Node node, int arg) {
    // node thread = ThreadB C线程进来之前可以认为ThreadB为tail
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            //自旋
            //获得当前节点的前一个节点 如果为头结点，则进行抢占锁，若抢占成功，则舍弃头结点，将当前节点设置为头结点，且设置thread 由ThreadB变为NULL 返回false
            final Node p = node.predecessor();//由这一行代码可知，进入链表后，获得锁的顺序是固定的
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
     //若当前节点的头一个节点不是头结点 或者没有成功抢占锁 则进入到shouldParkAfterFailedAcquire方法
            //当前一个节点的waitStatus变为waitStatus为SIGNAL后，进入parkAndCheckInterrupt
            //LockSupport.park(this); 阻塞当前线程
            //当线程再次被唤醒以后 会向上传递interrupted状态
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        //如果自旋过程中，如果线程被终止 设置waitStatus为cancel
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //pred 当前节点的前一个节点 node当前节点 出事的waitStatus都是0
    //所以首先会进入到compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    //再次进入时，pred.waitStatus为SIGNAL 直接返回true
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)//Node.SIGNAL = -1
        /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
        return true;
    if (ws > 0) {
        //ws>0 表示为cancel状态 需要移除
        /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
        // cas设置当前节点的前一个节点waitStatus 为SIGNAL 返回到上一个方法后 继续自旋进入
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

stateOffset

一个 Java 对象可以看成是一段内存，每个字段都得按照一定的顺序放在这段内存里，通过这个方法可以准确地告诉你某个字段相对于对象的起始内存地址的字节偏移。用于在后面的 compareAndSwapInt 中，去根据偏移量找到对象在内存中的具体位置所以 stateOffset 表示 state 这个字段在 AQS 类的内存中相对于该类首地址的偏移量

释放锁 lock.unlock()
public final boolean release(int arg) {
    //arg 1
    if (tryRelease(arg)) {
        //tryRelease成功释放锁后 拿到头结点，如果头结点不为空，且h.waitStatus 不为初始值，前面已经讲过，在阻塞之前会设置为SIGNAL -1
        Node h = head;
        if (h != null && h.waitStatus != 0)
            //唤醒线程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    //getState() 一个线程在一次持有锁的过程中 进入同一个共享资源锁定的代码的次数（重入次数+1）
    int c = getState() - releases;
    //如果当前线程不是lock中的ExclusiveOwnerThread 抛出IllegalMonitorStateException
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // c==0 代表当前线程的锁可以释放，进入次数与调用lock.unlock()相同
    //设置lock的ExclusiveOwnerThread 为null 返回true
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    //设置lock的state
    setState(c);
    return free;
}

private void unparkSuccessor(Node node) {
    //传进来的时头结点 head
    /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
    int ws = node.waitStatus;
    if (ws < 0)
        //如果头结点的waitStatus 为SIGNAL 则改为0
        compareAndSetWaitStatus(node, ws, 0);

    /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
    // 拿到头结点的下一个节点
    Node s = node.next;
    //如果下一个节点为空 或者是cancel状态，则提出这个节点
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        //如果不为空 则唤醒节点 ThreadB会去竞争资源
        LockSupport.unpark(s.thread);
}

在这里插入图片描述

为什么在释放锁的时候是从 tail 进行扫描

来看一个新的节点是如何加入到链表中的

  1. 将新的节点的 prev 指向 tail
  2. 通过 cas 将 tail 设置为新的节点，因为 cas 是原子操作所以能够保证线安全性
  3. t.next=node；设置原 tail 的 next 节点指向新的节点

在 cas 操作之后，

t.next=node 操作之前。

存在其他线程调用 unlock 方法从 head开始往后遍历，由于 t.next=node 还没执行意味着链表的关系还没有建立完整。就会导致遍历到 t 节点的时候被中断。所以从后往前遍历，一定不会存在这个问题。

公平锁和非公平锁的区别

锁的公平性是相对于获取锁的顺序而言的，如果是一个公平锁，那么锁的获取顺序就应该符合请求的绝对时间顺序，也就是 FIFO。 在上面分析的例子来说，只要CAS 设置同步状态成功，则表示当前线程获取了锁，而公平锁则不一样，差异点有两个

  1. 非公平锁在获取锁的时候，会先通过 CAS 进行抢占，而公平锁则不会

    //FairSync.tryAcquire
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

//这个方法与 nonfairTryAcquire(int acquires)比较，不同的地方在于判断条件多了hasQueuedPredecessors()方法，也就是加入了[同步队列中当前节点是否有前驱节点]的判断，如果该方法返回true，则表示有线程比当前线程更早地请求获取锁，因此需要等待前驱线程获取并释放锁之后才能继续获取锁。

AQS AbstractQueuedSynchronizer（同步队列）

在 Lock 中，用到了一个同步队列 AQS，全称 AbstractQueuedSynchronizer，它是一个同步工具也是 Lock 用来实现线程同步的核心组件。如果你搞懂了 AQS，那么 J.U.C 中绝大部分的工具都能轻松掌握。

AQS的两种功能

从使用层面来说，AQS 的功能分为两种：独占和共享

  • 独占锁，每次只能有一个线程持有锁，比如ReentrantLock 就是以独占方式实现的互斥锁
  • 共享锁，允 许 多 个 线 程 同 时 获 取 锁 ， 并 发 访 问 共 享 资 源 ， 比 如ReentrantReadWriteLock的读-读

AQS的内部实现

AQS队列内部维护的是一个FIFO的双向列表，这种结构的特点就是，每个节点有两个指针分别指向前一节点和后一节点。所以双向链表可以很方便的从任意节点访问其前一节点和后一节点。每个Node其实是有Thread封装的，当前程抢占锁失败后，会封装成Node到AQS中。当获取锁的线程释放锁以后，又会从AQS中选一个节点（线程）唤醒。

Node 的组成

在这里插入图片描述

释放锁以及添加线程对于队列的变化

当出现锁竞争以及释放锁的时候，AQS 同步队列中的节点会发生变化，首先看一下添加节点的场景。

在这里插入图片描述

这里会涉及到两个变化

  1. 新的线程封装成Node节点追加到同步队列中，设置 prev节点以及修改当前节点的前置节点的next节点指向自己
  2. 通过CAS将tail 重新指向新的尾部节点

head 节点表示获取锁成功的节点，当头结点在释放同步状态时，会唤醒后继节点，如果后继节点获得锁成功，会把自己设置为头结点，节点的变化过程如下
在这里插入图片描述

这个过程也是涉及到两个变化

  1. 修改 head 节点指向下一个获得锁的节点
  2. 新的获得锁的节点，将 prev 的指针指向 null

设置 head 节点不需要用 CAS，原因是设置 head 节点是由获得锁的线程来完成的，而同步锁只能由一个线程获得，所以不需要 CAS 保证，只需要把 head 节点设置为原首节点的后继节点，并且断开原 head 节点的 next 引用即可

整体流程图

在这里插入图片描述

Vince-chen
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解java并发之重入锁-ReentrantLock
08-26
主要介绍了java并发之重入锁-ReentrantLock，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
ReentrantLock源码详解--条件锁
08-25
主要介绍了ReentrantLock源码之条件锁，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面我们来一起学习一下吧
【死磕Java并发】-----J.U.C之重入锁：ReentrantLock
chenssy 的技术博客
03-26 6267
此篇博客所有源码均来自JDK 1.8 ReentrantLock，可重入锁，是一种递归无阻塞的同步机制。它可以等同于synchronized的使用，但是ReentrantLock提供了比synchronized更强大、灵活的锁机制，可以减少死锁发生的概率。 API介绍如下： 一个可重入的互斥锁定 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行
ReentrantLock重入锁
SuNew_bee的博客
05-24 294
重入锁的概念   ReentrantLock的意思为重入锁，重入锁完全可以替代synchronized。   ReentrantLock与synchronized相比，它有显示的上锁释放锁的操作过程，所以比Synchronized灵活很多。上锁、释放锁的方式： public ReentrantLock lock = new ReentrantLock(); lock.lock();//上锁 lock.unlock();//释放锁   为什么叫重入锁呢，因为对于同一个线程来说，只要获取到重入锁那么就可以重
ReentrantLock(可重入锁)源码解读与使用
最新发布
qq_35716689的博客
04-25 8486
ReentrantLock是一种独占式的可重入锁，位于JUC包下，是Lock接口的默认实现类。有三个特性：支持可重入，支持公平与非公平特性，提供堵塞锁和非阻塞锁两种获取方法（lock和trylock） 其中内部锁的竞争是基于AQS实现的，当某一线程获取锁后，将state值+1，并记录下当前持有锁的线程，再有线程来获取锁时，判断这个线程与持有锁的线程是否是同一个线程，如果是，将state值再+1，这样就实现了锁的可重入。当线程释放锁时，将state值-1，当state值减为0时，表示当前线程彻底释放了锁，唤
Java 重入锁 ReentrantLock 原理分析
dishitu6229的博客
05-08 342
1.简介 可重入锁ReentrantLock自 JDK 1.5 被引入，功能上与synchronized关键字类似。所谓的可重入是指，线程可对同一把锁进行重复加锁，而不会被阻塞住，这样可避免死锁的产生。ReentrantLock 的主要功能和 synchronized 关键字一致，均是用于多线程的同步。但除此之外，ReentrantLock 在功能上比 synchronized 更为丰富...
JAVA并发-重入锁ReentrantLock
rick_zyl的博客
08-14 122
一、ReentrantLock 重入锁ReentrantLock，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对 资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。 synchronized关键字隐式的支持重进入，比如一个synchronized修饰的递归方法，在方法执行时，执行线程在获取了锁之后仍能连续多次地获得该锁。ReentrantLock虽然没能像sync...
ReentrantLock——重入锁
rui920418的博客
05-29 288
ReentrantLock在AQS简介与源码分析中有所提及，本篇将用JDK1.8深入探索它内在的含义以及公平锁和非公平锁的性能测试比较。ReentrantLock实现了Lock接口，Lock接口提供比使用synchronized方法和语句有着更灵活的结构化，此外它还提供了其他功能，包括定时的锁等待、可中断的锁等待并且可以支持多个关联 Condition对象(关于Condition后续博文会单独解释...
Java多线程 ReentrantLock互斥锁详解
08-25
主要介绍了Java多线程 ReentrantLock互斥锁详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
ReentrantLock源码详解--公平锁、非公平锁
08-25
ReentrantLock重入锁，是实现Lock接口的一个类，也是在实际编程中使用频率很高的一个锁，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞。下面我们来深入了解一下它吧
Java中的显示锁ReentrantLock使用与原理详解
08-26
主要介绍了Java中的显示锁ReentrantLock使用与原理详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
[图解Java]ReentrantLock重入锁
weixin_30750335的博客
07-27 74
图解ReentrantLock 0. demo 我先给出一个demo, 这样大家就可以根据我给的这段代码, 边调试边看源码了. 还是那句话: 注意"My" , 我把ReentrantLock类 改名为了 "MyReentrantLock"类 , "Lock"类 改名为了"MyLock"类. 大家粘贴我的代码的时候, 把相应的"My"都去掉就好了, 否则会编译报错哦. import jav...
Java并发编程 | 第二篇：ReentrantLock重入锁
w
04-02 863
首先重入锁用ReentrantLock来实现的，关于重入锁ReentrantLock的几个重要方法： 1、lock（）：获得锁，如果锁被占用，只能等待 2、lockInterruptibly（）：获得锁，可以响应中断 3、tryLock（）：尝试获得锁，如果成功返回true，失败返回false，该方法不等待，立即返回 4、tryLock（long time，TimeUnit unit）：设...
Java并发编程之美(1) ReentrantLock重入锁
SoySauce_lm的博客
01-15 6655
Java并发编程之美(1）ReentrantLock重入锁简介locktryLock公平锁 简介 在JDK5.0版本之前，重入锁的性能远远好于synchronized关键字， JDK6.0版本之后synchronized 得到了大量的优化，使得两者性能差距不大. 与synchronized相比,重入锁有着显示的操作过程, 我们可以手动指定何时加锁,何时释放锁, 因此重入锁对逻辑控制的灵活性要远远...
java高并发系列 - 第12天JUC:ReentrantLock重入锁
yuzhiqiang_1的博客
11-08 167
java高并发系列 - 第12天JUC:ReentrantLock重入锁 2019-11-06 11:10:53爱我你会火_阅读数 3更多 分类专栏：Java高并发 编辑 原文链接：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933116&idx=1&sn=83ae2d1381e3b8a4...
ReentrantLock可重入锁
leonfree777的博客
11-06 205
Lockjava.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为 Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。 ReentrantLock是什么？ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，
reentrantlock原理_重入锁：ReentrantLock 详解
05-26
重入锁（ReentrantLock）是一种独占锁，也就是说同一时间只能有一个线程持有该锁。与 synchronized 关键字不同的是，重入锁可以支持公平锁和非公平锁两种模式，而 synchronized 关键字只支持非公平锁。 重入锁的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值