探索Netty的EventLoop

已于 2023-09-09 16:23:09 修改
阅读量227 收藏
点赞数
分类专栏： Netty学习之旅 文章标签： java 数据库 服务器
于 2023-09-07 20:10:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49183244/article/details/132733494
版权

文章目录

一、EventLoopGroup 是什么？🤔️

EventLoop，即"事件循环对象"，本质是一个单线程执行器（同时维护了一个 Selector），里面有run方法处理 Channel 上源源不断的 io 事件。

EventLoop它的继承关系比较复杂

  • 继承java.util.concurrent.ScheduledExecutorService ，因此包含了线程池中所有方法
  • 继承netty自身的OrderedEventExecutor，它提供了boolean inEventLoop(Thread thread);方法判断一个线程是否属于此 EventLoop，EventLoopGroup parent();方法查看自己属于哪个 EventLoopGroup。

EventLoopGroup，即“事件循环组”，是一组 EventLoop，channel 一般会调用 EventLoopGroup 的 register 方法来绑定其中一个 EventLoop，后续这个 channel 上的io事件都由此 EventLoop 来处理（保证了 io 事件处理时的线程安全）。

EventLoopGroup继承 netty 自己的 EventExecutorGroup，实现了 Iterable 接口提供遍历 EventLoop 的能力，另有 next() 方法获取集合中下一个 EventLoop。
在这里插入图片描述

二、NioEventLoop 有哪些重要组成部分？🔍

接下来我们通过源码查看 NioEventLoop 有哪些部分组成～

通过查看 NioEventLoop 类，我们发现其维护了 Selector！可是为什么是两个selector呢？这就是netty优化selector之处，在后面会为大家详细讲解！

public final class NioEventLoop extends SingleThreadEventLoop {
		
  	//......
    /**
     * The NIO {@link Selector}.
     */
    private Selector selector;
    private Selector unwrappedSelector;
}

我们查看NioEventLoop的父类io.netty.util.concurrent.SingleThreadEventExecutor，维护了一个线程和任务队列！

public abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
		//......

    private final Queue<Runnable> taskQueue;

    private volatile Thread thread;
}

其父类io.netty.util.concurrent.AbstractScheduledEventExecutor中维护了一个任务队列！

public abstract class AbstractScheduledEventExecutor extends AbstractEventExecutor {
		//......

    PriorityQueue<ScheduledFutureTask<?>> scheduledTaskQueue;
}

NioEventLoop主要由selector、线程和任务队列组成，NioEventLoop既会处理io事件，也可以处理普通任务和定时任务！

NioEventLoop 中的 selector 何时创建？

我们发现在EventLoop的构造方法中就已经将Selector创建！

在这里插入图片描述

NioEventLoop 为何有两个 selector 成员呢？

原生的selector中对于selectedKeys的实现是采用Set结构，想必大家一定知道set的遍历性能并不高！netty使用反射的方式将其读取出来替换成数组结构去维护～

在这里插入图片描述

三、NioEventLoop 的 thread 在何时启动？

当然是在执行 execute() 方法时创建咯，我们通过debug的方式来查看服务端这边NioEventLoop的nio线程启动过程！

以上通过bind()方法一直点下去，直至 io.netty.bootstrap.AbstractBootstrap#doBind0

private static void doBind0(
        final ChannelFuture regFuture, final Channel channel,
        final SocketAddress localAddress, final ChannelPromise promise) {

    // This method is invoked before channelRegistered() is triggered.  Give user handlers a chance to set up
    // the pipeline in its channelRegistered() implementation.
    channel.eventLoop().execute(new Runnable() {
        @Override
        public void run() {
            if (regFuture.isSuccess()) {
                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
            } else {
                promise.setFailure(regFuture.cause());
            }
        }
    });
}

此时调用了channel所关联的eventLoop的execute()方法，我们查看io.netty.util.concurrent.SingleThreadEventExecutor#execute

@Override
public void execute(Runnable task) {
    if (task == null) {
        throw new NullPointerException("task");
    }

    boolean inEventLoop = inEventLoop();
  	// 添加任务，其中队列使用了 jctools 提供的 mpsc 无锁队列
    addTask(task);
    if (!inEventLoop) {
       // inEventLoop 如果为 false 表示由其它线程来调用 execute，即首次调用，这时需要向 eventLoop 提交首个任务，启动死循环，会执行到下面的 doStartThread
        startThread();
        if (isShutdown()) {
          // 如果已经 shutdown，做拒绝逻辑
            boolean reject = false;
            try {
                if (removeTask(task)) {
                    reject = true;
                }
            } catch (UnsupportedOperationException e) {
                // The task queue does not support removal so the best thing we can do is to just move on and
                // hope we will be able to pick-up the task before its completely terminated.
                // In worst case we will log on termination.
            }
            if (reject) {
                reject();
            }
        }
    }

    if (!addTaskWakesUp && wakesUpForTask(task)) {
      // 如果线程由于 IO select 阻塞了，添加的任务的线程需要负责唤醒 NioEventLoop 线程
        wakeup(inEventLoop);
    }
}

在这里插入图片描述

此时会先调用inEventLoop()，判断当前线程是否是eventLoop线程。显然在此时eventLoop线程是null。inEventLoop 如果为 false 表示由其它线程来调用 execute，即首次调用，这时需要向 eventLoop 提交首个任务，启动死循环，会执行到下面的 doStartThread

在这里插入图片描述

进入startThread() 方法，其内部通过状态位控制线程只会启动一次。其内部使用执行器创建一个线程，并将其赋给eventLoop的thread属性，调用外部类 SingleThreadEventExecutor 的 run 方法，进入死循环！

在这里插入图片描述

三、 run() 方法中线程在干嘛？

io.netty.channel.nio.NioEventLoop#run 主要任务是执行死循环，不断看有没有新任务，有没有 IO 事件

protected void run() {
    for (;;) {
        try {
            try {
                // calculateStrategy 的逻辑如下：
                // 有任务，会执行一次 selectNow，清除上一次的 wakeup 结果，无论有没有 IO 事件，都会跳过 switch
                // 没有任务，会匹配 SelectStrategy.SELECT，看是否应当阻塞
                switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                    case SelectStrategy.CONTINUE:
                        continue;

                    case SelectStrategy.BUSY_WAIT:

                    case SelectStrategy.SELECT:
                        // 因为 IO 线程和提交任务线程都有可能执行 wakeup，而 wakeup 属于比较昂贵的操作，因此使用了一个原子布尔对象 wakenUp，它取值为 true 时，表示该由当前线程唤醒
                        // 进行 select 阻塞，并设置唤醒状态为 false
                        boolean oldWakenUp = wakenUp.getAndSet(false);
                        
                        // 如果在这个位置，非 EventLoop 线程抢先将 wakenUp 置为 true，并 wakeup
                        // 下面的 select 方法不会阻塞
                        // 等 runAllTasks 处理完成后，到再循环进来这个阶段新增的任务会不会及时执行呢?
                        // 因为 oldWakenUp 为 true，因此下面的 select 方法就会阻塞，直到超时
                        // 才能执行，让 select 方法无谓阻塞
                        select(oldWakenUp);

                        if (wakenUp.get()) {
                            selector.wakeup();
                        }
                    default:
                }
            } catch (IOException e) {
                rebuildSelector0();
                handleLoopException(e);
                continue;
            }

            cancelledKeys = 0;
            needsToSelectAgain = false;
            // ioRatio 默认是 50
            final int ioRatio = this.ioRatio;
            if (ioRatio == 100) {
                try {
                    processSelectedKeys();
                } finally {
                    // ioRatio 为 100 时，总是运行完所有非 IO 任务
                    runAllTasks();
                }
            } else {                
                final long ioStartTime = System.nanoTime();
                try {
                    processSelectedKeys();
                } finally {
                    // 记录 io 事件处理耗时
                    final long ioTime = System.nanoTime() - ioStartTime;
                    // 运行非 IO 任务，一旦超时会退出 runAllTasks
                    runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
        try {
            if (isShuttingDown()) {
                closeAll();
                if (confirmShutdown()) {
                    return;
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
    }
}

io.netty.channel.DefaultSelectStrategy#calculateStrategy，判断是否有任务，没有任务，返回 SelectStrategy.SELECT，看若有任务则调用selectNow()拿取

@Override
public int calculateStrategy(IntSupplier selectSupplier, boolean hasTasks) throws Exception {
    return hasTasks ? selectSupplier.get() : SelectStrategy.SELECT;
}

private final IntSupplier selectNowSupplier = new IntSupplier() {
    @Override
    public int get() throws Exception {
        return selectNow();
    }
};

接着进入io.netty.channel.nio.NioEventLoop#select 方法

private void select(boolean oldWakenUp) throws IOException {
    Selector selector = this.selector;
    try {
        int selectCnt = 0;
        long currentTimeNanos = System.nanoTime();
        // 计算等待时间,没有 scheduledTask，超时时间为 1s；有 scheduledTask，超时时间为 `下一个定时任务执行时间 - 当前时间`
        long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);

        for (;;) {
            long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;
            // 如果超时，退出循环
            if (timeoutMillis <= 0) {
                if (selectCnt == 0) {
                    selector.selectNow();
                    selectCnt = 1;
                }
                break;
            }

            // 如果期间又有 task 退出循环，如果没这个判断，那么任务就会等到下次 select 超时时才能被执行
            // wakenUp.compareAndSet(false, true) 是让非 NioEventLoop 不必再执行 wakeup
            if (hasTasks() && wakenUp.compareAndSet(false, true)) {
                selector.selectNow();
                selectCnt = 1;
                break;
            }

            // select 有限时阻塞
            // 注意 nio 有 bug，当 bug 出现时，select 方法即使没有时间发生，也不会阻塞住，导致不断空轮询，cpu 占用 100%
            int selectedKeys = selector.select(timeoutMillis);
            // 计数加 1
            selectCnt ++;

            // 醒来后，如果有 IO 事件、或是由非 EventLoop 线程唤醒，或者有任务，退出循环
            if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {
                break;
            }
            if (Thread.interrupted()) {
               	// 线程被打断，退出循环
                // 记录日志
                selectCnt = 1;
                break;
            }

            long time = System.nanoTime();
            if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {
                // 如果超时，计数重置为 1，下次循环就会 break
                selectCnt = 1;
            } 
            // 计数超过阈值，由 io.netty.selectorAutoRebuildThreshold 指定，默认 512
            // 这是为了解决 nio 空轮询 bug
            else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
                    selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
                // 重建 selector
                selector = selectRebuildSelector(selectCnt);
                selectCnt = 1;
                break;
            }

            currentTimeNanos = time;
        }

        if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS) {
            // 记录日志
        }
    } catch (CancelledKeyException e) {
        // 记录日志
    }
}

netty通过轮训执行次数是否到达预值判断是否发生空轮训bug，采用更换 selector 的方式去解决问题！

我们回到io.netty.channel.nio.NioEventLoop#run 方法中，通过以上分析我们知道一般只有在有任务或者有事件的时候才结束阻塞。那会不会出现任务的处理时间过长而耽误事件的处理呢？

					 	// ioRatio 默认是 50
            final int ioRatio = this.ioRatio;
            if (ioRatio == 100) {
                try {
                    processSelectedKeys();
                } finally {
                    // ioRatio 为 100 时，总是运行完所有非 IO 任务
                    runAllTasks();
                }
            } else {                
                final long ioStartTime = System.nanoTime();
                try {
                    processSelectedKeys();
                } finally {
                    // 记录 io 事件处理耗时
                    final long ioTime = System.nanoTime() - ioStartTime;
                    // 运行非 IO 任务，一旦超时会退出 runAllTasks
                    runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                }
            }

ioRatio 参数就是为了控制处理io事件 和 处理任务之间的时间比例！

我们来详细看看处理io事件的 io.netty.channel.nio.NioEventLoop#processSelectedKeys 方法

private void processSelectedKeys() {
    if (selectedKeys != null) {
        // 通过反射将 Selector 实现类中的就绪事件集合替换为 SelectedSelectionKeySet 
        // SelectedSelectionKeySet 底层为数组实现，可以提高遍历性能（原本为 HashSet）
        processSelectedKeysOptimized();
    } else {
        processSelectedKeysPlain(selector.selectedKeys());
    }
}

默认都会进入我们优化后的 io.netty.channel.nio.NioEventLoop#processSelectedKeysOptimized 方法

private void processSelectedKeysOptimized() {
    for (int i = 0; i < selectedKeys.size; ++i) {
        final SelectionKey k = selectedKeys.keys[i];
        // null out entry in the array to allow to have it GC'ed once the Channel close
        // See https://github.com/netty/netty/issues/2363
        selectedKeys.keys[i] = null;
				// 拿到 channel
        final Object a = k.attachment();
        if (a instanceof AbstractNioChannel) {
            processSelectedKey(k, (AbstractNioChannel) a);
        } else {
            @SuppressWarnings("unchecked")
            NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
            processSelectedKey(k, task);
        }

        if (needsToSelectAgain) {
            // null out entries in the array to allow to have it GC'ed once the Channel close
            // See https://github.com/netty/netty/issues/2363
            selectedKeys.reset(i + 1);

            selectAgain();
            i = -1;
        }
    }
}

拿到channel后判断是不是AbstractNioChannel，已知该类是所有Nio channel的父类。如果是则进入方法 io.netty.channel.nio.NioEventLoop#processSelectedKey，区分当前事件处理相关IO事件操作……

private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
    final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
    // 当 key 取消或关闭时会导致这个 key 无效
    if (!k.isValid()) {
        // 无效时处理...
        return;
    }

    try {
        int readyOps = k.readyOps();
        // 连接事件
        if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
            int ops = k.interestOps();
            ops &= ~SelectionKey.OP_CONNECT;
            k.interestOps(ops);

            unsafe.finishConnect();
        }

        // 可写事件
        if ((readyOps & SelectionKey.OP_WRITE) != 0) {
            ch.unsafe().forceFlush();
        }

        // 可读或可接入事件
        if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
            // 如果是可接入 io.netty.channel.nio.AbstractNioMessageChannel.NioMessageUnsafe#read
            // 如果是可读 io.netty.channel.nio.AbstractNioByteChannel.NioByteUnsafe#read
            unsafe.read();
        }
    } catch (CancelledKeyException ignored) {
        unsafe.close(unsafe.voidPromise());
    }
}
HGW689
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
netty+4G DTU
03-08
netty+4G DTU
Netty源码分析：NioEventLoop启动以及其IO操作和Task任务的处理
wojiushimogui的博客
09-26 6946
Netty源码分析：NioEventLoop类的execute、startThread、run方法在上篇博文分析服务端启动的过程中，我们遇到了如下的代码片段， if (eventLoop.inEventLoop()) {//判断当前线程是否为该EventLoop中拥有的线程，如果是，则直接注册，如果不是，则添加一个任务到该线程中 register
Netty in action—EventLoop和线程模型
日积月累，天道酬勤
09-11 486
线程模型概述在本节中，我们将介绍线程模型，然后讨论Netty过去和现在的线程模型，审查每个模型的优点和局限性。 线程模型指定了代码被执行的方式。因为我们一定要防范并发执行可能的副作用,所以了解使用的模型会产生的影响很重要（也有单线程模型）。因为具有多核或CPU的计算机是常见的，有很多应用程序采用复杂的多线程技术来有效利用 系统资源。相比之下，我们在Java早期的应用多线程方法仅仅是创建和启动新的
Netty数据转发工具
04-13
Netty实现端口数据转发：3000进4000出
Netty简介 Netty线程模型和EventLoop Codec编码与解码 ByteBuf容器
08-11
再根据本人实际学习体验总结而成。本部分内容可能不那么全面，但是我尽量挑选Netty中我认为比较重要的部分做讲解。
Netty之EventLoop 解读
一个菜鸡的博客
06-04 1027
定时任务：通过调用 NioEventLoop 的 schedule() 方法向定时任务队列 scheduledTaskQueue 添加一个定时任务，用于周期性执行该任务。例如，心跳消息发送等。NioEventLoop 不仅负责处理 I/O 事件，还要兼顾执行任务队列中的任务。客户端代码不变，启动三次，分别修改发送字符串为 zhangsan（第一次），lisi（第二次），wangwu（第三次）客户端，启动三次，分别修改发送字符串为 zhangsan（第一次），lisi（第二次），wangwu（第三次）
探索Netty的神奇之旅：揭秘EventLoop的异步魔力与高性能网络编程
qq_22037433的博客
08-02 138
EventLoop是一个不断循环执行的线程，它会从事件队列中获取事件并进行处理。每个EventLoop都有一个唯一的ID，用于标识它所属的线程。一个Netty应用通常会有多个EventLoop，它们组成了一个EventLoopGroup。在Netty中，EventLoop是实现异步事件驱动的核心组件，位于io.netty.channel包下。EventLoop的接口定义主要在EventLoop接口中，其主要实现类是SingleThreadEventLoop和NioEventLoop。
Netty inEventLoop方法的思想延伸
qq_44587855的博客
08-09 230
首先来看最常用的场景： NioEventLoop的父类SingleThreadEventExecutor处理刚刚接受的任务时 这里的boolean型 inEventLoop 可能有两种情况为false： NioEventLoop第一次使用，因为它在实例化的过程中是没有初始化 thread这个属性的，所以thread为null，无论和哪个线程比较都不会相等。（因为NioEventLoop它此时还没有创建工作线程） 以下第一次接受任务（向Selector注册Channel的任务），boolean型 ....
Netty源码解析 -- 事件循环机制实现原理
binecy
11-03 347
本文主要分享Netty中事件循环机制的实现。 源码分析基于Netty 4.1 EventLoop 前面分享服务端和客户端启动过程的文章中说过，Netty通过事件循环机制(EventLoop)处理IO事件和异步任务，简单来说，就是通过一个死循环，不断处理当前已发生的IO事件和待处理的异步任务。示例如下 while(true) { process(selector.select()); process(getTask()); } 这种事件循环机制也是一种常用的IO事件处理机制，包括Redis，Mysql
Netty inEventLoop方法？异步回调？Promise？
LeesinDong的个人博客
04-07 7441
文章目录inEventLoop拾遗 inEventLoop 一直对这个方法不是很理解，众所周知是判断当前线程是不是在当前的EventLoop中对应的那个线程？ 一个channel对应一个且只对应一个EventLoop，一个Channel对应一个且只对应一个Pipeline，Pipline中包含handler（也是context），当前的Handler被Channel调用，那什么时候执行这段代码的...
Netty入门教程文档
03-27
Netty入门教程
guang19#framework-learning#Netty线程模型和EventLoop1
07-25
Netty线程模型和EventLoop线程模型概述EventLoop事件循环任务调度JDK任务调度EventLoop任务调度线程管理线程分配非阻塞传输阻塞传输N
netty权威指南 - EventLoop事件循环
qq_42312907的博客
06-21 323
netty作为一个高性能网络框架，基于java线程实现了自己的线程模型，即EventLoop事件循环。 传统线程模型 在传统的java网络编程中，IO逻辑是同步阻塞的。也就是说，每次创建一个socket连接，就会有一个线程与该socket绑定，该线程不会去处理其他socket。如果有100个请求同时到来，会使用100个线程来处理。如果有200个请求同时到来，但是线程池中只有100个线程，那就只会同时处理100个请求，剩下100个请求阻塞在队列中。 在实际的编程开发中，有两个原则： IO性能比计算性能低。按
Netty事件循环--无锁化
ai_xiangjuan的博客
07-22 3258
netty无锁化实现-事件循环机制
netty之eventloop详解
小尘_OnMyWay的博客
04-04 1578
文章目录EventLoop继承关系线程数选择普通任务与定时任务EventLoop分工细化 EventLoop EventLoop本质上是一个单线程执行器(同时维护了一个Selector)，内部有run方法处理Channel上的IO事件。 继承关系 同时继承了ScheduledExecutor定时器，内部包含了线程池的所有方法，进行任务调度；其次继承了OrderedEventExecutor，内部方法能够判断一个线程是否属于当前的EventLoop，并能查看自己属于哪个EventLoopGroup。 事
netty学习1：NioEventLoopGroup 事件循环组源码分析
weixin_45453628的博客
05-18 1249
netty学习1：NioEventLoopGroup 事件循环组源码分析
Netty框架学习之路（五）—— EventLoop及事件循环机制
懋懋之为
03-30 8051
在前面的博文中，我们大致分析了解了Channel及其相关概念。在Netty的线程模型中，每个channel都有唯一的一个eventLoop与之相绑定，那么在这篇博文中我们来看一下EvenLoop及其相关概念。 在传统的Java NIO编程中，我们经常使用到如下代码： public static void main(String[] args) { try { ...
netty5笔记-线程模型4-无锁队列MpscLinkedQueue
youaremoon的专栏
12-18 6290
NioEventLoop里面使用了MpscLinkedQueue作为taskQueue，替换了父类中默认的LinkedBlockingQueue队列。taskQueue主要用于存放可执行任务，其调用的频率非常高，因此使用一个更高效的队列能带来很大的收益。 为什么在NioEvnetLoop里用MpscLinkedQueue替换了LinkedBlockingQueue，是使用了更好的算法？还是通过舍弃
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 387
借助jdeps分析出jar包的增量文件
java EventLoop
06-13
在 Java 中，EventLoop 通常称为事件循环或者消息循环，也是一种常用的异步编程模型。 Java 中常用的事件循环框架有 Netty 和 Vert.x。这些框架都是基于 NIO（非阻塞 I/O）实现的，可以支持高并发的网络编程。 在这些框架中，事件循环主要分为两个部分：事件轮询和事件处理。事件轮询是一个无限循环，不断地检查是否有事件需要处理。如果有事件需要处理，事件循环就会把事件交给事件处理器处理。 事件处理器通常是一个回调函数，用来处理特定的事件。当事件处理器完成事件处理后，它会将结果返回给事件循环。事件循环会等待事件处理器返回结果，然后再继续执行下一个事件。 在 Java 中，事件循环通常是由线程池实现的。线程池中的线程会不断地轮询事件队列，处理事件。当事件处理器完成事件处理后，线程会将结果返回给线程池，然后再继续处理下一个事件。 总之，Java 中的事件循环是一种常用的异步编程模型，可以帮助我们实现高效的网络编程。掌握事件循环的原理和使用方法对于 Java 开发者来说非常重要。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值