谈谈如何实现工程公平_谈谈dubbo负载均衡是如何实现的？

最新推荐文章于 2024-07-13 16:15:00 发布
最新推荐文章于 2024-07-13 16:15:00 发布
阅读量77 收藏
点赞数
文章标签： 谈谈如何实现工程公平
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33178459/article/details/113370153
版权
866913b28167d4c84a48dd62b867d787.png

dubbo的负载均衡全部由AbstractLoadBalance的子类来实现

RandomLoadBalance 随机

在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

  1. 获取invoker的数量
  2. 获取第一个invoker的权重，并复制给firstWeight
  3. 循环invoker集合，把它们的权重全部相加，并复制给totalWeight，如果权重不相等，那么sameWeight为false
  4. 如果invoker集合的权重并不是全部相等的，那么获取一个随机数在1到totalWeight之间，赋值给offset属性
  5. 循环遍历invoker集合，获取权重并与offset相减，当offset减到小于零，那么就返回这个inovker
  6. 如果权重相等，那么直接在invoker集合里面取一个随机数返回
 @Override protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) { int length = invokers.size(); // Number of invokers boolean sameWeight = true; // Every invoker has the same weight? int firstWeight = getWeight(invokers.get(0), invocation); int totalWeight = firstWeight; // The sum of weights for (int i = 1; i < length; i++) { int weight = getWeight(invokers.get(i), invocation); totalWeight += weight; // Sum if (sameWeight && weight != firstWeight) { sameWeight = false; } } if (totalWeight > 0 && !sameWeight) { // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight. int offset = ThreadLocalRandom.current().nextInt(totalWeight); // Return a invoker based on the random value. for (int i = 0; i < length; i++) { offset -= getWeight(invokers.get(i), invocation); if (offset < 0) { return invokers.get(i); } } } // If all invokers have the same weight value or totalWeight=0, return evenly. return invokers.get(ThreadLocalRandom.current().nextInt(length)); }

RoundRobinLoadBalance 轮询

存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

在老的版本上，dubbo会求出最大权重和最小权重，如果权重相等，那么就直接按取模的方式，每次取完后值加一；如果权重不相等，顺序根据权重分配。

在新的版本上，对这个类进行了重构。

  1. 从methodWeightMap这个实例中根据ServiceKey+MethodName的方式获取里面的一个map实例，如果没有则说明第一次进到该方法，则实例化一个放入到methodWeightMap中，并把获取到的实例命名为map
  2. 遍历所有的invokers
  3. 拿到当前的invoker的identifyString作为key，去map里获取weightedRoundRobin实例，如果map里没有则添加一个
  4. 如果weightedRoundRobin的权重和当前invoker的权重不同，说明权重变了，需要重新设置
  5. 获取当前invoker所对应的weightedRoundRobin实例中的current，并加上当前invoker的权重
  6. 设置weightedRoundRobin最后的更新时间
  7. maxCurrent一开始是设置的0，如果当前的weightedRoundRobin的current值大于maxCurrent则进行赋值
  8. 遍历完后会得到最大的权重的invoker的selectedInvoker和这个invoker所对应的weightedRoundRobin赋值给了selectedWRR，还有权重之和totalWeight
  9. 然后把selectedWRR里的current属性减去totalWeight，并返回selectedInvoker

这样看显然是不够清晰的，我们来举个例子：

假定有3台dubbo provider:10.0.0.1:20884, weight=210.0.0.1:20886, weight=310.0.0.1:20888, weight=4totalWeight=9;那么第一次调用的时候：10.0.0.1:20884, weight=2 selectedWRR -> current = 210.0.0.1:20886, weight=3 selectedWRR -> current = 310.0.0.1:20888, weight=4 selectedWRR -> current = 4 selectedInvoker-> 10.0.0.1:20888 调用 selectedWRR.sel(totalWeight); 10.0.0.1:20888, weight=4 selectedWRR -> current = -5返回10.0.0.1:20888这个实例那么第二次调用的时候：10.0.0.1:20884, weight=2 selectedWRR -> current = 410.0.0.1:20886, weight=3 selectedWRR -> current = 610.0.0.1:20888, weight=4 selectedWRR -> current = -1selectedInvoker-> 10.0.0.1:20886 调用 selectedWRR.sel(totalWeight); 10.0.0.1:20886 , weight=4 selectedWRR -> current = -3返回10.0.0.1:20886这个实例那么第三次调用的时候：10.0.0.1:20884, weight=2 selectedWRR -> current = 610.0.0.1:20886, weight=3 selectedWRR -> current = 010.0.0.1:20888, weight=4 selectedWRR -> current = 3selectedInvoker-> 10.0.0.1:20884调用 selectedWRR.sel(totalWeight); 10.0.0.1:20884, weight=2 selectedWRR -> current = -3返回10.0.0.1:20884这个实例 protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) { String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName(); ConcurrentMap map = methodWeightMap.get(key); if (map == null) { methodWeightMap.putIfAbsent(key, new ConcurrentHashMap()); map = methodWeightMap.get(key); } int totalWeight = 0; long maxCurrent = Long.MIN_VALUE; long now = System.currentTimeMillis(); Invoker selectedInvoker = null; WeightedRoundRobin selectedWRR = null; for (Invoker invoker : invokers) { String identifyString = invoker.getUrl().toIdentityString(); WeightedRoundRobin weightedRoundRobin = map.get(identifyString); int weight = getWeight(invoker, invocation); if (weight < 0) { weight = 0; } if (weightedRoundRobin == null) { weightedRoundRobin = new WeightedRoundRobin(); weightedRoundRobin.setWeight(weight); map.putIfAbsent(identifyString, weightedRoundRobin); weightedRoundRobin = map.get(identifyString); } if (weight != weightedRoundRobin.getWeight()) { //weight changed weightedRoundRobin.setWeight(weight); } long cur = weightedRoundRobin.increaseCurrent(); weightedRoundRobin.setLastUpdate(now); if (cur > maxCurrent) { maxCurrent = cur; selectedInvoker = invoker; selectedWRR = weightedRoundRobin; } totalWeight += weight; } if (!updateLock.get() && invokers.size() != map.size()) { if (updateLock.compareAndSet(false, true)) { try { // copy -> modify -> update reference ConcurrentMap newMap = new ConcurrentHashMap(); newMap.putAll(map); Iterator> it = newMap.entrySet().iterator(); while (it.hasNext()) { Entry item = it.next(); if (now - item.getValue().getLastUpdate() > RECYCLE_PERIOD) { it.remove(); } } methodWeightMap.put(key, newMap); } finally { updateLock.set(false); } } } if (selectedInvoker != null) { selectedWRR.sel(totalWeight); return selectedInvoker; } // should not happen here return invokers.get(0); }

LeastActiveLoadBalance 最少活跃调用数

使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

  1. 遍历所有的invoker
  2. 获取当前invoker的活跃数，调用的是RpcStatus的getStatus方法，过滤器里面会记录每个方法的活跃数
  3. 获取当前invoker的权重
  4. 如果是第一次进来或者是当前invoker的活跃数比最小的活跃数还小
  5. 那么把leastActive设置为当前invoker的活跃数，设置leastCount为1，leastIndexes数组的第一个位置设置为1，记录一下totalWeight和firstWeight
  6. 如果不满足第4点的条件，那么判断当前invoker的活跃数和最小的活跃数是否相等
  7. 如果满足第6点，那么把当前的权重加入到totalWeight中，并把leastIndexes数组中记录一下最小活跃数相同的下标；再看一下是否所有的权重相同
  8. 如果invoker集合中只有一个invoker活跃数是最小的，那么直接返回
  9. 如果权重不相等，随机权重后，判断在哪个 Invoker 的权重区间中
  10. 权重相等，直接随机选择 Invoker 即可
最小活跃数算法实现：假定有3台dubbo provider:10.0.0.1:20884, weight=2，active=210.0.0.1:20886, weight=3，active=410.0.0.1:20888, weight=4，active=3active=2最小，且只有一个2，所以选择10.0.0.1:20884假定有3台dubbo provider:10.0.0.1:20884, weight=2，active=210.0.0.1:20886, weight=3，active=210.0.0.1:20888, weight=4，active=3active=2最小，且有2个，所以从[10.0.0.1:20884,10.0.0.1:20886 ]中选择；接下来的算法与随机算法类似：假设offset=1(即random.nextInt(5)=1)1-2=-1<0？是，所以选中 10.0.0.1:20884, weight=2假设offset=4(即random.nextInt(5)=4)4-2=2<0？否，这时候offset=2， 2-3<0？是，所以选中 10.0.0.1:20886, weight=3 1: public class LeastActiveLoadBalance extends AbstractLoadBalance { 2:  3: public static final String NAME = "leastactive"; 4:  5: private final Random random = new Random(); 6:  7: @Override 8: protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) { 9: int length = invokers.size(); // 总个数10: int leastActive = -1; // 最小的活跃数11: int leastCount = 0; // 相同最小活跃数的个数12: int[] leastIndexes = new int[length]; // 相同最小活跃数的下标13: int totalWeight = 0; // 总权重14: int firstWeight = 0; // 第一个权重，用于于计算是否相同15: boolean sameWeight = true; // 是否所有权重相同16: // 计算获得相同最小活跃数的数组和个数17: for (int i = 0; i < length; i++) {18: Invoker invoker = invokers.get(i);19: int active = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive(); // 活跃数20: int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.WEIGHT_KEY, Constants.DEFAULT_WEIGHT); // 权重21: if (leastActive == -1 || active < leastActive) { // 发现更小的活跃数，重新开始22: leastActive = active; // 记录最小活跃数23: leastCount = 1; // 重新统计相同最小活跃数的个数24: leastIndexes[0] = i; // 重新记录最小活跃数下标25: totalWeight = weight; // 重新累计总权重26: firstWeight = weight; // 记录第一个权重27: sameWeight = true; // 还原权重相同标识28: } else if (active == leastActive) { // 累计相同最小的活跃数29: leastIndexes[leastCount++] = i; // 累计相同最小活跃数下标30: totalWeight += weight; // 累计总权重31: // 判断所有权重是否一样32: if (sameWeight && weight != firstWeight) {33: sameWeight = false;34: }35: }36: }37: // assert(leastCount > 0)38: if (leastCount == 1) {39: // 如果只有一个最小则直接返回40: return invokers.get(leastIndexes[0]);41: }42: if (!sameWeight && totalWeight > 0) {43: // 如果权重不相同且权重大于0则按总权重数随机44: int offsetWeight = random.nextInt(totalWeight);45: // 并确定随机值落在哪个片断上46: for (int i = 0; i < leastCount; i++) {47: int leastIndex = leastIndexes[i];48: offsetWeight -= getWeight(invokers.get(leastIndex), invocation);49: if (offsetWeight <= 0) {50: return invokers.get(leastIndex);51: }52: }53: }54: // 如果权重相同或权重为0则均等随机55: return invokers.get(leastIndexes[random.nextInt(leastCount)]);56: }57: 58: }

ConsistentHashLoadBalance 一致性 Hash

相同参数的请求总是发到同一提供者。当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。

  1. 基于 invokers 集合，根据对象内存地址来计算定义哈希值
  2. 获得 ConsistentHashSelector 对象。若为空，或者定义哈希值变更(说明 invokers 集合发生变化)，进行创建新的 ConsistentHashSelector 对象
  3. 调用ConsistentHashSelector对象的select方法
 1: public class ConsistentHashLoadBalance extends AbstractLoadBalance { 2:  3: /** 4: * 服务方法与一致性哈希选择器的映射 5: * 6: * KEY：serviceKey + "." + methodName 7: */ 8: private final ConcurrentMap> selectors = new ConcurrentHashMap>(); 9: 10: @SuppressWarnings("unchecked")11: @Override12: protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {13: String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();14: // 基于 invokers 集合，根据对象内存地址来计算定义哈希值15: int identityHashCode = System.identityHashCode(invokers);16: // 获得 ConsistentHashSelector 对象。若为空，或者定义哈希值变更(说明 invokers 集合发生变化)，进行创建新的 ConsistentHashSelector 对象17: ConsistentHashSelector selector = (ConsistentHashSelector) selectors.get(key);18: if (selector == null || selector.identityHashCode != identityHashCode) {19: selectors.put(key, new ConsistentHashSelector(invokers, invocation.getMethodName(), identityHashCode));20: selector = (ConsistentHashSelector) selectors.get(key);21: }22: return selector.select(invocation);23: }24: }

ConsistentHashSelector 一致性哈希选择器

ConsistentHashSelector ，是 ConsistentHashLoadBalance 的内部类，一致性哈希选择器，基于 Ketama 算法。

/** * 虚拟节点与 Invoker 的映射关系 */private final TreeMap> virtualInvokers;/** * 每个Invoker 对应的虚拟节点数 */private final int replicaNumber;/** * 定义哈希值 */private final int identityHashCode;/** * 取值参数位置数组 */private final int[] argumentIndex; 1: ConsistentHashSelector(List> invokers, String methodName, int identityHashCode) { 2: this.virtualInvokers = new TreeMap>(); 3: // 设置 identityHashCode 4: this.identityHashCode = identityHashCode; 5: URL url = invokers.get(0).getUrl(); 6: // 初始化 replicaNumber 7: this.replicaNumber = url.getMethodParameter(methodName, "hash.nodes
张小庑
关注
Davids原理探究：Dubbo负载均衡实现原理
Davids_的博客
06-15 4255
Dubbo负载均衡实现原理 RandomRobin 随机负载均衡（default） RoundRobin 轮询负载均衡 普通轮询/平滑轮询算法（Nginx中有使用） LeastActive 最少活跃调用数负载均衡 越慢的服务越少调用，活跃计数差（调用前计数器+1，调用后计数器-1，如果一个服务提供者计数差很大，则说明该服务处理的比较慢，则减少请求量，防止服务客户端阻塞，以及服务端崩溃。） 一致性Hash负载均衡 默认根据只对第一个参数hash，可以通过<dubbo:parameter key="has
实现自己的大厂梦，毕业一年半拿遍所有大厂offer，怎么做到的？
程序媛小琬的博客
08-26 483
很多同学会问Java面试八股文有必要背吗？ 答案是，必须背，我的好多同学凭借八股文斩获了多个大厂暑期实习offer，相信一定也可以发挥重要作用。
Dubbo 负载均衡的实现
YANGTAO_0的博客
05-10 372
前言 负载均衡是指在集群中，将多个数据请求分散在不同单元上进行执行，主要为了提高系统容错能力和加强系统对数据的处理能力。 在 Dubbo 中，一次服务的调用就是对所有实体域 Invoker 的一次筛选过滤，最终选定具体调用的 Invoker。首先在 Directory 中获取全部 Invoker 列表，通过路由筛选出符合规则的 Invoker，最后再经过负载均衡选出具体的 Invoker。所以 Dubbo 负载均衡机制是决定一次服务调用使用哪个提供者的服务。 整体结构 Dubbo 负载均衡的分析入口是.
Dubbo 负载均衡（Load Balance）
最新发布
FireFox1997
07-13 1002
随机负载均衡策略是通过随机算法从服务提供者列表中选取一个节点进行调用。每次请求到达时，系统都会随机选择一个服务节点，无需考虑之前的请求情况。轮询负载均衡策略是按照固定的顺序依次轮流选择服务节点进行调用。每次请求到达时，系统选择下一个节点，当到达列表末尾时重新从头开始。一致性哈希负载均衡策略通过哈希算法将请求映射到固定的服务节点，确保相同参数的请求始终由同一个服务节点处理。此策略特别适用于需要会话粘性或数据分片的场景。Dubbo 提供了多种负载均衡策略，帮助开发者根据不同的业务场景选择合适的方案。
dubbo负载均衡是如何实现的？
weixin_30708329的博客
06-02 124
dubbo的负载均衡全部由AbstractLoadBalance的子类来实现 RandomLoadBalance 随机 在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。 获取invoker的数量 获取第一个invoker的权重，并复制给firstWeight 循环invoker集合，把它们的权重全部相加，并复制给totalWeight...
njx如何实现负载均衡_面试题：说一说Dubbo负载均衡的具体实现？
weixin_39522698的博客
12-03 81
# 前言负载均衡是指在集群中，将多个数据请求分散在不同单元上进行执行，主要为了提高系统容错能力和加强系统对数据的处理能力。在 Dubbo 中，一次服务的调用就是对所有实体域 Invoker 的一次筛选过滤，最终选定具体调用的 Invoker。首先在 Directory 中获取全部 Invoker 列表，通过路由筛选出符合规则的 Invoker，最后再经过负载均衡选出具体的 Invoker...
java实现动画的代码
m0_57064331的博客
06-19 260
前言 大家在面试的时候不同程度会被问到JVM的垃圾回收，看面试官水平，有些就背个书就行，比如GC的工作原理，有哪些GC算法和回收器，分别优点和缺点等等，有些面试官估计自己也就背书水平，都没个追问；有些面试官就能追问，一追问就歇菜，比如低延迟的垃圾回收器有哪些以及其原理，跨代引用及解决方案，三色标记及漏标问题处理，等等。 还是那句话，虽然都是些理论的问题，但是在实际开发过程中真的能遇到这些问题来解决实际问题，所以多多了解JVM的实现原理总没有错，既能抗极限面试，又能在适时的时候帮忙解决实际问题，得到领导和.
Java中高级面试题总览(一)
热门推荐
击水三千里的专栏
03-29 2万+
高频面试题深入剖析
「java工程师」常见面试题及其答案(持续更新)
datoujing2019的博客
01-28 1317
java工程师常见面试题，redis，mysql，面向对象，索引，hashmap，线程池，JVM，消息队列，缓存，分布式，ZK，dubbo，加密
整理了3家面试问题：美团+字节+腾讯，个个三面，你认为你能走到哪一面？
weixin_47345084的博客
02-19 267
2020年，莫名的感觉自己度过了最艰难而又漫长的一年！炒鱿鱼，跳槽不顺，就像家常便饭一样。2020也是迄今为止我投简历最多的一年了，天天面试天天挂，要多糟心有多糟心…不过我始终坚信，机会永远是留给坚持不懈与努力的人的，所以很庆幸，我抓住了2020年的年尾吧，上岸了腾讯！ 回顾这一年，我的付出终归是没有白费的！很快，今天又是2021年02月19号了，激烈的金三银四已经没有多少日子就有上场了！所以今天，我挑选了“美团+字节+腾讯”等三家的一二三面问题，在此篇文章里做一个分享，希望看到的朋友可以做一个面试参考，并
Dubbo源码学习--集群负载均衡算法的实现
weixin_30522095的博客
02-05 111
相关文章： Dubbo源码学习文章目录 前言 Dubbo 的定位是分布式服务框架，为了避免单点压力过大，服务的提供者通常部署多台，如何从服务提供者集群中选取一个进行调用，就依赖于Dubbo的负载均衡策略。 Dubbo 负载均衡策略 Dubbo 负载均衡策略提供下列四种方式： Random LoadBalance 随机，按权重设置随机概率。 Dubbo的默认负载均衡策略 在一个截面上碰撞的概率高，...
Dubbo的负载均衡LoadBalance的源码分析和如何实现负载均衡
之城的专栏
08-05 648
五种负载均衡策略 Dubbo 最新的源码中可以看到提供了以下五种策略： RandomLoadBalance： 随机访问策略 LeastActiveLoadBalance： 最少访问策略 ConsistentHashLoadBalance： 一致性hash访问策略 RoundRobinLoadBalance： 轮流访问策略 ShortestResponseLoadBalance：最快响应策略（就是调用响应最快的服务提供者） LoadBalance 接口 这五个策略都实现了实现了AbstractLoadBa
Dubbo（三）：负载均衡实现解析
AI乔治
01-04 874
dubbo作为分布式远程调用框架，要保证的点很多，比如：服务注册与发现、故障转移、高性能通信、负载均衡等等！ 　　负载均衡的目的是为了特定场景下，能够将请求合理地平分到各服务实例上，以便发挥所有机器的叠加作用。主要考虑的点如：不要分配请求到挂掉的机器，性能越好的机器可以分配更多的请求。。。 　　一般负载均衡是借助外部工具，硬件负载均衡或软件负载均衡，如F5/nginx。当然了，在当前分布式环境遍地开花的情况下，客户端的负载均衡看起来就更轻量级，显得不可或缺。 　　今天我们就来看看dubbo是如何进行负
Dubbo——负载均衡的实现
吴声子夜歌的博客
07-02 1876
负载均衡的实现 在整个集群容错流程中，首先经过Directory获取所有Invoker列表，然后经过Router根据路由规则过滤Invoker，最后幸存下来的Invoker还需要经过负载均衡这一关，选出最终要调用的Invoker。 包装后的负载均衡 所有的容错策略中的负载均衡都使用了抽象父类AbstractClusterInvoker中定义的Invoker <T> select方法，而并不是直接使用LoadBalance方法。因为抽象父类在LoadBalance的基础上有封装了一些新的特性：
Dubbo-负载均衡原理解析
张姐姐聊编程
12-29 961
我们的程序是分布式应用，服务部署在几个节点（服务器）上，当消费者调用服务时，zk返回给dubbo的是一个节点列表，但是dubbo只会选择一台服务器，那么它究竟会选择哪一台呢？这就是dubbo的负载均衡策略了，本篇博客就来聚焦dubbo的负载均衡策略。
Dubbo——负载均衡(LoadBalance)原理
庄小焱
04-01 3894
摘要 当一台服务器的承受能力达到上限时，那么就需要多台服务器来组成集群，提升应用整体的吞吐量，那么这个时候就涉及到如何合理分配客户端请求到集群中不同的机器，这个过程就叫做负载均衡。LoadBalance 中文意思为负载均衡，它的职责是将网络请求，或者其他形式的负载“均摊”到不同的机器上。避免集群中部分服务器压力过大，而另一些服务器比较空闲的情况。通过负载均衡，可以让每台服务器获取到适合自己处理能力的负载。在为高负载服务器分流的同时，还可以避免资源浪费，一举两得。负载均衡可分为软件负载均衡和硬件负载均衡
dubbo负载均衡。
IT从业者
05-19 791
1.搭建zookeeper集群，搭建过程参考网上资料（地址为192.168.200.141：2182,192.168.200.141:2183,192.168.200.141:2184）。 2.搭建dubbo服务生产者和消费者项目工程，github地址：https://github.com/kickTec/dubboDemo，详细过程请参考https://www.cnblogs.com/hd...
【Dubbo】Dubbo负载均衡实现解析
小明的Java问道之路
11-19 1180
本文讲解了Dubbo负载均衡的作用，如何配置Dubbo负载均衡策略，以及Dubbo提供5种负载均衡实现和原理。
Dubbo负载均衡策略与注解详解
"Dubbo是一种高性能、轻量级的开源Java RPC框架，它提供了丰富的负载均衡策略，包括随机、轮询、最少活跃调用数和一致性哈希等。这些策略有助于在分布式环境中优化服务调用的分布，提高系统的稳定性和响应速度。此外...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值