4.Lock的使用

最新推荐文章于 2024-09-14 19:44:09 发布
最新推荐文章于 2024-09-14 19:44:09 发布
阅读量382 收藏
点赞数
分类专栏： JAVA多线程编程核心技术笔记 文章标签： java jdk 多线程 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ning421479924/article/details/70337218
版权


本章着重掌握如下2个知识点：

  • ReentrantLock类的使用
  • ReentrantReadWriteLock类

使用ReentrantLock类
前提:在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比比synchronized更加的灵活。

先来看个例子:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {
    private Lock lock = new ReentrantLock();
    public void testMethod(){
        lock.lock();
        for(int i = 0; i < 5; i++){
            System.out.println("ThreadName=" + Thread.currentThread().getName() + (" " + (i + 1)));
        }
        lock.unlock();
    }
}

说明：调用ReentrantLock对象的lock()方法获取锁，调用unlock()方法释放锁。 

import chapter4.ReentrantLockTest.service.MyService;

public class MyThread extends Thread{
    private MyService service;
    public MyThread(MyService service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.testMethod();
    }
}


import chapter4.ReentrantLockTest.extthread.MyThread;
import chapter4.ReentrantLockTest.service.MyService;

public class Run {
    public static void main(String[] args){
        MyService service = new MyService();
        MyThread a1 = new MyThread(service);
        MyThread a2 = new MyThread(service);
        MyThread a3 = new MyThread(service);
        MyThread a4 = new MyThread(service);
        MyThread a5 = new MyThread(service);
        a1.start();
        a2.start();
        a3.start();
        a4.start();
    }
}



结果：
这里写图片描述


从运行的结果来看，当前线程打印完毕之后将锁进行释放，其他线程才可以继续打印。线程打印的数据是分组打印，因为当前线程已经持有锁，但线程之间打印的顺序时随机的。调用lock.lock()代码的线程就持有了”对象监视器”，其他线程只有等待锁被释放时再次争抢。效果和使用synchronized关键字一样，线程之间还是顺序执行的。


使用Condition实现等待/通知
前提:关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式，类ReentrantLock也可以实现同样的功能，但需要借助于Condition对象。Condition类是在JDK5中出现的技术，使用它有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition(即对象监视器)实例，线程对象可以注册在指定的Condition中，从而可以有选择性进行线程通知，在调度线程上更加灵活。

比较:在使用notify()/notifyAll()方法进行通知时，被通知的线程却是JVM随机选择的。但使用ReentrantLock结合Condition类是可以实现前面介绍过的”选择性通知”，这个功能是非常重要的，而且在Condition类中是默认提供的。而synchronized就相当于整个Lock对象中只有一个单一的Condition对象，所有的线程都注册在一个对象的身上。线程开始notifyAll()时，需要通知所有的WAITING线程，没有选择权，会出现相当大的效率问题。

看个例子:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void await(){
        try{
            lock.lock();
            System.out.println("await 时间为 " + System.currentTimeMillis());
            condition.await();
            System.out.println("B");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
            System.out.println("锁释放了!");
        }
    }

    public void signal(){
        try{
            lock.lock();
            System.out.println("signal时间为 " + System.currentTimeMillis());
            condition.signal();
        }finally {
            lock.unlock();
        }
    }
}


import chapter4.z3_ok.service.MyService;

public class MyThreadA extends Thread{
    private MyService myService;

    public MyThreadA(MyService myService){
        super();
        this.myService = myService;
    }

    @Override
    public void run(){
        myService.await();
    }
}


import chapter4.z3_ok.extthread.MyThreadA;
import chapter4.z3_ok.service.MyService;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        MyThreadA a = new MyThreadA(service);
        a.start();
        Thread.sleep(3000);
        service.signal();
    }
}



结果：
这里写图片描述

总结：Object类中的wait()方法相当于Condition类中的await()方法。Object类中的await(long timeout)方法相当于Condition类中的await(longtime, TimeUnit unit)方法。Object类中的notify()方法相当于Condition类中的signal()方法。Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。


使用多个Condition实现通知部分线程

看个例子:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {
    private ReentrantLock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    public void awaitA(){
        try{
            lock.lock();
            System.out.println("begin awaitA 时间为 "
                    + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            conditionA.await();
            System.out.println("end awaitA 时间为 "
                    + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void awaitB(){
        try{
            lock.lock();
            System.out.println("begin awaitB 时间为 "
                    + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            conditionB.await();
            System.out.println("end awaitB 时间为 "
                    + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void signalAll_A(){
        try{
            lock.lock();
            System.out.println(" signalAll_A 时间为 "
                    + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            conditionA.signalAll();
        }finally {
            lock.unlock();
        }
    }

    public void signalAll_B(){
        try{
            lock.lock();
            System.out.println(" signalAll_B 时间为 "
                    + System.currentTimeMillis() + " ThreadName=" + Thread.currentThread().getName());
            conditionB.signalAll();
        }finally {
            lock.unlock();
        }
    }
}


import chapter4.z3_ok.service.MyService;

public class MyThreadA extends Thread{
    private MyService myService;

    public MyThreadA(MyService myService){
        super();
        this.myService = myService;
    }

    @Override
    public void run(){
        myService.awaitA();
    }
}


import chapter4.z3_ok.service.MyService;

public class MyThreadB extends Thread{

    private MyService service;

    public MyThreadB(MyService service){
        super();
        this.service = service;
    }

    @Override
    public void run(){
        service.awaitB();
    }
}


import chapter4.z3_ok.extthread.MyThreadA;
import chapter4.z3_ok.extthread.MyThreadB;
import chapter4.z3_ok.service.MyService;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        MyThreadA a = new MyThreadA(service);
        a.setName("A");
        a.start();
        MyThreadB b = new MyThreadB(service);
        b.setName("B");
        b.start();
        Thread.sleep(3000);
        service.signalAll_A();
        service.signalAll_B();
    }
}



结果：
这里写图片描述

公平锁与非公平锁
说明:公平锁与非公平锁：锁Lock分为”公平锁”和”非公平锁”，公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。

用法:公平锁 ReentrantLock lock = new ReentrantLock(true);

用法:非公平锁 ReentrantLock lock = new ReentrantLock(false);


Lock其他方法介绍：

getHoldCount():作用是查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。

getQueueLength():作用是返回正等待获取此锁定的线程的线程估计数，比如有5个线程，1个线程首先执行await()方法，那么调用getQueueLength()方法后返回值是4，说明有4个线程同时在等待lock的释放。

getWaitQueueLength(Condition condition):作用是返回等待与此锁定相关的给定条件Condition的线程估计数，比如有5个线程，每个线程都执行了同一个condition对象的await()方法，则调用getWaitQueueLength(Condition conditon)方法时返回的int值是5。

hasQueuedThread(Thread thread):作用是查询指定的线程是否正在等待获取此锁定。

hasQueuedThreads():作用是查询是否有线程正在等待获取此锁定。

hasWaiters(Condition condition):作用是查询是否有线程正在等待与此锁定有关的condition条件。

isFair():作用是判断是不是公平锁。

isHeldByCurrentThread():作用是查询当前线程是否保持此锁定。

isLocked():作用是查询此锁定是否由任意线程保持。

lockInterruptibly():作用是如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常。

tryLock():作用是仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定。

tryLock(long timeout, TimeUnit unit):作用是如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定。

awaitUninterruptibly:

awaitUntil:



使用ReentrantReadWriteLock类：
说明:类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后面的任务。这样做虽然保证了实例变量的线程安全性，但效率却是非常低下的。所以在JDK中提供了一种读写锁ReentrantReadWriteLock类，使用它可以加快运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReentrantReadWriteLock来提升该方法的代码运行速度。

读写锁表示也有两个锁，一个是读操作相关的锁，也成为共享锁;另一个是写操作相关的锁，也叫排他锁。也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，而进行写入操作的Thread只有在获取写锁后才能进行写入操作。即多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作。

ReentrantReadWriteLock类的使用：读读共享

看个例子:

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Service {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read(){
        try{
            try{
                lock.readLock().lock();
                System.out.println("获得读锁: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                lock.readLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}


import chapter4.ReadWriteLockBegin.service.Service;

public class ThreadA extends Thread{
    private Service service;

    public ThreadA(Service service){
        this.service = service;
    }

    @Override
    public void run(){
        service.read();
    }
}


import chapter4.ReadWriteLockBegin.service.Service;

public class ThreadB extends Thread {
    private Service service;

    public ThreadB(Service service){
        this.service = service;
    }

    @Override
    public void run(){
        service.read();
    }
}


import chapter4.ReadWriteLockBegin.extthread.ThreadA;
import chapter4.ReadWriteLockBegin.extthread.ThreadB;
import chapter4.ReadWriteLockBegin.service.Service;


public class Run {
    public static void main(String[] args){
        Service service = new Service();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");
        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}



这里写图片描述

分析:从控制台中打印的时间来看，两个线程几乎同时进入lock()方法后面的代码。说明在此使用了lock.readLock()读锁可以提高程序运行效率，允许多个线程同时执行lock()方法后面的代码。

ReentrantReadWriteLock类的使用：写写互斥

看个例子:

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Service {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void write(){
        try{
            try{
                lock.writeLock().lock();
                System.out.println("获得写锁: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                lock.writeLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}


import chapter4.ReadWriteLockBegin.service.Service;

public class ThreadA extends Thread{
    private Service service;

    public ThreadA(Service service){
        this.service = service;
    }

    @Override
    public void run(){
        service.read();
    }
}


import chapter4.ReadWriteLockBegin.service.Service;

public class ThreadB extends Thread {
    private Service service;

    public ThreadB(Service service){
        this.service = service;
    }

    @Override
    public void run(){
        service.write();
    }
}


import chapter4.ReadWriteLockBegin.extthread.ThreadA;
import chapter4.ReadWriteLockBegin.extthread.ThreadB;
import chapter4.ReadWriteLockBegin.service.Service;


public class Run {
    public static void main(String[] args){
        Service service = new Service();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");
        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}



这里写图片描述

分析:使用写锁代码lock.writeLock()的效果就是同一时间只允许一个线程执行lock()方法后面的代码。

ReentrantReadWriteLock类的使用：读写互斥

看个例子:

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Service {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
     public void read(){
        try{
            try{
                lock.readLock().lock();
                System.out.println("获得读锁: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                lock.readLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    public void write(){
        try{
            try{
                lock.writeLock().lock();
                System.out.println("获得写锁: " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                lock.writeLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}


import chapter4.ReadWriteLockBegin.service.Service;

public class ThreadA extends Thread{
    private Service service;

    public ThreadA(Service service){
        this.service = service;
    }

    @Override
    public void run(){
        service.read();
    }
}


import chapter4.ReadWriteLockBegin.service.Service;

public class ThreadB extends Thread {
    private Service service;

    public ThreadB(Service service){
        this.service = service;
    }

    @Override
    public void run(){
        service.write();
    }
}


import chapter4.ReadWriteLockBegin.extthread.ThreadA;
import chapter4.ReadWriteLockBegin.extthread.ThreadB;
import chapter4.ReadWriteLockBegin.service.Service;


public class Run {
    public static void main(String[] args){
        Service service = new Service();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");
        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}



这里写图片描述

分析:此实验说明”读写”操作时互斥的，而”写读”操作也是互斥的。即只要出现”写操作”的过程，就是互斥的。


ReentrantReadWriteLock类的使用：写读互斥
结果与读写互斥一样，在此不再赘述。


本章总结：在本章中完全可以使用Lock对象将synchronized关键字替换掉，而且其具有的独特功能也是synchronized所不具有的。在学习并发时，Lock是synchronized关键字的进阶，掌握Lock有助于学习并发包中源代码的实现原理，在并发包中大量的类使用了Lock接口作为同步的处理方式。

ning421479924
关注
专栏目录
mysql.sock.lock的作用_mysql.sock的作用
weixin_39876595的博客
01-27 2538
1、在编译安装mysql的时候，会将mysql的配置文件复制到/etc/my.conf中：[root@Web-lnmp02 mysql]# cp support-files/my-small.cnf /etc/my.cnf 将配置模板复制到mysql的配置文件cp：是否覆盖"/etc/my.cnf"？ y2、可以通过查看/etc/my.conf查看mysql.sock的目录位置：[root@mys...
优先级纱线：如果项目具有yarn.lock，请将npm install更改为yarn
02-03
如果项目具有yarn.lock，请将npm install更改为yarn。 命令行界面 $ npm install --global prioritize-yarn $ alias npm='prioritize-yarn' // Using yarn, when there is a `yarn.lock`. $ npm install yarn ...
4 Lock的使用
liyidaozhang的博客
06-03 626
4 Lock的使用4.1.3 使用Condition实现等待/通知：错误用法与解决在一个Lock对象中可以创见多个Condition（即对象监视器）实例。使用ReentrantLock结合Condition类可以实现“选择性通知” Object类中的wait()方法相当于Condition类中的await()方法。 Object类中的wait(long timeout)方法相当于Condition类
Java多线程详解（四）线程同步 4、Lock（锁）
tomatoarmys的博客
02-19 153
Java多线程详解（四）线程同步 （1）并发与三个线程不安全的实例 （2）线程同步 （3）队列和锁 （4）同步方法(synchronized方法和synchronized块) （5）死锁 （6）Lock（锁） JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当 java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始
ReentrantLock
快乐的小三菊的博客
12-17 522
ReentrantLock 的语法和特性，特性包括可重入性、可打断、超时释放、公平锁、条件变量等相关知识
多线程4-Lock的使用
weixin_39389850的博客
05-18 1260
之前学习了通过synchronized关键字实现线程同步效果。除此之外，通过Lock对象来实现同步效果。 知识点 1- ReentrantLock类的使用 2- ReentrantReadWriteLock类的使用 ReentrantLock类 案例说明ReentrantLock可实现线程同步效果。 运行类： package ReentrantLock_part1; ...
ReentrantLock的公平锁和非公平锁
wj11825的博客
09-25 273
今天学习了一下关于Lock中的公平锁和非公平锁，就想总结一下这两种之间的区别。具体有不对的地方欢迎指正。     首先锁Lock分为"公平锁"和"非公平锁"，公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即呢就是先来先得的FIFO先进先顺序。非公平锁就是获取锁的抢占机制，是随机获取锁的，那这俩货的区别就在这个地方了，非公平锁先来的不一定先得到锁，这就会造成某些线程可能一直拿不到锁，结果
lock.lock()使用，与synchronized对比
技匠而已
02-18 3247
Lock锁 锁实现提供了比使用synchronized方法和语句更广泛的锁操作。它们允许更灵活的结构，可能有不同的属性，可能支持多个关联的Condition对象。 锁是用于控制多个线程对共享资源的访问的工具。 通常，锁提供对共享资源的独占访问:一次只有一个线程可以获得锁，并且所有访问共享资源的访问都需要先获得锁。但是，有些锁可能允许并发访问共享资源。例如readwritellock的读锁。 同步方法或语句的使用提供了对每个对象关联的隐式监视器锁的访问，但强制所有锁的获取和释放都以块结构的方式进行:当多个锁
yarn.lock 介绍
qq_43437571的博客
07-07 3402
概述 今天本地运行尤大的vue-hackernews-2.0，使用 yarn 命令安装，报错提示 node 版本必须大于7小于9，如下所示： error upath@1.0.4: The engine "node" is incompatible with this module. Expected version ">=4 <=9". error Found incompatible module 然后我到 package.json 文件里面去看，明明只说了 node 要大于7，没有说要小于
yarn.lock文件
ivenqin的博客
06-29 2752
为了在多台机器之间获得一致的安装结果，Yarn 可能会需要比 package.json 文件中配置的依赖项更多的信息。它需要准确存储每一个依赖项的安装版本。因此在 Yarn 项目的根目录我们需要一个 yarn.lock 文件，这个 yarn.lock 文件是自动生成的。 当我们执行 yarn 命令或者添加依赖包命令后，Yarn 都会在项目根目录下自动生成一个 yarn.lock 文件。在使用 Yarn 安装、升级、删除依赖项目时，会自动更新到 yarn.lock 文件中。一般我们不会去手动编辑这个文件，因为
分布式锁Lock4J 使用总结
zhouzhiwengang的专栏
01-04 4384
前提条件必须继承抽象类：com.baomidou.lock.executor.AbstractLockExecutorZooKeeper 版本执行器之ZookeeperLockExecutor////if (!} else {try {try {Redis 版本执行器之RedisTemplateLockExecutor////
swift-根据Podfile.lock生成依赖图的MacApp。WritteninSwift
08-15
描述简短地说明了这是一个使用Swift编写的Mac应用，其核心功能是处理Podfile.lock文件。Podfile.lock是CocoaPods（iOS和macOS的依赖管理工具）在安装库时生成的一个文件，记录了所有依赖及其精确版本，确保团队成员...
解决git:fatal:Unable to create”…/.git/index.lock” 的错误
01-08
问题描述: 在使用git 进行提交时, 出现上面这个报错, 导致无法提交. 报错大致意思就是创建index.lock文件失败,因为已经存在index.lock文件了. index.lock文件是在.git下面, 而.git是一般是隐藏的, 那么可以通过以下...
composer.lock文件的作用
12-18
在项目中使用Composer时，有两个关键的文件：`composer.json`和`composer.lock`。 `composer.json`文件是项目的核心配置文件，它定义了项目的元数据以及项目所需的依赖。在`composer.json`中，`require`关键字用于...
Java-网络
2301_81543552的博客
09-14 708
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 642
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 291
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1153
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
记录开发一个英语听力训练网站
最新发布
业余程序员Blue的博客
09-14 708
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
Threading.lock
09-12
1. **获得锁**：使用 `lock.acquire()` 方法获取锁，如果锁已被其他线程持有，则当前线程会被阻塞等待。 2. **释放锁**：一旦完成对共享资源的操作，应使用 `lock.release()` 方法释放锁，这使得其他线程有机会获得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值