JUC底层的详细学习(狂神JUC笔记)(全网最全)---8锁问题 集合类问题 Callable

最新推荐文章于 2024-04-24 22:52:03 发布
最新推荐文章于 2024-04-24 22:52:03 发布
阅读量155 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43886282/article/details/122761406
版权

8锁现象

如何判断锁的是谁！锁到底锁的是谁？
锁会锁住：对象、Class
深刻理解我们的锁

问题1：多个线程使用同一把锁-顺序执行

package com.whf.juc.lock8;

/**
 * @ClassName Test1
 * @Description Test1
 * @Author 德鲁大叔
 * @Date 2021/1/14 16:17
 * @Version 1.0
 */

import java.util.concurrent.TimeUnit;

/**
 * 8锁就是关于锁的8个问题
 * 1.标准情况下，两个线程先打印 发短信还是打电话
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        }, "A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);//休息1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        }, "B").start();
    }
}

class Phone {
    //synchronized的对象是方法的调用者
    //两个对象用的同一个锁，谁先拿到谁执行
    public synchronized void sendSms() {
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

打电话
发短信

Process finished with exit code 0

问题2：多个线程使用同一把锁，其中某个线程里面还有阻塞-顺序先执行

package com.whf.juc.lock8;

/**
 * @ClassName Test1
 * @Description Test1
 * @Author 德鲁大叔
 * @Date 2021/1/14 16:17
 * @Version 1.0
 */

import java.util.concurrent.TimeUnit;

/**
 * 8锁就是关于锁的8个问题
 * 1.标准情况下，两个线程先打印 发短信还是打电话
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        }, "A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);//休息1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        }, "B").start();
    }
}

class Phone {
    //synchronized的对象是方法的调用者
    //两个对象用的同一个锁，谁先拿到谁执行
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);//休息4s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

打电话
发短信

Process finished with exit code 0

问题三：多个线程有锁与没锁-随机执行

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadHaveLockAndNot03 {
    public static void main(String[] args){

        Mobile3 mobile = new Mobile3();
        // 两个线程使用的是同一个对象。两个线程是一把锁！先调用的先执行！
        new Thread(()->mobile.sendEmail(),"A").start();

        // 干扰
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->mobile.sendMS(),"B").start();

        new Thread(()->mobile.getWeixinMs(),"C").start();
    }
}

// 手机，发短信，发邮件
class Mobile3 {
    // 被 synchronized 修饰的方法、锁的对象是方法的调用者、
    public synchronized void sendEmail() {

        //多个线程使用一把锁，这里设置一个干扰
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    public synchronized void sendMS() {
        System.out.println("sendMS");
    }

    //接收微信，没有锁
    public void getWeixinMs() {
        System.out.println("getWeixinMs");
    }
}

问题四：多个线程使用多把锁-随机执行

1、被 synchronized 修饰的方法，锁的对象是方法的调用者；
2、调用者不同，它们之间用的不是同一个锁，相互之间没有关系。

package com.whf.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName Test2
 * @Description Test2
 * @Author 德鲁大叔
 * @Date 2021/1/14 16:43
 * @Version 1.0
 */

/**
 * 3.增加一个普通方法 先发短信还是先hello
 * 4.两个对象两个同步方法 先发短信还是先打电话
 */
public class Test2 {
    public static void main(String[] args) {
        //两个对象 两个调用者 两把锁
        Phone2 phone = new Phone2();
        Phone2 phone2 = new Phone2();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        }, "A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);//休息1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        }, "B").start();
    }
}

class Phone2 {
    //synchronized的对象是方法的调用者
    //两个对象用的同一个锁，谁先拿到谁执行
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);//休息4s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }

    //没有锁 没有锁的影响
    public void hello() {
        System.out.println("hello");
    }
}

问题五：Class锁：多个线程使用一个对象-顺序执行

被 synchronized 和 static 同时修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。
锁Class和锁对象的区别：
1、Class 锁 ，类模版，只有一个；
2、对象锁 ， 通过类模板可以new 多个对象。
如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。

package com.whf.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName Test3
 * @Description Test3
 * @Author 德鲁大叔
 * @Date 2021/1/15 15:45
 * @Version 1.0
 */

/**
 * 5.增加两个静态同步方法只有一个对象 先发短信还是先打电话
 * 6.两个对象 增加两个静态同步方法只有一个对象 先发短信还是先打电话
 */
public class Test3 {
    public static void main(String[] args) {

        //两个对象的class类模板只有一个 static锁的是class
        Phone3 phone = new Phone3();
//        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        }, "A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);//休息1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        }, "B").start();
    }
}

//Phone3是唯一的class对象
class Phone3 {
    //synchronized的对象是方法的调用者
    //两个对象用的同一个锁，谁先拿到谁执行
    //static静态方法 类一加载就有了 class模板 锁的是class
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);//休息4s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call() {
        System.out.println("打电话");
    }
}

问题六：Class锁：多个线程使用多个对象-顺序执行

package com.whf.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName Test3
 * @Description Test3
 * @Author 德鲁大叔
 * @Date 2021/1/15 15:45
 * @Version 1.0
 */

/**
 * 5.增加两个静态同步方法只有一个对象 先发短信还是先打电话
 * 6.两个对象 增加两个静态同步方法只有一个对象 先发短信还是先打电话
 */
public class Test3 {
    public static void main(String[] args) {

        //两个对象的class类模板只有一个 static锁的是class
        Phone3 phone = new Phone3();
        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        }, "A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);//休息1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        }, "B").start();
    }
}

//Phone3是唯一的class对象
class Phone3 {
    //synchronized的对象是方法的调用者
    //两个对象用的同一个锁，谁先拿到谁执行
    //static静态方法 类一加载就有了 class模板 锁的是class
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);//休息4s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call() {
        System.out.println("打电话");
    }
}

问题七：Class锁与对象锁：多个线程使用一个对象-随机执行

被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。

package com.whf.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName Test4
 * @Description Test4
 * @Author 德鲁大叔
 * @Date 2021/1/15 15:53
 * @Version 1.0
 */

/**
 * 7.一个普通方法一个静态方法 先发短信还是先打电话
 * 8.两个对象 一个普通方法一个静态方法 先发短信还是先打电话
 */
public class Test4 {
    public static void main(String[] args) {

        //两个对象的class类模板只有一个 static锁的是class
        Phone4 phone = new Phone4();
        Phone4 phone2 = new Phone4();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        }, "A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);//休息1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        }, "B").start();
    }
}

//Phone3是唯一的class对象
class Phone4 {
    //synchronized的对象是方法的调用者
    //两个对象用的同一个锁，谁先拿到谁执行
    //static静态方法 类一加载就有了 class模板 锁的是class类模板
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);//休息4s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通同步方法
    //锁的是调用者
    public synchronized void call() {
        System.out.println("打电话");
    }
}

问题八：Class锁与对象锁：多个线程使用多个对象-随机执行

被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。

package com.whf.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName Test4
 * @Description Test4
 * @Author 德鲁大叔
 * @Date 2021/1/15 15:53
 * @Version 1.0
 */

/**
 * 7.一个普通方法一个静态方法 先发短信还是先打电话
 * 8.两个对象 一个普通方法一个静态方法 先发短信还是先打电话
 */
public class Test4 {
    public static void main(String[] args) {

        //两个对象的class类模板只有一个 static锁的是class
        Phone4 phone = new Phone4();
        Phone4 phone2 = new Phone4();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        }, "A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);//休息1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        }, "B").start();
    }
}

//Phone3是唯一的class对象
class Phone4 {
    //synchronized的对象是方法的调用者
    //两个对象用的同一个锁，谁先拿到谁执行
    //static静态方法 类一加载就有了 class模板 锁的是class类模板
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);//休息4s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通同步方法
    //锁的是调用者
    public synchronized void call() {
        System.out.println("打电话");
    }
}

new this 本身的这个对象，调用者
static class 类模板，保证唯一！

集合类问题

List不安全

package com.whf.juc.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @ClassName ListTest
 * @Description ListTest
 * @Author 德鲁大叔
 * @Date 2021/1/15 16:19
 * @Version 1.0
 */
//ConcurrentModificationException
public class ListTest {

    public static void main(String[] args) {
        /**
         * ArrayList多线程不安全
         * 1.List<String> lists = new Vector<>();
         * 2.List<String> lists = Collections.synchronizedList(new ArrayList<>());
         * List<String> lists = new CopyOnWriteArrayList<>();***
         */
        List<String> lists = new ArrayList<>();

        //CopyOnWrite写入时复制 COW 计算机的一种优化策略
        //多个线程调用时 list 读取固定 写入的时候 复制出来 再覆盖
        //在写入的时候避免覆盖 造成数据问题

        //读写分离
        //CopyOnWriteArrayList 比 Vector牛逼在哪里
        //CopyOnWriteArrayList读操作不需要同步 不需要synchronized
        //Vector读写都需要synchronized
        //List<String> lists = new CopyOnWriteArrayList<>();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                lists.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(lists);
            }, String.valueOf(i)).start();

        }
    }
}

使用一下三种解决方案

        /**
         * ArrayList多线程不安全
         * 1.List<String> lists = new Vector<>();
         * 2.List<String> lists = Collections.synchronizedList(new ArrayList<>());
         * List<String> lists = new CopyOnWriteArrayList<>();***
         */
        //CopyOnWrite写入时复制 COW 计算机的一种优化策略
        //多个线程调用时 list 读取固定 写入的时候 复制出来 再覆盖
        //在写入的时候避免覆盖 造成数据问题

        //读写分离
        //CopyOnWriteArrayList 比 Vector牛逼在哪里
        //CopyOnWriteArrayList读操作不需要同步 不需要synchronized
        //Vector读写都需要synchronized

Set不安全

在这里插入图片描述

       /**
         * 解决方法
         * 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2.Set<String> set = new CopyOnWriteArraySet<>();
         */

package com.whf.juc.unsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @ClassName SetTest
 * @Description SetTest
 * @Author 德鲁大叔
 * @Date 2021/1/15 17:18
 * @Version 1.0
 */
//ConcurrentModificationException
public class SetTest {

    public static void main(String[] args) {
        //Set<String> set = new HashSet<>();
        /**
         * 解决方法
         * 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2.Set<String> set = new CopyOnWriteArraySet<>();
         */
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            }, String.valueOf(i)).start();

        }
    }
}

hashSet 底层是什么？

public HashSet() {
map = new HashMap<>();
}
// add set 本质就是 map key是无法重复的！
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
private static final Object PRESENT = new Object(); // 不变得值！

Map 不安全

在这里插入图片描述

package com.whf.juc.unsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @ClassName SetTest
 * @Description SetTest
 * @Author 德鲁大叔
 * @Date 2021/1/15 17:18
 * @Version 1.0
 */
//ConcurrentModificationException
public class SetTest {

    public static void main(String[] args) {
        //Set<String> set = new HashSet<>();
        /**
         * 解决方法
         * 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2.Set<String> set = new CopyOnWriteArraySet<>();
         */
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            }, String.valueOf(i)).start();

        }
    }
}

Callable(简单)

Charliefive
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC并发编程，狂神说-详细笔记，含md文件
04-07
主要记录了狂神说Java里JUC那一门课的笔记，主要针对学了狂神的JUC课程的人用来复习的，我记录得还是比较详细，也自己画了不少的图，还根据弹幕大神做了一些修改，对于复习来说应该不成问题，总共有一万多字。
java的基础知识总结＞集合相关
liangdeniu的专栏
03-21 156
java的集合相关知识>基本的框架 从框架图上来看分两种类型，一种是collect集合，一种是map集合，Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，最常用的是常用的有ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap ，map是存储键/值对映射 集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容 接口：是代...
JUC（狂神版）全面总结
qq_45464015的博客
07-19 3013
目录 1、什么是JUC 1、什么是juc（学习方法：官方文档+源码） java.util：java的工具包，包，分类 什么是juc：java.util.concurrent，java工具类下的一个并发功能的包。 Runnable 没有返回值、效率相比入 Callable相对较低! ·两者都属于juc里面 ·但callable可以返回结果，也可以抛出异常 所以比起runable来说，callable有以下特点： 1、有返回值 2、可以抛出异常 3、方法不同，run（），call（） 案例：https:/
【狂神说java juc 20200219 02篇】8锁现象，TimeUnit，线程安全的使用集合 ConcurrentHashMap，Callable,CyclicBarrierr
qq120631157的博客
08-26 336
8锁现象，TimeUnit，线程安全的使用集合 ConcurrentHashMap，CopyOnWriteArrayList，Callable,CyclicBarrierr，CountDownLatch，Semaphore
JUC并发编程学习笔记二（狂神）
兴趣是最好的老师
12-08 313
1、生产者和消费者问题Synchronized版 package com.kuang.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
2020-11-22
qq_29461579的博客
11-22 111
Synchronized 锁得问题1 package com.thread; import java.util.concurrent.TimeUnit; /** * 打印的信息 一定是 先发短信后打电话 */ public class Test1 { public static void main(String[] args) { //创建对象 Phone phone = new Phone(); //下面两个线程的调用者都是 对
个人学习-JUC-笔记
02-25
尚硅谷周阳老师的juc课程
JUC高并发编程详细讲解 狂神笔记pdf 从入门到入坟 请与狂神视频配套使用
12-17
JUC高并发编程详细讲解 狂神笔记pdf 从入门到入坟 请与狂神视频配套使用 请去b站搜遇见狂神说同步课程跟进学习 食用效果最佳。
juc-study编程笔记.md
07-06
学习狂神说的juc编程的笔记
【狂神说】笔记（史上最全）含各类md笔记.zip
01-22
跟视频的一模一样。md格式 包含： javascript JavaWeb java基础 mybatis MySQL Reids spring spring boot springMVC Vue
狂神JUC——8锁现象彻底理解锁
黄坤的博客
06-02 809
1-2锁 package com.company.lock_8; /** * 8锁问题，就是关于锁的8个问题！，判断锁的是谁 */ import java.util.concurrent.TimeUnit; /** * 1.标志情况下，两个线程先打印，发短信？ 打电话？ * 2.sendSms延迟4秒，两个线程先打印，发短信？ 打电话？ */ public class Lock_1To2 { public static void main(String[] args) throw.
再探JUC-8锁现象
qq_21793443的博客
03-21 411
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 471
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1556
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 724
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
PageHelper实现分页查询
m0_63849044的博客
04-24 956
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
Lambda表达式特点
最新发布
weixin_57763462的博客
04-24 643
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 795
consul官网地址。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 254
待更新。
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值