JUC(Java中的多线程)

最新推荐文章于 2024-01-06 18:04:21 发布
最新推荐文章于 2024-01-06 18:04:21 发布
阅读量81 收藏
点赞数
文章标签： java 开发语言 servlet
原文链接：https://blog.csdn.net/a1669674377/artcle/details/125193615
版权

JUC介绍

JUC是jdk中java.util.concurrent包的简称。改包提供了并发编程中常用的工具类。

线程和进程

进程：运行中的程序，一个进程包含多个线程。

线程：进程中的单一串行程序片段

线程创建方式

线程创建有四种方式：继承Thread类、实现Runnable接口结合Thread类、利用Callable接口，FutureTast类结合Thread（有返回值时用这个）、线程池创建

1、继承Thread类

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author: curry
 * @Date: Created in 19:51 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class One extends Thread {

    @Override
    public void run() {
        for (int i =0;i<=1000;i++){
            log.debug("----->{}",i);
        }
    }

    public static void main(String[] args) {
        Thread t = new One();
        t.start();

    }
}

2、结合Thread类实现Runnable接口

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author: curry
 * @Date: Created in 20:04 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class Two implements Runnable {

    @Override
    public void run() {
        for (int i =0;i<=1000;i++){
            log.debug("----->{}",i);
        }
    }

    public static void main(String[] args) {
        Two two = new Two();
        Thread t = new Thread(two);
        t.start();
    }
}

进阶1 内部类方法实现

 Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i =0;i<=1000;i++){
                    log.debug("----->()",i);
                }
            }
        };
        t1.start();

进阶2 lamada表达式实现

Thread t1 = new Thread(()->{
            for(int i=1;i<=1000;i++){
                log.debug("{}----->{}", Thread.currentThread().getName(),i);

            }
        },"T1");

3、FutrueTask类结合Thread实现Callable接口

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

/**
 * @Author: curry
 * @Date: Created in 20:15 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class Three {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                TimeUnit.SECONDS.sleep(5);
                return 100;
            }
        };

        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t1 = new Thread(futureTask);
        t1.start();

        //get方法是阻塞的。一直到内部的call方法执行完毕才返回
        Integer k = futureTask.get();
        log.debug("{}",k);
        System.out.println(k);
    }
}

4、线程池创建

线程的状态

新建：刚刚new出来的线程对象

就绪：已调用start，但尚未运行，但正在积极竞争cpu

运行：正在运行

阻塞：不竞争cpu（即使cpu空闲）阻塞状态结束进入就绪状态

死亡：线程运行结束

yield、wait，join，sleep的区别

阻塞：wait、sleep、join

非阻塞：yield

Thread.yield()使当前线程进入就绪状态（也叫做让步方法，由运行状态编程就绪状态，让出cpu的使用权） (我自己的理解，当有多个线程时，线程一执行yield方法后，让出cpu的使用权，下一刻还有可能是线程一抢占到cpu的使用权)

Thread.sleep()使当前线程进入阻塞状态一段时间，调用该方法后，cpu极大可能被另一个线程抢占

join()方法（线程实例方法）使当前线程进入阻塞状态，等待被调用join方法的线程执行完毕后，再接着执行。如果在当前线程中调用另一个线程的join方法，则会等待另一个线程执行完毕（即使另一个线程就绪或阻塞），才会执行

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;


/**
 * @Author: curry
 * @Date: Created in 20:23 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class Four {

    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            for(int i=1;i<=1000;i++){
                log.debug("{}----->{}", Thread.currentThread().getName(),i);

            }
        },"T1");

        Thread t2 = new Thread(()->{
           for (int i =1;i<=1000;i++){
               log.debug("{}------>{}",Thread.currentThread().getName(),i);
               if(i==200){
                   try {
                       t1.join();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
        },"T2");

        t1.start();
        t2.start();
    }
}

wait()方法（Object实例方法）使当前线程阻塞，需要其他线程调用notify或者notifyAll方法

线程优先级

多个运行状态的线程，其中优先级较高的竞争上cpu的概率较高

优先级：1~10（越大优先级越高）优先级较高的线程被cpu调用的概率高

通过setPriority设置线程的优先级

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;


/**
 * @Author: curry
 * @Date: Created in 20:23 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class Four {

    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            for(int i=1;i<=1000;i++){
                log.debug("{}----->{}", Thread.currentThread().getName(),i);

            }
        },"T1");

        Thread t2 = new Thread(()->{
           for (int i =1;i<=1000;i++){
               log.debug("{}------>{}",Thread.currentThread().getName(),i);
//               if(i==200){
//                   try {
//                       t1.join();
//                   } catch (InterruptedException e) {
//                       e.printStackTrace();
//                   }
//               }
           }
        },"T2");
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
    }
}

线程中断interrupt(中断)

1.对于不在阻塞状态的线程，interrupt方法仅仅修改中断状态为true，不影响线程的执行

2.对于阻塞的线程，interrupt方法将终止阻塞并抛出interruptedException，同时恢复中断状态为false

对于中断线程怎么处理由开发者决定，根据isinterred来判断是否处于中断状态

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author: curry
 * @Date: Created in 20:38 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class Five {


    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           for(int i=1;i<=1000;i++) {
               log.debug("--->()", i, Thread.currentThread().getName());
               if (Thread.currentThread().isInterrupted()) {
                   //假如线程处于阻塞状态，则return
                   return;
               }
               Thread.yield();
           }
        },"T2");
        t1.start();
        Thread.sleep(10);
        t1.interrupt();  //向被调用的线程发出中断信号
        //线程可以收到中断信号，但是收到的中断信号的逻辑由开发者决定
    }
}

守护线程

垃圾回收线程是一个守护线程

守护线程是为其他线程服务的线程，随着其他线程的结束而结束

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author: curry
 * @Date: Created in 20:54 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class Six {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i=0;i<=1000;i++){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是守护线程。。。"+i);
            }
        });
        t1.setDaemon(true);
        t1.start();
        Thread.sleep(1000);
    }
}

如果不设置t1为守护线程则这个线程会一直运行，不会终止

互斥

synchronize是同步代码块的简洁写法

同步实例方法：以this对象为锁，以整个方法体为同步代码块

同步静态方法：以所属类的元对象为锁，以整个方法为同步代码块

线程安全问题

1.基本类型的局部变量和变量所引用对象的作用范围不超出局部范围的引用类型变量没有线程安全问题

2.属性（类的实例属性和静态属性）需要考虑线程安全问题

3.变量所引用对象作用范围超出局部范围的引用类型变量需要考虑线程安全问题

线程同步-协作（生产者和消费者问题）

场景:

一个面包柜只能容纳5个面包，面包师傅每天烤100个面包放入面包柜，店员每天从面包柜中取100个面包销售

操作：

师傅每放入一个面包就通知（notify）店员可以取了，如果师傅发现柜满了，则等待（wait）指导被唤醒（通知）

店员每取出一个面包就通知师傅可以放了，如果店员发现柜子空了，则等待直到被唤醒（通知）

满了就让师傅等待，空了就让店员等待

java.lang.Object提供了三个方法

wait（）只能在同步代码块中调用，而且只能通过锁对象调用，使当前线程基于所在代码锁等待

notify（）只能在同步代码块中调用，而且只能通过锁对象调用。唤醒【基于当前线程锁在代码锁等待的】线程中的一个

notifyAll() 只能在同步代码块中调用，而且只能通过锁对象调用，唤醒【基于当前线程所在代码锁等待的】所有线程

实现代码

柜子类

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author: curry
 * @Date: Created in 21:10 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class Guizi {
    private int cap;  //容量
    private int size;  //数量

    public Guizi(int cap) {
        this.cap = cap;
        this.size = 0;
    }

    public boolean isFull(){
        return size==cap;
    }

    public boolean isEmpty(){
        return size==0;
    }

    public synchronized void add(){
        while (this.isFull()){
            try {
                log.debug("柜子慢，等待中。。。");
                this.notifyAll();
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        log.debug("有空位，被唤醒。。。");
        size++;
        log.debug("放入一个面包，面包数为：{}",size);
    }

    public synchronized void remove(){
        while (this.isEmpty()){
            try {
                log.debug("柜子空，等待中。。。");

                this.notifyAll();

                this.wait();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        log.debug("有面包，被唤醒。。。");
        size--;
        log.debug("取出一个面包，面包数为：{}",size);
    }
}

启动类

package com.hzz.test;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author: curry
 * @Date: Created in 21:19 2022/11/30
 * @Modified By:
 * @description:
 */
@Slf4j
public class GuiziTest {

    public static void main(String[] args) {
        Guizi guizi = new Guizi(5);
        for(int k=0;k<7;k++){
            new Thread(()->{
               for (int i=0;i<100;i++){
                   guizi.add();
                   Thread.yield();
               }
            },"面包师"+k).start();

            new Thread(()->{
                for (int i=0;i<100;i++){
                    guizi.remove();
                    Thread.yield();
                }
            },"店员"+k).start();
        }
    }
}

synchronize锁升级

偏向锁->轻量级锁->重量级锁

偏向锁：仅有一个线程访问，当有另一个线程访问时升级为轻量级锁

轻量级锁：有多个线程不同时间访问，当多个线程同时访问时产生锁自选

锁的自选：当一个线程持有锁，另一个线程访问同步代码块是并不阻塞，而是进入循环，等待取到同步代码块的锁后执行，循环次数大于jvm设置的上限之后升级为重量级锁。（处于运行状态，还在占用cpu，减少在运行态和阻塞态之间切换的消耗）

重量级锁：当锁自旋次数大于jvm设置的上限之后，还没有获得锁的线程进入阻塞状态

JAVA内存模型（JVM）

多线程把内存分为主内存和工作内存，工作内存是线程独有的

当一个线程从非运行状态变成运行状态是会从主存中更新工作内存的数据

当一个线程拿到锁之后会从主内存拿取数据，释放锁的时候将数据向主内存回传

线程只要遇到锁，就会从主内存中更新工作内存

注：被volatile修饰的变量，主内存的值改变后，立即通知各工作内存从主内存中重新读取值

JVM三大特性

原子性：如何保证指令不会收到线程上下文切换的影响。线程上下文切换主要指运行态和阻塞态之间的转换，这个切换消耗成本较大

可见性:如何保证指令不受cpu缓存的影响（工作内存和主内存的值不一样）

有序性：如何保证指令不受cpu指令优化的影响（cpu进行优化时可能进行指令重排）

synchronize保证原子性、可见性

volatile可以保证可见性、有序性，但不保证原子性(适合一个线程写，多个线程读的情况)

CAS无锁技术

CAS即比较并设置，是一种无锁的、非阻塞的线程并发安全技术

CAS操作：设置新值时，首先将数据的当前值和预期原值进行比较，如果一致则更新为新值，否者不更新

CAS和volatile结合实现了安全的原子性并发，在java中提供的原子数据类型就是这样做的

公平锁和非公平锁

公平锁：按照请求锁的顺序依次获得锁，好处是每个线程都有获得锁的机会，效率低一些

一开始时是线程一处于第一位，线程一执行完后释放锁，再重新排队

package com.hzz.test;

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

/**
 * @Author: curry
 * @Date: Created in 22:39 2022/11/30
 * @Modified By:
 * @description:
 */
public class Task implements Runnable {

    Lock l = new ReentrantLock(true);  //ReentrantLock构造方法中的参数为true时是公平锁，为false时是非公平锁

    @Override
    public void run() {
        while (true){
            l.lock();
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                l.unlock();
            }
        }
    }
}





package com.hzz.test;




/**
 * @Author: curry
 * @Date: Created in 22:11 2022/11/30
 * @Modified By:
 * @description: 公平锁和非公平锁
 */
public class TestLock {

    public static void main(String[] args) {

        //公平锁测试
        Task task = new Task();

        Thread t1 = new Thread(task,"线程一");
        Thread t2 = new Thread(task,"线程二");
        Thread t3 = new Thread(task,"线程三");
        t1.start();
        t2.start();
        t3.start();


    }
}

非公平锁：不按照请求顺序获得锁，而是随机顺序获得锁，好处是效率高，但是有的线程没有获得锁的机会（锁饥饿）

synchronize是非公平锁

package com.hzz.test;

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

/**
 * @Author: curry
 * @Date: Created in 22:39 2022/11/30
 * @Modified By:
 * @description:
 */
public class Task implements Runnable {

    Lock l = new ReentrantLock(true);  //ReentrantLock构造方法中的参数为true时是公平锁，为false时是非公平锁

    @Override
    public void run() {
        while (true){
            l.lock();
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                l.unlock();
            }
        }
    }
}





package com.hzz.test;




/**
 * @Author: curry
 * @Date: Created in 22:11 2022/11/30
 * @Modified By:
 * @description: 公平锁和非公平锁
 */
public class TestLock {

    public static void main(String[] args) {

        //公平锁测试
        Task task = new Task();

        Thread t1 = new Thread(task,"线程一");
        Thread t2 = new Thread(task,"线程二");
        Thread t3 = new Thread(task,"线程三");
        t1.start();
        t2.start();
        t3.start();


    }
}

Lock接口

Lock接口有三个实现类，分别是可重入锁ReentranLock、读锁ReadLock、写锁writeLock

可重入锁（ReentranLock）

本线程已经有这个锁之后再获得一次这个锁

hzz19943305823
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java---JUC并发篇（多线程详细版）
mxy2404830的博客
12-12 366
Java---多线程 1. 并发基础（线程篇） 1.1 java线程状态及线程状态之间的转化 1.2 操作系统层面有5种状态 2. 线程池的核心参数（7个核心参数） 3. sleep与wait方法对比 4. lock锁与synchronized锁区别 5. volatile 能否保证线程安全 6. Java中的悲观锁与乐观锁 6.1 悲观锁与乐观锁区别 6.2.2 悲观锁与乐观锁代码实现共享变量线程安全 7. Hashtable 与 ConcurrentHashMa
JUC代码演示 Java多线程并发
最新发布
05-03
### Java多线程并发知识点详解 #### 一、用户线程与守护线程 在Java中，线程分为用户线程（User Thread）和守护线程（Daemon Thread）。这两种线程的区别主要在于程序退出的方式： - **用户线程**：默认创建的...
Java --- JUC之多线程
qq_46093575的博客
12-25 921
1、恢复挂起的线程到真正锁的获取还是有时间差的，从开发人员来看这个时间微乎其微，但从CPU的角度来看，这个时间差存在的还是很明显的。2、使用多线程很重要的考量点是线程切换的开销，当采用非公平锁时，当一个线程请求锁获取同步状态，然后释放同步状态，所以刚释放锁的线程在此刻再次获取同步状态的概率就变得非常大，所以就减少了线程的开销。非公平锁：指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转或者饥饿的状态(某个线程一直得不到锁)
java多线程之JUC
CapMiachael的博客
11-23 382
java多线程之JUC 1. 简介 在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中 的 Collection 实现等; 2. volatile 关键字 2-1问题重现 package com.main.j...
java多线程：线程池（JUC）
01-30 435
前言 并发是伴随着多核处理器的诞生而产生的，为了充分利用硬件资源，诞生了多线程技术。但是多线程又存在资源竞争的问题，引发了同步和互斥的问题，JDK1.5推出的java.util.concurrent(并发工具包）来解决这些问题。 目录 1、JUC概述 2、线程池分类 2.1、可缓存线程池CachedThreadPool 2.2、定长线程池FixedThreadPoo...
Java核心技术之- 多线程并发-JUC总结-并发编程
Aili的博客
05-24 486
1. 线程基础线程的创建与启动方式- 线程生命周期管理- 线程的状态转换- 线程同步与互斥- 程优先级设置2. 线程间通信- synchronized 关键字及其实现原理- wait() ， notify() ，notifyAll()，join()方法的使用- Lock 和 Condition 的使用- volatile 关键字的使用 - 原子类的使用- ConcurrentHashMap 和 ConcurrentLinkedQueue 的使用- CountD
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
Java多线程和JUC.pdf
01-22
### Java多线程和JUC知识点详解 #### Lambda表达式与函数式编程 Lambda表达式是Java 8引入的一个重要特性，它支持将函数作为参数传递到方法中，极大地简化了代码编写。Lambda表达式的使用使得Java语言更加简洁、易...
JUC代码收集，java高并发多线程学习
03-31
本资源"JUC代码收集，java高并发多线程学习"显然是一个专注于探讨和学习JUC库的资料包。 JUC库包含多个子包，如`concurrent`, `atomic`, `locks`等，每个子包都有其特定的功能和用途： 1. **concurrent**：这是JUC...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
Java多线程与JUC——02线程的创建与启动
JokerCaesar的博客
03-03 148
Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。 线程的创建一般有以下三种： 一、继承Thread类创建线程类 步骤1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务， 因此经常把run( )方法称为线程执行体。 步骤2.创建Thread子类的实例，即创建了线程对象。你每new出一个对象，就意味着你创...
java必备基础3(包、多线程、锁、juc并发类、ThreadLocal)
sv
09-19 512
java必备基础3(包、多线程、锁、juc并发类、ThreadLocal)
jvm和juc
m0_72673660的博客
10-13 802
jvm和juc
JUC_JVM_Somthing
ylittlema的专栏
06-05 686
SomeThing JUC多线程及高并发 JMM（Java内存模型） volatile的理解 volatile是JVM提供的轻量级的同步机制 保证内存可见性 不保证原子性 禁止指令重排 线程内存可见性 不保证原子性 对任意单个volatile变量的读写具有原子性 对类似volatile++这种复合操作布局有原子性 i++ 实际分成两步： 复合两步一起操作不具有原子性 读 读取内存中i ...
近五万字关于Java并发（JUC）与虚拟机（JVM）面试题（尚硅谷第二季Java面试题学习笔记）
xjx666666的博客
10-14 483
JUC（java.util.concurrent）JUC 下的三个包Volatile 在日常的单线程环境是应用不到的，Volatile 是 Java 虚拟机提供的轻量级的同步机制，轻量级可以理解为是低配版的syncronized。它是一个修饰符，可以用来修饰变量，被其修饰的变量会有具有volatile的特性，volatile其有三大特性：JMM（Java内存模型Java Memory Model，简称JMM）本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实
Java面试题（JUC&JVM）
Hide on bush
03-10 264
面试题之Volatile，CAS1. 请谈一下关于volatile的理解2. CAS 1. 请谈一下关于volatile的理解 volatile是JVM提供的轻量级同步机制 保证可见性 不保证原子性 禁止指令重排 java内存模型（JMM）：是一种抽象的概念，并不真实存在，描述的是一组规则或规范。定义了程序中对每个变量的访问方式 java内存模型中规定所有变量都存储在主内存，主内存是共享的内存区域，所有线程都可以访问，但是线程对变量的操作（读取赋值等）必须在工作内存中进行。首先将变量从主内存中拷
Java：多线程和JUC详解
游手好闲
01-06 1386
Java多线程和JUC详解
JUC(java中的多线程)
a16696747377的博客
06-08 4478
juc（Java里的多线程）
JUC系列（一）什么是JUC？
北
08-19 2456
多线程一直Java开发中的难点，也是面试中的常客，趁着还有时间，打算巩固一下JUC方面知识，我想机会随处可见，但始终都是留给有准备的人的，希望我们都能加油！！！ 沉下去，再浮上来，我想我们会变的不一样的。 先看张图,舒缓下心情，再继续吧 一、JUC简介 JUC实际上就是我们对于jdk中java.util .concurrent 工具包的简称。这个包下都是Java处理线程相关的类，自jdk1.5后出现。 二、进程与线程 2.1、进程 概述： 进程（Process） 是计算机中的程序关于某数据集合上的一.
Java并发编程详解：JUC工具包与多线程实战
在Java中，JUC库提供了一系列工具，如ThreadPoolExecutor、Semaphore、CyclicBarrier和CountDownLatch等，帮助开发者有效地管理和协调并发任务，确保程序的正确性和性能。 并发编程的学习不仅仅是理论知识，还需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值