javaEE - 1（9000字详解多线程）

已于 2023-12-13 17:27:24 修改
阅读量1.2k 收藏 9
点赞数 6
分类专栏： javaEE 文章标签： java-ee java
于 2023-10-18 21:20:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73232539/article/details/133909661
版权

一：认识线程

1.1 线程的概念

线程是操作系统中执行的最小单位，它是进程中的一个实体。一个进程可以包含多个线程，并且这些线程共享进程的资源，如内存、文件句柄等，但每个线程有自己的独立执行流程和栈空间。

一个线程就是一个 “执行流”. 每个线程之间都可以按照顺序执行自己的代码. 它可以独立执行特定任务，也可以与其他线程通过同步机制进行协作。

通常，一个进程中的多个线程可以并发执行，共享相同的上下文和资源，从而提高系统的并发处理和资源利用率。

1.2 并行和并发

并发和并行是计算机领域中两个常用的概念。

并发指的是在同一时刻只能执行一个任务，但是通过快速切换和时间片轮转等技术，可以让多个任务交替执行，给人一种同时进行的感觉。在并发的情况下，多个任务之间可能是交替执行的。

并行则指的是多个任务在同一时刻同时执行，每个任务拥有自己的执行资源，比如独立的 CPU 核心。在并行的情况下，多个任务可以同时进行，每个任务都在独立的执行路径上进行处理。

简单来说，如果多个任务交替执行，就是并发；如果多个任务同时执行，就是并行。

但是因为并行和并发难以感知，所以我们把并行和并发这两个概念统称为并发

1.3 为啥要有线程

首先, “并发编程” 成为 “刚需”.

  • 单核 CPU 的发展遇到了瓶颈. 要想提高算力, 就需要多核 CPU. 而并发编程能更充分利用多核 CPU资源.
  • 有些任务场景需要 “等待 IO”, 为了让等待 IO 的时间能够去做一些其他的工作, 也需要用到并发编程.

其次, 虽然多进程也能实现 并发编程, 但是线程比进程更轻量.

  • 创建线程比创建进程更快.
  • 销毁线程比销毁进程更快.
  • 调度线程比调度进程更快.

最后, 线程虽然比进程轻量, 但是人们还不满足, 于是又有了 “线程池”(ThreadPool) 和 “协程”(Coroutine)，关于线程池我们后面再介绍.

1.4进程和线程的区别

  • 进程是包含线程的. 每个进程至少有一个线程存在，即主线程。
  • 进程和进程之间不共享内存空间. 同一个进程的线程之间共享同一个内存空间.
  • 进程是系统分配资源的最小单位，线程是系统调度的最小单位。

在这里插入图片描述
线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库).

Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装.

二：线程操作

2.1创建线程

2.1.1 方法1 继承 Thread 类

  1. 继承 Thread 来创建一个线程类，并重写 run 方法
class MyThread extends Thread {
  @Override
  public void run() {
    System.out.println("这里是线程运行的代码");
 }
}
  1. 创建 MyThread 类的实例
MyThread t = new MyThread();
  1. 调用 start 方法启动线程
t.start(); // 线程开始运行

2.2.2 方法2 实现 Runnable 接口

  1. 实现 Runnable 接口
class MyRunnable implements Runnable {
  @Override
  public void run() {
    System.out.println("这里是线程运行的代码");
 }
}
  1. 创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数.
Thread t = new Thread(new MyRunnable());
  1. 调用 start 方法
t.start(); // 线程开始运行

2.2.3两种方法的区别

这两种写法有一些区别：

  1. 继承 Thread 类：当我们继承 Thread 类并重写 run() 方法时，this 关键字表示的是当前线程对象的引用，即 new 出来的线程对象本身。我们可以直接调用该对象的方法，比如 this.sleep()。

  2. 实现 Runnable 接口：当我们实现 Runnable 接口并创建了一个 Thread 对象来运行该 Runnable 对象时，this 关键字表示的是实现了 Runnable 接口的类的实例，即 MyRunnable 的引用。我们不能直接调用 this.sleep()，而是要使用Thread.currentThread().sleep()。

两种写法都可以创建线程并实现线程的运行逻辑，不同之处在于 this 表示的对象引用不同。

2.2.4其他变形

  1. 匿名内部类创建 Thread 子类对象
// 使用匿名类创建 Thread 子类对象
Thread t1 = new Thread() {
  @Override
  public void run() {
    System.out.println("使用匿名类创建 Thread 子类对象");
 }
};
  1. 匿名内部类创建 Runnable 子类对象
// 使用匿名类创建 Runnable 子类对象
Thread t2 = new Thread(new Runnable() {
  @Override
  public void run() {
    System.out.println("使用匿名类创建 Runnable 子类对象");
 }
});
  1. lambda 表达式创建 Runnable 子类对象
// 使用 lambda 表达式创建 Runnable 子类对象
Thread t3 = new Thread(() -> System.out.println("使用匿名类创建 Thread 子类对象"));
Thread t4 = new Thread(() -> {
  System.out.println("使用匿名类创建 Thread 子类对象");
});

通过这几种方式就可以创建一个线程了。

但是需要注意：一个线程在调用了start()方法之后，才算是真正创建了。调用start()方法会导致线程进入就绪状态，并且系统会为该线程分配执行资源，使得它可以开始执行run()方法中的代码。

  • 只有调用start()方法才会创建一个新的线程
  • run()方法只是分配了这个线程的任务是什么，不会创建新的线程。
  • start()方法来启动线程，

三：Thread 类及常见方法

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。

2.1Thread 的常见构造方法

方法说明
Thread()创建线程对象
Thread(Runnable target)使用 Runnable 对象创建线程对象
Thread(String name)创建线程对象，并命名
Thread(Runnable target, String name)使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group, Runnable target)线程可以被用来分组管理，分好的组即为线程组，这个目前我们了解即可
Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

2.2 Thread 的几个常见属性

属性获取方法
IDgetId()
名称getName()
状态getState()
优先级getPriority()
是否后台线程isDaemon()
是否存活isAlive()
是否被中断isInterrupted()
  • ID 是线程的唯一标识，不同线程不会重复
  • 名称是各种调试工具用到
  • 状态表示线程当前所处的一个情况，下面我们会进一步说明
  • 优先级高的线程理论上来说更容易被调度到
  • 关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
  • 是否存活，即简单的理解为 ：run 方法是否运行结束了

2.3 线程中断问题

interrupt()、interrupted() 和 isInterrupted() 方法是 Java 中用于线程中断的相关方法，它们有着不同的功能和用法。下面我将逐一解释它们的区别，并提供相应的代码示例。

  1. interrupt() 方法：

interrupt() 方法是用于中断线程的方法。它并不会真正地中断线程，而是给线程设置一个中断标志，表示线程被请求中断。

当调用线程的 interrupt() 方法时，如果线程处于阻塞状态（如 sleep、wait、join 等方法），就会抛出 InterruptedException 异常并清除中断状态，接着结束睡眠，

如果线程未处于阻塞状态，仅仅是设置中断标志，并不是真正的中断线程。线程的中断由线程决定，线程可以通过检查中断标志来决定是否中断自己的执行。

Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标记：
在这里插入图片描述

以下是一个示例代码，演示了如何使用 interrupt() 方法中断线程：

public class MyThread extends Thread {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            // 线程任务逻辑
            // ...
        }
    }
}

public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();

    // 等待一段时间后中断线程
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    thread.interrupt();
}

注意：当sleep被唤醒之后，sleep会自动把 isInterrupted()标志位给清空（true - > false）
在这里插入图片描述
注意：异常的抛出会清除线程的中断标志位，但并不会立即停止线程的执行。

它只会在线程的指定时间段内抛出异常，告诉线程当前处于中断状态，然后线程有机会从阻塞状态恢复，并在异常被捕获之后继续执行。

这种设计的目的是为了给开发者一个处理线程中断的机会。当线程被中断后，开发者可以根据具体业务需求来决定如何处理中断。

因此，当线程被InterruptedException异常唤醒时，isInterrupted()的返回结果会变为false, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程

  1. interrupted() 方法：

interrupted() 方法是一个静态方法，用于判断当前线程是否被中断，并返回中断状态。

而且在判断中断状态后，还会自动清除中断标志。

  • 如果线程在判断中断状态时没有被中断，则返回 false；
  • 如果线程在判断中断状态时被中断，则返回 true；

以下是一个示例代码，演示了如何使用 interrupted() 方法判断当前线程是否被中断：

public class ThreadDemo {
  private static class MyRunnable implements Runnable {
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        System.out.println(Thread.interrupted());
     }
   }
 }
  public static void main(String[] args) throws InterruptedException {
    MyRunnable target = new MyRunnable();
    Thread thread = new Thread(target, "李四");
    thread.start();
    thread.interrupt();
 }
}

true // 只有一开始是 true，后边都是 false，因为标志位被清
false
false
false
false
false
false
false
false
false

注意：interrupted() 方法会清除中断状态，即使线程未被中断。

  • isInterrupted() 方法：

isInterrupted() 方法是一个Java中的线程方法，用于检查当前线程是否被中断。

而且调用isInterrupted() 方法并不会清除线程的中断状态。

  • 当线程被中断时，isInterrupted() 方法会返回true。
  • 当线程没有被中断时，isInterrupted() 方法会返回false。

下面是一个示例代码，演示如何使用isInterrupted() 方法：

public class ThreadDemo {
  private static class MyRunnable implements Runnable {
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().isInterrupted());
     }
     }
 }
  public static void main(String[] args) throws InterruptedException {
    MyRunnable target = new MyRunnable();
    Thread thread = new Thread(target, "李四");
    thread.start();
    thread.interrupt();
 }
}

true // 全部是 true，因为标志位没有被清
true
true
true
true
true
true
true
true
true

下面是这三个方法的总结：

方法说明
public void interrupt()中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位
public static boolean interrupted()判断当前线程的中断标志位是否设置，调用后清除标志位
public boolean isInterrupted()判断对象关联的线程的中断标志位是否设置，调用后不清除标志位

2.4线程启动

之前我们已经看到了如何通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了，调用 start 方法, 才真的在操作系统的底层创建出一个线程.

  • 覆写 run 方法是提供给线程要做的事情的指令清单
  • 线程对象可以认为是把 李四、王五叫过来了
  • 而调用 start() 方法，就是喊一声：”行动起来！“，线程才真正独立去执行了。

在这里插入图片描述

2.5 等待一个线程

因为线程是并发执行的，线程的调度是抢占式执行的，所以操作系统对于线程调用的顺序的不知道的，无法判断哪个线程先结束，为了能够控制线程的结束顺序，因此java提供了join（）方法。

在Java中，join()方法是Thread类的一个方法，它允许一个线程等待另一个线程的完成。当一个线程调用另一个线程的join()方法时，调用线程将被阻塞，直到被调用的线程执行完毕。

方法说明
public void join()等待线程结束
public void join(long millis)等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos)同理，但可以更高精度

下面是代码示例：

public class JoinExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                // 模拟线程执行耗时的操作
                Thread.sleep(2000);
                System.out.println("子线程执行完毕");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread.start(); // 启动子线程
        thread.join(); // 主线程等待子线程执行完毕

        System.out.println("主线程继续执行");
    }
}

在上面的代码中，主线程启动子线程后调用了子线程的join()方法，这样主线程就会等待子线程执行完毕后再继续执行。

当子线程执行完毕后，主线程才会继续执行并输出"主线程继续执行"。

2.6获取当前线程引用

方法说明
public static Thread currentThread();返回当前线程对象的引用

代码示例：

public class ThreadDemo {
  public static void main(String[] args) {
    Thread thread = Thread.currentThread();
    System.out.println(thread.getName());
 }
}

2.7 休眠当前线程

也是我们比较熟悉一组方法，有一点要记得，因为线程的调度是不可控的，所以，这个方法只能保证实际休眠时间是 ≥ 参数设置的休眠时间的。

方法说明
public static void sleep(long millis) throws InterruptedException休眠当前线程 millis毫秒
public static void sleep(long millis, int nanos) throws InterruptedException可以更高精度的休眠
public class ThreadDemo {
  public static void main(String[] args) throws InterruptedException {
    System.out.println(System.currentTimeMillis());
    Thread.sleep(3 * 1000);
    System.out.println(System.currentTimeMillis());
 }
}

四：线程的状态

4.2线程的状态

线程的状态是一个枚举类型 Thread.State，我们可以通过这段代码得到线程的状态：

public class ThreadState {
  public static void main(String[] args) {
    for (Thread.State state : Thread.State.values()) {
      System.out.println(state);
   }
 }
}

线程在Java中有几种不同的状态，每种状态表示线程在执行过程中的不同阶段或状态。线程的状态主要有以下几种：

  1. 新建状态（NEW）：当线程对象被创建时，它处于新建状态。在这个状态下，线程没有被启动，还未开始执行。

  2. 可运行状态（RUNNABLE）：线程处于可运行状态意味着线程已经通过调用start()方法启动。

可运行状态又分为这两种状态：

  • 正在运行（Running）：线程正在执行中。
  • 就绪（Ready）：线程等待CPU调度，具备执行条件，但尚未获得CPU时间片。

  1. 阻塞状态（BLOCKED）：线程可能因为等待获取一个排它锁（synchronized关键字）而进入阻塞状态。当其他线程持有锁时，该线程将被阻塞，只有当获取到锁时才能继续执行，BLOCKED 表示等待获取锁

  2. 等待状态（WAITING）：线程在等待其他线程的特定操作，例如等待其他线程的通知或等待输入/输出操作完成，WAITING 表示等待其他线程发来通知，WAITING 线程在无限等待唤醒

  3. 超时等待状态（TIMED_WAITING）：类似于等待状态，但是可以设置一个超时时间，当超过指定时间后，线程将自动恢复到可运行状态， TIMED_WAITING 表示线程在等待唤醒，等待其他线程发来通知，但设置了时限。

  4. 终止状态（TERMINATED）：线程已经完成执行，或者因为异常而终止。

线程状态之间可以相互转换，而且转换的过程是由Java的线程调度器负责控制的。

下面是对线程状态的比喻：

  • NEW: 安排了工作, 还未开始行动
  • RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
  • BLOCKED: 这几个都表示排队等着其他事情
  • WAITING: 这几个都表示排队等着其他事情
  • TIMED_WAITING: 这几个都表示排队等着其他事情
  • TERMINATED: 工作完成了.

在这里插入图片描述
下面是各个状态的详细关系图：

在这里插入图片描述
所以，之前我们学过的 isAlive() 方法，可以认为是处于不是 NEW 和 TERMINATED 的状态都是活着的。

4.2 yield（）

yield()方法的作用是提醒调度器当前线程可以放弃cpu控制权，但是它不保证CPU资源一定会让给其他线程，只是将当前线程的状态更改为就绪状态，然后再次与同等或更高优先级的线程竞争CPU资源。

下面是yield()方法的一般语法：

Thread.yield();

以下几点要注意：

  1. yield()方法只能在线程内部调用，不能在静态方法中使用。
  2. yield()方法不会释放锁，即使线程调用了yield()方法，它仍然持有当前获取的锁。
  3. 当线程调用yield()方法后，它可能会立即重新获得执行权，因此yield()方法不能用来实现线程的顺序执行。

下面是一个简单的示例代码，演示了yield()方法的使用：

Thread t1 = new Thread(new Runnable() {
  @Override
  public void run() {
  while (true) {
      System.out.println("张三");
      // 先注释掉, 再放开
      // Thread.yield();
   }
 }
}, "t1");
t1.start();
Thread t2 = new Thread(new Runnable() {
  @Override
  public void run() {
    while (true) {
      System.out.println("李四");
   }
 }
}, "t2");
t2.start();

可以看到:

  1. 不使用 yield 的时候, 张三李四大概五五开
  2. 使用 yield 时, 张三的数量远远少于李四
ice___Cpu
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
javaee详解.7z
06-07
javaee详解.7z
JavaEE介绍
热门推荐
qq_53945199的博客
05-20 1万+
目录 前言 一、JavaEE的产生背景 二、Java EE是什么？ 三、Java EE的编程思想 四、Java EE在应用上的分层模型 五、Java EE体系架构的有点 六、开源和开源框架 前言 JavaEE是什么？小小的脑袋大大的疑惑，Java和JavaEE不同的，下面的一些内容，将大概的介绍JavaEE的一些知识点。更容易理解JAVAEE的来历以及它的作用。 一、JavaEE的产生背景 为了满足开发多层体系结构的企业级应用的需求，Java公...
JavaEE基础知识详解教程（初学者的必选教程，不看后悔，入门级教程）
03-03
JavaEE基础知识详解教程（初学者的必选教程，不看后悔，入门级教程）...入门首先的基础实用教程！
JavaEE知识体系详细知识点详细讲解
风一般的男子·小亮仔
05-22 8523
JavaEE知识体系 idl的快捷方式: 查找：ctrl+F 快速显示文档和信息:ctrl+Q 抽取方法:ctrl+alt+M 修改：shift+F6 导入：ctrl+shift+alt+S 快捷键 英文说明 中文说明 Ctrl + Space Basic code completion (the name of any class, method or va...
JAVA EE教程详解，很详细的
04-10
JAVA EE教程详解，很详细的。适合有基础的学习和使用，希望对大家有所帮助
李兴华-JavaSE开发详解笔记-李兴华
02-07
线程是并发编程的基础，Java提供了丰富的线程API，包括Thread类和Runnable接口，以及synchronized关键字、wait/notify机制等，用于实现多任务并行执行。 I/O流是处理输入输出的关键，Java提供了丰富的流类，支持...
ChatRoom_JavaEE_eventuallyk3w_
10-03
【JavaEE技术体系详解】 JavaEE（Java Platform, Enterprise Edition），是Java平台的企业版，用于构建分布式、多层的企业级应用程序。它包含了多种组件和服务，为开发者提供了丰富的工具集，以便构建可扩展、高...
java基础入门详解.1
07-05
Sun公司对Java编程语言的解释是：Java编程语言是个简单、面向对象、分布式、解释性、健壮（鲁棒性）、安全与系统无关、可移植、高性能、多线程和静态的语言（从JDK8开始引入了一些动态语言的特性）。 Java平台是...
javaee试卷.pdf
09-30
【JavaEE试卷知识点详解】 JavaEE是企业级应用开发的标准，涵盖了诸如Web开发、服务器端组件、数据库交互等多方面内容。本试卷涉及到的主要知识点包括： 1. 表单操作：在JavaEE中，表单操作是用户与服务器交互的...
JavaEE基础知识讲解
wanghan_ak的博客
06-22 1720
学习JavaEE的你们是不是一头雾水呢？ C/S client/server 客户端/服务器 B/C browser/server 浏览器/服务器 通过浏览器访问到对应页面，发送请求（同步请求，异步请求，ajax请求，会读接口文档）---服务器（云服务器：腾讯云服务器 阿里云服务器等等）---应用服务器Tomcat---匹配servlet---service业务处理---dao层 JDBC Hibemate，ORM---数据库---File---servlet（控制器Controller）MVC
javaEE -8（10000字详解网络编程）
最新发布
weixin_73232539的博客
10-24 1666
9000字详解网络编程
JAVAEE三层架构详细解释以及代码分层编写
weixin_51351637的博客
08-11 318
web、service、dao层
Web核心-Servlet
weixin_33894992的博客
09-17 107
Servlet实际上是ServerApplet--小服务程序或服务连接器，用Java编写的服务器端程序，主要功能在于交互式地浏览和修改数据，生成动态Web内容。与常用的协议，如DNS，TCP/IP，HTTP类似，Servlet是作为一整套规范存在的；同时作为J2EE标准的一部分，定义了javaweb开发的标准。Servlet制定了java处理WEB请求的一系列标准，我们只需要按照标准规定的去做就可...
JAVA EE，一文彻底聊明白
Joker_ZJN的博客
12-07 2208
一文彻底将明白JAVA EE，以及JAVA EE和Spring的相爱相杀。
JavaEE相关知识和技巧概括
weixin_41005188的博客
08-11 900
JavaEE相关知识和技巧概括RESTRPCREST与RPC比较 REST REST详解： REST，表示性状态转移（representation statetransfer）。简单来说，就是用URI表示资源，用HTTP方法(GET, POST, PUT, DELETE)表征对这些资源的操作。 ①Resource: 资源，即数据，存在互联网上的可被访问的实体 ②Representation： 数据的某种表现形式，如HTML, JSON。 ③State Transfer：状态变化，HTTP方法实现 REST
JavaEE基础知识整理
qq_34341951的博客
06-29 3240
Web应用执行流程JavaEE概念、技术（了解）通过实现Servlet接口，编写代码（写类，实现接口，重写5个接口：初始化等）init destroy service getServletConfig getServletInfoServlet接口和HttpServlet之间的关系HttpServlet继承GenericServlet  GenericServlet继承ServletServlet...
javaee基础知识详细总结
qq_42612870的博客
03-07 4133
Java基础阶段 - 知识总结及重点案例 预科班 电脑常用配置 电脑常见操作 JDK安装和环境变量 预习 高级记事本安装配置 预习 day01 Java环境搭建及入门 Java语言发展史(了解) Java是1995年由SUN公司推出的计算机语言 公认的Java之父是詹姆斯高士林 ork橡树 -> 被注册了 -> Java是[爪哇]音译 -> 爪哇岛是印度尼西亚的一座岛 -> 盛产咖啡豆 跨平台原理(了解) 常见的平台有Windows Mac Linux 不同平台的厂商
javaee思维导图版笔记-吉林大学
06-30
"吉林大学的JavaEE思维导图版笔记涵盖了从基础到高级的Java企业级应用开发知识，强调了复习策略和考试题型，包括填空、选择、简答和程序设计。笔记特别提到了JSP、JNDI、JPA作为重点复习内容，并给出了ejb和jpa的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ice___Cpu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值