零基础掌握Java多线程（一）：进程与线程、线程的创建

最新推荐文章于 2026-06-29 16:52:08 发布
原创 最新推荐文章于 2026-06-29 16:52:08 发布 · 1k 阅读 · 22 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

 学习目的：使用Web开发，构建网站

一、进程与线程

为了解决多进程开销过大的问题，引入线程（Thread），轻量级进程。每一个进程都包含多个线程。可以同一时间执行多个任务。

1. 进程与线程关系

进程：操作系统资源分配的基本单位（如内存、文件），每个进程有独立内存空间。资源隔离性好，适合需高稳定性的任务（如独立服务）

线程：进程内的执行单元，多个线程共享进程资源（内存、文件等），是CPU调度的基本单位。资源共享效率高，适合高并发但需控制数量（如并行计算）。

2. 资源开销差异

进程开销大：创建/销毁需申请/释放资源（如内存），切换时需保存完整上下文（寄存器、内存管理等）。  

线程开销小：首个线程随进程创建时申请资源，后续线程直接共享资源；切换时仅需保存寄存器等少量数据，故称“轻量级进程”

3. 线程效率的局限性

资源限制：线程共享进程的有限资源（如内存）。提高线程数目，能提升效率，但无法线性增长，资源有限。

调度开销：线程数量过多时，操作系统调度线程的切换成本增加，反而降低性能。  线程数目太多，线程调度开销也会增大。

4. 稳定性影响  

进程独立：一个进程崩溃不影响其他进程

线程依赖：同一进程的线程共享资源，一个线程崩溃可能导致整个进程终止

二、线程的创建

1.基本创建软件包的流程（以IDEA为例）

新建软件包，并为软件包命名（以first命名为例）

在软件包中创建Java类

2.基本创建相关知识

多线程默认不按照顺序执行，具体顺序由操作系统调度策略综合决定。

创建启动线程的一般流程：

（1）​​定义线程任务​​：

通过重写run()方法实现线程的具体逻辑。run()方法是线程的执行体，是线程的核心。定义了线程启动后要执行的任务内容。可以通过继承Thread类并重写run()方法，或实现Runnable接口的run()方法来实现。Runnable接口是重写run()，Callable接口是重写call()。

（2）​​创建线程对象​​：

若继承Thread类，直接实例化该子类

若实现Runnable接口，需将Runnable实例作为参数传递给Thread的构造函数。

（3）​​启动线程​​：

调用线程对象的start()方法。该方法会触发JVM创建一个新线程，并自动调用run()方法执行任务。注意直接调用run()方法仅会在当前线程中同步执行，不会创建新线程。

start() vs run() 的区别

start()：​​创建​​新线程，并​​安排​​执行run()方法

run()：只是​​普通方法​​，直接调用不会创建线程

三、线程创建的方法

1.继承Thread类--单继承

注：Java只支持单继承，不支持多继承。所以该方法有单继承限制。

（1）基本写法

class MyThread extends Thread {
    public void run() {
        // 任务逻辑（无返回值）
    }
}
new MyThread().start();

代码示例：

package thread;

/**
 * 自定义线程类，继承Thread类并重写run方法定义线程任务
 * 用于演示继承Thread类创建线程的基本方式
 */
class MyThread extends Thread{
    @Override
    public void run(){
        //线程执行体：无限循环打印当前的线程信息
        while (true){
            //打印当前线程对象（包含线程名称、优先级等信息）
            System.out.println("Using Thread:"+Thread.currentThread());
            try{
                //休眠一秒（1000毫秒），sleep()会抛出InterruptedException,需要捕获处理
                Thread.sleep(1000);
            }catch(InterruptedException e){
                //当线程被中断时，抛出运行时异常终止循环
                throw new RuntimeException(e);
            }
        }
    }
}

/**
 * 主类演示通过继承Thread类创建并启动线程
 */
public class ThreadDemo {
    public static void main(String[] args) {
        Thread t = new MyThread(); //创建自定义线程实例

        //启动线程，调用start()，而不是run()
        //start()会创建新线程并自动调用run()方法，实现并发执行
        //直接调用run()只会作为普通方法在当前线程同步执行
        t.start();
    }
}

（2）基于继承Thread，使用内部匿名类

new Thread() {
    @Override
    public void run() {
        // 线程任务
    }
}.start();

代码示例：

package thread;

public class AnonymousThreadDemo {
    public static void main(String[] args) {
        //通过匿名内部类创建并启动线程
        new Thread(){ //创建Thread类的匿名子类
            @Override
            public void run(){
                System.out.println("Anonymous Thread running");
                try {
                    Thread.sleep(1000); //休眠一秒
                } catch (InterruptedException e) {
                    //处理中断异常
                    e.printStackTrace(); //打印异常堆栈
                }
            }
        }.start();  //立即启动线程
    }
}

2.实现Runnable接口--无返回值任务

（1）基本写法

class MyTask implements Runnable {
    public void run() {
        // 任务逻辑
    }
}
new Thread(new MyTask()).start();

示例代码：

package thread;

/**
 * 自定义Runnable实现类，用于定义线程任务逻辑
 */
class MyRunnable implements Runnable{
    @Override
    public void run(){
        //使用无限循坏持续运行
        while (true){
            //打印当前线程信息（包含线程名称、优先级等）
            System.out.println("Runnable Task:"+Thread.currentThread());
            try {
                Thread.sleep(1000); //休眠一秒
            } catch (InterruptedException e) {
                //捕获并打印中断异常（当线程中断时触发）
                e.printStackTrace();
            }
        }
    }
}

/**
 * 演示Runnable接口使用的示例类
 * 展示如何通过Runnable实现多线程编程
 */
public class RunnableDemo {
    public static void main(String[] args) {
        Runnable task = new MyRunnable(); //创建Runnable实例

        //创建Thread对象，讲Runnable任务与线程绑定
        //第二个参数（可不加），指定线程名称是"Runnable-Thread"
        Thread thread = new Thread(task,"Runnable-Thread");
        thread.start();//启动线程，JVM会调用run()方法
    }
}

（2）基于实现Runnable，实现匿名内部类

new Thread(new Runnable() {
    @Override
    public void run() {
        // 线程任务
    }
}).start();

代码示例：

package thread;

public class AnonymousRunnableDemo {
    public static void main(String[] args) {
        //使用匿名内部类实现Runnable接口，并直接传递给Thread构造函数
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("Anonymous Runnable running");
                    try {
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

3.实现Callable接口--有返回值任务

可返回结果 + 抛出异常，需配合 FutureTask

（1）基本方法

// 1. 定义一个实现Callable接口的类，泛型指定返回值类型

class 任务名 implements Callable<返回类型> { 

    public 任务名(参数) {

        // 初始化字段

    }

// 2. 重写call方法，编写任务逻辑

    @Override

    public 返回值类型 call() throws Exception {

        // 代码逻辑

        // 可以返回结果，也可以抛出异常

        return 返回类型对应的对象;

    }

}

// 3.将Callable任务包装进FutureTask

FutureTask<返回值类型> futureTask = new FutureTask<>(callableTask);

// 4.创建线程并启动

Thread thread = new Thread(futureTask);

thread.start();

代码示例：

package thread;

// 导入必要的并发编程类
import java.util.concurrent.Callable;       // 定义可返回结果和抛出异常的任务的接口
import java.util.concurrent.ExecutionException; // 执行计算时可能抛出的异常
import java.util.concurrent.FutureTask;    // 可取消的异步计算，提供了Future的基本实现

/**
 * MyTask 类实现了 Callable<Integer> 接口
 * 这意味着它可以作为一个能够返回 Integer 类型结果的任务
 * 与 Runnable 相比，Callable 的优势在于可以返回值和抛出受检异常
 */
class MyTask implements Callable<Integer> {
    private int n; // 用于存储计算的上限值

    /**
     * 构造函数，初始化任务的计算上限值
     * @param n 计算的上限值（计算从0到n-1的和）
     */
    public MyTask(int n) {
        this.n = n; // 将参数n赋值给成员变量n
    }

    /**
     * 重写 Callable 接口的 call 方法
     * 这是任务执行的核心逻辑，计算从0到n-1的累加和
     * @return 计算得到的累加和 (Integer类型)
     * @throws Exception 可以抛出受检异常，这是Callable与Runnable的一个区别
     */
    @Override
    public Integer call() throws Exception {
        int sum = 0; // 初始化累加和为0
        // 循环从0到n-1，进行累加计算
        for (int i = 0; i < n; i++) {
            sum += i; // 将当前索引i的值加到sum上
        }
        return sum; // 返回最终计算得到的累加和
    }
}

/**
 * CallableDemo 类演示了如何使用 Callable 和 FutureTask
 * 实现带有返回值的多线程任务
 */
public class CallableDemo {
    public static void main(String[] args) {
        // 创建一个MyTask实例，计算0到79的和（因为参数是80，循环条件是i<80）
        MyTask task = new MyTask(80);

        /**
         * 创建一个FutureTask对象，封装MyTask任务
         * FutureTask实现了RunnableFuture接口，而RunnableFuture继承了Runnable和Future接口
         * 因此FutureTask既可以作为Runnable被Thread执行，又可以作为Future来获取计算结果
         */
        FutureTask<Integer> future = new FutureTask<>(task);

        /**
         * 创建并启动一个线程来执行FutureTask任务
         * FutureTask本身实现了Runnable接口，所以可以传递给Thread的构造函数[9](@ref)
         * 也可以直接写成 new Thread(future).start();
         */
        Thread thread = new Thread(future); // 创建线程，将future作为其运行目标
        thread.start(); // 启动线程，线程开始执行MyTask中的call方法

        // 尝试获取并处理计算结果
        try {
            Integer result = future.get();
            // 打印计算结果：0+1+2+...+79 = 3160
            System.out.println(result);
        } catch (InterruptedException e) {
            // 处理线程在等待过程中被中断的异常
            e.printStackTrace();
        } catch (ExecutionException e) {
            /**
             * 处理执行计算过程中发生的异常
             * 如果在MyTask的call方法执行过程中抛出了任何异常，
             * 都会被包装在ExecutionException中
             */
            e.printStackTrace();
        }
    }
}

（2）匿名内部类实现Callable接口

这种方式适用于一次性任务，无需单独创建类文件。直接在需要的地方（例如 main方法内）定义并实例化 Callable。

package thread;

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

public class AnonymousCallableDemo {
    public static void main(String[] args) {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i < 80; i++) {
                    sum+=i;
                }
                return sum;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            Integer result = futureTask.get();
            System.out.println(result);  //3160
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

【推荐】基于 Lambda 表达式（JDK 8+）

（1）Lambda表达式基础

Lambda 表达式是 Java 8 引入的核心特性，用于简化函数式接口（仅含一个抽象方法的接口）的实现。其简化规则涵盖语法、参数、方法体等多个维度

基本语法

(parameters) -> expression

或

(parameters) -> { statements; }

（2）使用lambda表达式创建线程

继承Thread类的方式无法使用Lambda表达式简化​​， Callable和Runnable都是函数式接口（只有一个 call()方法），可以用 Lambda 表达式进一步简化

Lambda 中引用的外部变量必须是 final 或 effectively final。

1）使用Lambda表达式实现Runnable接口

使用Lambda表达式：


Runnable lambdaRunnable = () -> {

        //线程执行代码逻辑

}；

new Thread(lambdaRunnable).start();

更简洁的直接写法：

// 创建并启动线程
new Thread(() -> {
    // 线程执行的代码逻辑
}).start();

代码示例：

package thread;

public class LambdaRunnableDemo1 {
    public static void main(String[] args) {
        //使用Lambda表达式实现Runnable接口
        Runnable lambdaRunnable = ()->{
            //无限打印线程名
            while (true){
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //创建并启动线程，第二个参数（对线程的命名可省略）
        new Thread(lambdaRunnable,"Lambda_Thread").start();
    }
}

package thread;

public class LambdaRunnableDemo2 {
    public static void main(String[] args) {
        final String Hi = "Hello Lambda Runnable";

        new Thread(()->{
            System.out.println(Hi + Thread.currentThread().getName());
        },"Lambda-Thread").start();
    }
}

单行表达式简化：若执行语句仅一行，可省略大括号，进一步简化为：() -> 执行语句

Runnable runnable = () -> System.out.println("Hello from Lambda");
new Thread(runnable).start();

或直接内联

new Thread(() -> System.out.println("Hello from Lambda")).start();
2)使用Lambda实现Callable接口

Callable<返回类型> callable = () -> {
    // 任务逻辑代码
    return 结果; // 返回指定类型的结果
};

package thread;

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

public class LambdaCallableDemo {
    public static void main(String[] args) {

        //1. 使用Lambda 表达式实现Callable接口
        Callable<Integer> MyTask = ()->{
            int sum = 0;
            for (int i = 0; i < 80; i++) {
                sum+=i;
            }
            return sum;
        };

        //2.将Callable任务包装在FutureTask中
        FutureTask<Integer> futureTask = new FutureTask<>(MyTask);

        //3.创建线程来执行任务
        Thread thread = new Thread(futureTask);
        thread.start();

        //4.通过FutureTask获取结果
        try{
            Integer result = futureTask.get();
            System.out.println(result); //结果为3160
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

单行表达式简化​：Lambda表达式主体为单行时，可自动返回该表达式的值，无需显式写return

Callable<Integer> callable = () -> 42; // 无参数且返回简单值，直接返回常量
Callable<Double> randomTask = () -> Math.random(); // 返回随机数

注意事项：

1.​​Lambda表达式限制​​：Lambda中引用的外部变量必须是final或effectively final（即实际不可变）。

2.线程启动​​：必须调用start()而非直接调用run()，后者会在当前线程同步执行。

3.​​资源管理​​：Callable需配合FutureTask或线程池使用，避免手动创建线程。

标签
#java #开发语言
散小尘
关注
【Java多线程】：理解线程创建、特性及后台进程
island1314的博客
11-05 2503
本篇主要是了解进程与线程，能够说出两者区别，并且掌握 创建多线程的 3 种方式，能够正确使用 Thread 类、Runnable 接口、Callable 接口实现多线程，并且了解 3 种创建多线程方式的区别。其次还会熟悉后台线程的使用，能够理解后台线程用于做什么
多线程学习笔记01线程、进程、多线程与线程创建
2501_90425057的博客
01-30 1651
多线程学习笔记01线程、进程、多线程与线程创建。
Java中的多线程和多进程
木瓜有益健康的博客
04-05 3391
Java中的多进程Thread创建进程线程状态进程的分类线程同步死锁 标准：高可用、高性能、高并发 区别 进程 线程 根本区别 作为资源分配的单位 调度和执行的单位 开销 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换开销大 同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器PC，线程的切换开销小 所处环境 OS中能同时运行多个任务/程序 同一...
java单线程和多线程的区别_Java多线程详解之一：线程创建
weixin_29499957的博客
02-13 1729
一、线程、进程、多线程1、线程与进程定义进程：进程是系统进行资源分配和调度的基本单位，是操作系统中一个运行的程序，是线程的容器；线程：线程是处理机调度的最小单位，包含在进程中，是进程中实际运作单位；一个例子：比如说我们的华为手机，操作系统是安卓，手机里的应用是进程，比如微信，而微信里的发语音、发文字、拍一拍等功能就是一个个线程。2、线程与进程的区别调度：线程是处理机调度的基本单位，进程是资源分配的...
多线程原理与实战 之 线程创建 （一）
spy47_的博客
04-02 1267
最后总结一下Runnable接口创建线程目标类的优缺点。1）所创建的类并不是线程类，而是线程的target执行目标类，需要将其实例作为参数传入线程类的构造器，才能创建真正的线程。也就是说Runnable仅仅只是任务逻辑的载体，是最核心的部分。2）在Runnable的run()方法中，无法直接访问当前线程的属性（如名称、优先级），因为run()方法属于Runnable实例，而非Thread实例。必须通过获取当前线程对象之后才能访问线程属性。1）可以避免由于Java单继承带来的局限性。
Java自学日记之多线程（一）：线程与进程以及线程的创建
qq_51738873的博客
03-11 1182
系列文章目录 暂无 文章目录系列文章目录一、线程与进程1.进程概念特点2.线程概念特点线程的优先级线程的五种状态新生状态就绪状态运行状态阻塞状态进入阻塞状态的原因死亡状态进入死亡状态的原因二、线程的创建1.继承Thread类本身流程样例2.实现Runnable接口流程样例总结 一、线程与进程 1.进程 概念 进程是操作系统环境中的基本成分、是系统资源分配的基本单位。从用户角度来看，进程是应用程序的一个执行过程。 特点 进程是线程的容器 占用特定的地址空间 进程之间相互独立 缺点：频繁地切换进程会造
Java零基础入门:多线程总结
分享技术干货，锻炼表达能力
06-06 581
程序、进程、线程程序：从所周知的，编写代码组成的。进程：可以理解为运行中的程序，比如启动QQ，就启动一个进程，操作系统会为进程分配内存空间。线程：由进程创建的，是进程的一个实体。单线程和多线程的区分：同一个时刻，只允许执行一个线程同一个时刻，可以执行多个线程，比如QQ可以同时打开多个聊天窗口并发和并行（理解）通过继承 Thread 的方法和实现 Runnable 接口的方式创建多线程，哪个好？实现Runnable接口好，原因有两个： ②、runnable接口实现run方法 1、dog.start();这里不
进程与线程概述及JAVA多线程四种实现方式详解
weixin_48655626的博客
12-10 3800
1. 进程与线程概述 利用多线程技术可以使系统同时运行多个程序块，缩短出程序响应的时间，提高计算机资源的利用率，达到多任务处理的目的。 进程是程序的一次动态执行过程，每个进程都有自己独立的内存空间。一个应用程序可以同时启动多个进程(比如浏览器可以开多个窗口，每个窗口就是一个进程) 多进程操作系统能够运行多个进程，每个进程都能够循环利用所需要的CPU时间片，使的所有进程看上去像在同时运行一样。 线程是进程的一个执行流程，一个进程可以由多个线程组成，也就是一个进程可以同时运行多个不同的线程，每个线程完成不
进程与线程+多线程优势
欢迎来到 小哇 的博客，会一直加油！
11-06 1329
开始记录时间后创建了线程t1，然后开启t1，接着创建线程t2并开启该线程，然后就打印了执行时间，但此时两个线程还在执行任务，没有结束。线程用的就是进程启动时从操作系统中分配的资源，（线程也可以叫轻量级的进程），当创建一个进程时，进程中就会包含一个线程，叫主线程。run方法只是Java对象的一个普通方法，定义了线程要执行的任务，但是调用run方法不会申请系统进程PCB，不能启动线程。我们可以理解为进程就是一个公司，线程就是员工，一个公司可以有多个员工，一个进程可以创建多个线程。
线程与进程的区别？如何创建一个线程?Java中如何创建一个进程？
赵KK的博客
05-27 1315
在操作系统中，进程是程序执行的实体。在Java中，我们可以通过多种方式创建和管理进程。了解进程的基本概念是创建和管理它们的第一步。进程是Java应用程序的重要组成部分，正确地创建和管理进程对于构建稳定和高效的应用程序至关重要。
多线程（一）程序，进程，线程的区别与联系
qq_42856647的博客
11-18 5441
程序、进程、线程的概念 程序是指令的有序集合，被存储在磁盘或其他的数据存储设备中，是一个静态概念，其本身没有任何运行的含义。 进程是指一个具有一定独立功能的程序关于某个数据集合的一次运行活动，是系统运行程序的基本单位，因此进程是动态的。 线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。 程序
多线程一 线程的创建
iqqcode
07-21 1037
JavaSE中最核心的内容，多线程它来了。什么是进程？什么是线程？创建线程要执行哪些操作？有哪几种方式来创建线程？本文带你揭秘，欢迎学习多线程系列博文......
Java讲课笔记33：多线程概述与线程创建
howard2005的专栏
06-03 1265
1. 了解多线程的概念 2. 掌握多线程创建的三种方式 3. 熟悉创建多线程三种方式的主要区别
Java多线程~认识进程与线程、掌握创建线程的方式
qq_58284486的博客
04-27 526
目录 进程与线程 进程 什么是进程？ 进程管理 进程的状态 线程 什么是线程？ 线程的实现方式 进程与线程的关系 Java线程和操作系统线程的关系 多线程的优点和缺陷 三种方式创建线程 继承Thread 自定义一个类继承Thread 使用匿名内部类 实现Runnable接口 自定义一个类来实现Runnable接口 匿名内部类实现 实现Callable接口 进程与线程 进程 什么是进程？ 进程是操作系统对一个正在运行的程序的一种抽象，也可以把进程看做程序的..
Java多线程编程基础：进程与线程、并发与并行
xOVOx___的博客
07-24 975
理解进程与线程和并发与并行是Java多线程编程的基础。Java提供了多种创建线程的方式，开发者应根据具体需求选择最合适的方式。在多线程编程中，线程安全和资源管理是需要特别注意的问题。后续可以进一步学习线程同步、线程池等高级主题来提升多线程编程能力。希望这篇文章能帮助你更好地理解多线程编程基础中进程与线程和并发与并行的概念。如果你有任何问题或建议，欢迎在评论区留言讨论。
Java多线程（创建线程的三种方式、线程与进程）
baolingye的博客
06-03 1274
Java多线程 一、进程与线程 程序：程序是指令和数据的有序集合，其本身没有任何运 行的含义，是一个静态的概念 进程：进程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位 。当一个程序进入内存运行时，就变成了一个进程 线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程 三者关系：简而言之，一个程序运行后至少有一个进程，一个进程里可以包含多个线程，但至少包含...
java中多线程、并发、并行、线程与进程、线程调度、创建线程的方式
专研前端，探索后端
12-17 1352
java中多线程、并发、并行、线程与进程、线程调度、创建线程的方式
Java：多线程（进程线程，线程状态，创建线程，线程操作）
燕双嘤
07-31 965
2w字吐血整理，Java（线程，进程，协程，守护线程，线程的生命周期，创建线程三种方式，线程操作，优先级，后台线程）。包括：基础知识，底层原理，代码复现，面试难点，刁钻问题解答。
Java多线程的四种创建方式
xieyichun_的博客
11-18 1165
分享了Java多线程的四种创建方式
一款针对Spring漏洞框架进行快速利用的图形化工具
最新发布
LiBai'S BLOG
06-29 380
一款针对Spring漏洞框架进行快速利用的图形化工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值