JUC（多线程）

已于 2024-06-11 14:22:29 修改
阅读量862 收藏 23
点赞数 17
分类专栏： 面对面 高并发 文章标签： java
于 2024-04-09 19:00:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54122311/article/details/137562642
版权
本文详细探讨了Java并发编程中的JUC组件，包括线程与进程的区别、Lock接口与synchronized的区别、生产者消费者问题的解决、并发八大锁现象、线程池的重点、常用辅助类如CountDownLatch、CyclicBarrier和Semaphore，以及对Volatile特性的深入理解。通过源码分析和实战案例，帮助读者全面掌握Java并发编程的核心概念和技术。
摘要由CSDN通过智能技术生成

JUC

1.什么是JUC

源码+官方文档
在这里插入图片描述

java.util 工具包、包、分类

业务 ：普通的线程代码 Thread

Runnable 没有返回值、效率相比Callable相对较低！
在这里插入图片描述

在这里插入图片描述

2、线程和进程

线程、进程，如果不能使用一句话说出来底层技术，不扎实

进程：一个程序，QQ.exe Music.exe 程序的集合；

一个进程往往可以包含多个线程，至少包含一个！

java默认有几个线程？ 2个 main线程 GC线程

线程：开了一个进程 Typora，写字，自动保存（线程负责的）

对于java而言：Thread、Runnable、Callable

Java真的可以开启线程吗？ 不可以：本地方法，底层的C++ , Java无法直接操作硬件

    public synchronized void start() {
   
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
   
            start0();
            started = true;
        } finally {
   
            try {
   
                if (!started) {
   
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
   
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

	//本地方法，底层的C++ , Java无法直接操作硬件
    private native void start0();

并发、并行

并发编程：并发、并行

并发（多线程操作同一个资源）

  • CPU 一核，模拟出来多条线程，天下武功，唯快不破，快速交替

并行（多个人一起行走）

  • CPU 多核，多个线程可以同时执行；线程池
public class Test1 {
   
    public static void main(String[] args) {
   
        //获取cpu的核算
        // cpu 密集型，io密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU的资源

所有的公司都很看重！

企业 ，挣钱=》提高效率，裁员，找一个厉害的人顶替三个不怎么样的人；

人员（减），技术成本（提高）

线程有几个状态 6

    public enum State {
        //新生
        NEW,
        
        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,

        //等待，死死的等
        WAITING,

        //超时等待
        TIMED_WAITING,

        //终止
        TERMINATED;
    }

wait/sleep 区别

1、来自不同的类

wait => Object

sleep => Thread

2、关于锁的释放

wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放！

3、使用的范围不同的

wait 必须在同步代码块中使用

sleep 可以在任何地方睡

4、是否需要捕获异常

wait 不要捕获异常

sleep 必须要捕获异常

3、Lock锁（重点）

传统 synchronized

package com.hw.cn.demo01;

/**
 * 基本的卖票例子
 *
 * 真正的多线程开发，公司中的开发、降低耦合性
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1、属性、方法
 * @author hw
 * @ClassName SaleTicketDemo01
 **/
public class SaleTicketDemo01 {
   
    public static void main(String[] args) {
   
        //并发:多线程操作同一个资源类
        Ticket ticket = new Ticket();

        //@FunctionalInterface  函数式接口  jdk1.8 lamdba表达式  (参数)->{代码}
        new  Thread(()->{
   
            for (int i = 0; i < 60; i++) {
   
                ticket.sale();
            }
        },"A").start();

        new  Thread(()->{
   
            for (int i = 0; i < 60; i++) {
   
                ticket.sale();
            }
        },"B").start();

        new  Thread(()->{
   
            for (int i = 0; i < 60; i++) {
   
                ticket.sale();
            }
        },"C").start();
    }
}

//资源类 OOP
class Ticket{
   
    //属性、方法
    private int number = 50;

    //卖票的方式
    //synchronized 本质：队列，锁
    public synchronized void sale(){
   
        if (number>0){
   
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余："+number);
        }
    }
}

Lock 接口

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

公平锁：十分公平：可以先来后到

非公平锁：十分不公平：可以插队（默认）

public class SaleTicketDemo02 {
   
    public static void main(String[] args) {
   
        //并发:多线程操作同一个资源类
        Ticket ticket = new Ticket();

        //@FunctionalInterface  函数式接口  jdk1.8 lamdba表达式  (参数)->{代码}
        new  Thread(()->{
    for (int i = 0; i < 60; i++) ticket.sale(); },"A").start();
        new  Thread(()->{
    for (int i = 0; i < 60; i++) ticket.sale(); },"B").start();

        new  Thread(()->{
   
            for (int i = 0; i < 60; i++) {
   
                ticket.sale();
            }
        },"C").start();
    }
}

//资源类 OOP
class Ticket2{
   
    //属性、方法
    private int number = 50;

    Lock lock = new ReentrantLock();

    //卖票的方式
    //lock三部曲
    //1、new ReentrantLock();
    //2、lock.lock();//加锁
    //3、finally => lock.unlock();//解锁
    public void sale(){
   
        lock.lock();//加锁
        try {
   
            //业务代码
            if (number>0){
   
                System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余："+number);
            }
        }catch (Exception e){
   
            e.printStackTrace();
        }finally {
   
            lock.unlock();//解锁
        }
    }
}

synchronized 和 Lock 区别

1、Synchronized 内置的Java关键字，Lock是一个Java类

2、Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁

3、Synchronized 会自动释放锁，lock必须要手动释放锁!如果不释放锁，死锁

4、Synchronized 线程1（获得锁，阻塞），线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；

5、Synchronized 可重入锁，不可以中断的，非公平 ; Lock ，可重入锁，可以判断锁，非公平(可以自己设置);

6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！

锁是什么，如何判断锁是谁！

4、生产者和消费者问题

面试的：单例模式、排序算法、生产者和消费者、死锁

生产者和消费者问题 Synchronized 版

package com.hw.cn.pc;

/**
 * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，等待通知
 * 线程交替执行  A  B 操作同一个变量  num = 0
 * A num+1
 * B num-1
 **/
public class A {
   
    public static void main(String[] args) {
   
        Data data = new Data();
        new Thread(()->{
   
            for (int i = 0; i <10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

//  判断等待，业务，通知
class Data{
   //数字  资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
   
        if (number!=0){
   
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完毕
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
   
        if (number==0){
   
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕
        this.notifyAll();
    }
}

问题存在，A B C D 4个线程！ 虚假唤醒

在这里插入图片描述

if 改成 while 判断

package com.hw.cn.pc;

/**
 * 线程之间的通信问题：生产者和消费者问题！  等待唤醒，等待通知
 * 线程交替执行  A  B 操作同一个变量  num = 0
 * A num+1
 * B num-1
 **/
public class A {
   
    public static void main(String[] args) {
   
        Data data = new Data();
        new Thread(()->{
   
            for (int i = 0; i <10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

//  判断等待，业务，通知
class Data{
   //数字  资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
   
        while (number!=0){
   
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完毕
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
   
        while (number==0){
   
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕
        this.notifyAll();
    }
}

JUC版的生产者和消费者问题
在这里插入图片描述

通过Lock 找到 Condition
在这里插入图片描述

代码实现:

package com.hw.cn.pc;

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

/**
 * 线程之间的通信问题：生产者和消费者问题！  等待唤醒，等待通知
 * 线程交替执行  A  B 操作同一个变量  num = 0
 * A num+1
 * B num-1
 **/
public class B {
   
    public static void main(String[] args) {
   
        Data2 data = new Data2();
        new Thread(()->{
   
            for (int i = 0; i <10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
    }

    //  判断等待，业务，通知
    class Data2 {
   //数字  资源类

        private int number = 0;

        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
//            condition.await();//等待
//            condition.signal();//唤醒全部

        //+1
        public void increment() throws InterruptedException {
   
            lock.lock();
            try {
   
                //业务代码
                while (number != 0) {
   
                    //等待
                    condition.await();
                }
                number++;
                System.out.println(Thread.currentThread().getName() + "=>" + number);
                //通知其他线程，我-1完毕
                condition.signalAll();
            } catch (Exception e) {
   
                e.printStackTrace();
            } finally {
   
                lock.unlock();
            }
        }

        //-1
        public void decrement() throws InterruptedException {
   
            lock.lock();
            try {
   
                //业务代码
                while (number == 0) {
   
                    //等待
                    condition.await();
                }
                number--;
                System.out.println(Thread.currentThread().getName() + "=>" + number);
                //通知其他线程，我-1完毕
                condition.signalAll();
            } catch (Exception e) {
   
                e.printStackTrace();
            } finally {
   
                lock.unlock();
            }
        }
    }

任何一个新的技术，绝对不是仅仅只是覆盖了原来的技术，优势和补充！

Condition 精准的通知和唤醒线程
在这里插入图片描述

代码测试：

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

/**
 * A 执行完调用B，B执行完调用C，C执行完调用A
 **/
public class C {
   
    public static void main(String[] args) {
   
        Data3 data = new Data3();
        new Thread(() -> {
   
            for (int i = 0; i < 10; i++) {
   
                data.printA();
            }
        }, "A").start();

        new Thread(() -> {
   
            for (int i = 0; i < 10; i++) {
   
                data.printB();
            }
        }, "B").start();

        new Thread(() -> {
   
            for (int i = 0; i < 10; i++) {
   
                data.printC();
            }
        }, "C").start();
    }
}

//  判断等待，业务，通知
class Data3 {
   //资源类

    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number = 1;// 1A 2B 3C

    public void printA(){
   
        lock.lock();
        try {
   
            //业务,判断 -> 执行 ->通知
            while (number!=1){
   
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAAAAAAAAAA");
            //唤醒，唤醒指定的人 B
            number = 2;
            condition2.signal();

        } catch (Exception e) {
   
            e.printStackTrace();
        }finally {
   
            lock.unlock();
        }


    }
    public void printB(){
   
        lock.lock();
        try {
   
            //业务,判断 -> 执行 ->通知
            while (number<
最低0.47元/天 解锁文章
巨人与阿伟
关注
  • 17
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC多线程面试题
三分强势七分暖的博客
11-16 642
JUC多线程面试题 一、进程与线程的区别 进程：是系统进行资源分配和调度的基本单位，是操作系统结构的基础，在系统中正在运行的一个应用程序就是一个线程。 线程：一个线程中有多个进程，线程是进程内独立执行的一个单元执行流。 二、并发与并行的区别 并发：同一时刻多个线程在访问同一个资源， 例如：春运抢票 电商秒杀。 并行：同一个时刻多个线程访问不同的资源，例如：多项工作多人同时执行，之后再汇总。 三、wait 和 sleep 的区别 不同点： sleep 是 Thread 的静态方法，wait 是 Ob
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
JUC多线程
qq_42722241的博客
08-04 171
JUC多线程(jdk中包含可直接操作) 学习目标： 1.多线程的创建 2.线程安全的处理 3.了解线程状态 4.线程停止两种方法 5.了解线程的原子性、可见性和有序性 6.理解内存可见性的原理 7.synchronized解决内存可见性 多线程目的： 1.可充分利用cpu空闲时间片； 2.同一进程的所有线程是共享同一内存，不需要特殊的数据传送机制，不需要建立共享存储区域共享文件 名词概念： 进程： 指一个内存中运行的应用程序，拥有一个独立的内存空间，一个应用程序可以同时运行多个进程； ...
多线程~juc
张华的博客
01-09 1265
1.juc相关概念 1.1进程/线程 1)进程:是一个程序运行的最小单位(巧记：先"进"来，然后才能看到线程) 2)线程:是进程里最小的运行单位(例如idea进程,里面有多个微服务在运行,就是线程) 3)线程的6种状态: NEW(新生态),RUNNABLE(运行态),BLOCKED(阻塞态),WAITING(无限等待),TIMED_WAITING(有限等待),TERMINATED(死亡态) 1.2并发/并行 并发: 在相对的一段时间内,其实是很短,对计算机有感,对人无感,多个线程抢占资源来执行自
JUC多线程：创建线程的四种方式
热门推荐
张维鹏的博客
01-18 1万+
Java多线程的实现方式主要有四种： （1）继承Thread类，重写run()； （2）实现Runnable接口，重写run()； （3）实现Callable接口，实现call() 方法，通过FutureTask包装器来创建Thread线程； （4）使用ExecutorService、Callable、Future实现有返回结果的多线程。
JUC多线程：线程池的创建及工作原理 和 Executor 框架
张维鹏的博客
11-01 1万+
一、什么是线程池： 线程池主要是为了解决 新任务执行时，应用程序为任务创建一个新线程 以及 任务执行完毕时，销毁线程所带来的开销。通过线程池，可以在项目初始化时就创建一个线程集合，然后在需要执行新任务时重用这些线程而不是每次都新建一个线程，一旦任务已经完成了，线程回到线程池中并等待下一次分配任务。 二、创建线程池： 1、通过Executors创建线程池： 在JUC包中的Executors中，提供了一些静态方法，用于快速创建线程池，常见的线程池有： （1）newSingleThreadExecutor：创建一
JUC多线程常见面试题汇总
sxn0121的博客
07-23 1001
如果工作队列满了，则判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。在上锁的过程中，如果有其他线程也来抢锁，则进入EntryList 进行阻塞，当获得锁的线程执行完了，释放了锁，就会唤醒EntryList 中等待的线程竞争锁，竞争的时候是非公平的。偏向锁：一段很长的时间内都只被一个线程使用锁，可以使用了偏向锁，在第一次获得锁时，会有一个CAS操作，之后该线程再获取锁，只需要判断mark word中是否是自己的线程id就可以，一旦锁发生了竞争，都会升级为重量级锁。
JUC多线程：线程的中断停止
张维鹏的博客
01-24 3672
对于线程的停止，通常情况下我们是不会去手动去停止的，而是等待线程自然运行至结束，但在实际开发中，很多情况中需要我们提前去手动来停止线程，比如程序中出现异常错误、使用者关闭程序等情况中。如果不能很好地停止线程那么可能会导致各种问题，所以正确的停止线程是非常的重要的，常见的中断线程的方式有以下几种： ① 方式一：使用 Thread 类的 stop() 方法来终止线程； ② 方式二：根据 volatile 修饰的标志位判断线程是否需要中断； ③ 方式三：通过 interrupt中断机制终止线程；
JAVA面试题——JUC多线程及并发常见问题目录
Huntermax LC的博客
01-28 2127
1、谈谈你对volitile的理解 2、CAS你知道吗？ 3、原子类AtomicInteger的ABA问题谈谈？原子更新引用知道吗？ 4、ArrayList的线程不安全问题。 5、各种锁。 6、CountDownLatch/CyclicBarrier/Semaphore使用过吗? 7、阻塞队列知道吗? 8、线程池用过吗?ThreadPoolExecutor谈谈你的理解? 9、线程池用过吗?生产上你...
JUC多线程：CountDownLatch、CyclicBarrier、Semaphore同步器原理总结
张维鹏的博客
10-11 1万+
1、CountDownLatch，闭锁，主要作用是使一个或一组线程在其他线程执行完毕之前，一直处于等待状态，直到其他线程执行完成后再继续执行。 2、CyclicBarrier，循环栅栏，通过 CyclicBarrier 可以实现一组线程之间的相互等待，当所有线程都到达屏障点之后再执行后续的操作。 3、Semaphore 信号量，主要用于控制并发访问共享资源的线程数量，依赖 AQS 的变量 state 作为许可证 permit，通过控制许可证的数量，来保证线程之间的配合。
JUC多线程并发
AhangA的博客
09-20 139
一、简介 JUC（java.util.concurrent），Java并发编程工具类。 二、LockSupport 线程阻塞工具类 简单介绍 LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。 LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。 LockSupport类使用了一种名为Permit(许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可(permit), permit只有两个值1和0，默认是0。许可的累加上限是1。 几种唤醒
JUC多线程及高并发1
08-03
本文将深入探讨JUC中的多线程及高并发相关知识点。 一、volatile的理解 volatile是Java虚拟机提供的一种轻量级同步机制，它确保了在多线程环境下，对共享变量的修改能够被其他线程即时看到。volatile主要提供两方面...
juc多线程交替打印ABC、熟悉lock的唤醒机制
07-10
现场交替访问、等待和唤醒
thread.zip--狂神多线程+juc
03-18
《狂神多线程+juc》是一份针对Java并发编程深度学习的资源包，主要涵盖了Java多线程基础以及Java并发工具集（JUC）的高级应用。在Java编程中，多线程是提高程序效率、实现并发执行的重要手段，而JUC（Java ...
JAVA进阶补充
2301_80150315的博客
08-15 875
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 569
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1042
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 347
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
"深入理解JUC多线程编程：线程池、并发集合和原子操作
在学习JUC多线程编程的过程中，我们会接触到一些基本概念和技术。比如，锁是一种重要的同步机制，可以保证多线程访问共享资源的安全性；并发是一种多对一的关系，多个线程同时竞争一个资源；并行是一种多对多的关系...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值