HBase-split

最新推荐文章于 2023-07-21 16:09:34 发布
最新推荐文章于 2023-07-21 16:09:34 发布
阅读量1.3k 收藏
点赞数
分类专栏： # HBase基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Gloria_y/article/details/60470718
版权

HBase-split代码分析

相关类：

  • SplitRequest : 具体执行split过程的类
  • CompactSplitThread ： compact split 线程控制
  • MemStoreFlusher : flush memstore 实现
  • RSRpcServices : regionserver RPC实现类
  • TableLock : 是TableLockManager中的一个接口，实现类：ZKTableLockManager
  • IncreasingToUpperBoundRegionSplitPolicy：默认的split策略

hbase-split代码01

触发split的情况

  • HBaseAdmin : HBaseAdmin.split
  • compact : CompactSplitThread.CompactRunner
  • memstore flush : FlushHandler.java

这里写图片描述

  1. compact 触发 split：
    CompactionRunner.run()中：
    public void run() {
      //....一些条件判断
      if (this.compaction == null) {
        .....
      // Finally we can compact something.
      assert this.compaction != null;

      ...
      try {
        ...
        boolean completed = region.compact(compaction, store);
        ...
        if (completed) {
          // degenerate case: blocked regions require recursive enqueues
          if (store.getCompactPriority() <= 0) {
            requestSystemCompaction(region, store, "Recursive enqueue");
          } else {
            // see if the compaction has caused us to exceed max region size
            //*********如果超过最大的region大小******
            requestSplit(region);
          }
        }
      } catch (IOException ex) {
       ...
        }
        server.checkFileSystem();
      } catch (Exception ex) {
        ...
      } finally {
        LOG...
      }
      this.compaction.getRequest().afterExecute();//一个空的方法
    }

上面的：store.getCompactPriority() <= 0 是什么意思？？

我们来看一下HStore.java中 getCompactPriority()

@Override
  public int getCompactPriority() {

    // 从StoreFileManager中获取Compact Priority
    int priority = this.storeEngine.getStoreFileManager().getStoreCompactionPriority();
    if (priority == PRIORITY_USER) {
      LOG.warn("Compaction priority is USER despite there being no user compaction");
    }
    return priority;
  }

它转而从StoreFileManager中获取Compact Priority，继续吧！在StoreFileManager的默认实现DefaultStoreFileManager中，代码如下：

@Override
  public int getStoreCompactionPriority() {
    isTooManyStoreFiles:MemStore在进行flush时会判断HRegion上每个HStore下的文件数是否太多，太多则意味着MemStore的flush会被推迟进行，优先进行compact，否则文件数则会越来越多，而这里，离blockingFileCount越远，当前文件数越小的话，则意味着MemStore的flush可以优先进行，而compact可以在它flush之后再进行，将资源利用效率最大化
    // BLOCKING_STOREFILES_KEY = "hbase.hstore.blockingStoreFiles"
    // HStore.DEFAULT_BLOCKING_STOREFILE_COUNT = 7  为什么为7？？？
    int blockingFileCount = conf.getInt(
        HStore.BLOCKING_STOREFILES_KEY, HStore.DEFAULT_BLOCKING_STOREFILE_COUNT);

    // 优先级为上述blockingFileCount减去当前storefiles的数目
    int priority = blockingFileCount - storefiles.size();

    // 如果priority为1，则返回2，否则返回原值
    return (priority == HStore.PRIORITY_USER) ? priority + 1 : priority;
  }
回到 store.getCompactPriority() <= 0 这个问题

如果 store.getCompactPriority() <= 0 则 blockingFileCount（=7） - storefiles.size() <= 0
说明 storefiles.size() >=7
然后执行 requestSystemCompaction(region, store, “Recursive enqueue”);
这个里面又是需要执行CompactionRunner

requestSplit

好了，相当于 storefiles.size() < 7 的话
CompactionRunner.run()中执行requestSplit()
这个方法是CompactSplitThread中的requestSplit()

  public synchronized boolean requestSplit(final HRegion r) {
    // 1.shouldSplitRegion()  判断当前RS上region数量是否大于系统设置
    // 2.r.getCompactPriority() >= 1
    if (shouldSplitRegion() && r.getCompactPriority() >= Store.PRIORITY_USER) {
      byte[] midKey = r.checkSplit();
      if (midKey != null) {
        requestSplit(r, midKey);
        return true;
      }
    }
    return false;
  }

看一下shouldSplitRegion()方法里面做了什么判断？

  private boolean shouldSplitRegion() {
 //this.regionSplitLimit=conf.getInt(
//REGION_SERVER_REGION_SPLIT_LIMIT,
//DEFAULT_REGION_SERVER_REGION_SPLIT_LIMIT);   默认为1000
    if(server.getNumberOfOnlineRegions() > 0.9*regionSplitLimit) {
    //如果当前regionserver上的region数 > 900 打印WARN LOG
      LOG.warn("Total number of regions is approaching the upper limit " + regionSplitLimit + ". "
          + "Please consider taking a look at http://hbase.apache.org/book.html#ops.regionmgt");
    }
    // regionSplitLimit 大于 当前RS的online region数则返回true
    return (regionSplitLimit > server.getNumberOfOnlineRegions());
  }

region在RS上的数量和compact优先级都判断完了
下面执行HRegion checkSplit()

  /**
   * Return the splitpoint. null indicates the region isn't splittable
   * If the splitpoint isn't explicitly specified, it will go over the stores
   * to find the best splitpoint. Currently the criteria of best splitpoint
   * is based on the size of the store.
   * 返回split point。null 表示不能被split。
   * 如果split point 没有指定。则会根据stores寻找最佳split point 。最佳split point基于store的size
   */
  public byte[] checkSplit() {
    // META表和NAMESPACE元数据表不能被split

    // recovering（恢复中）状态的表不能被split

    //splitPolicy（split策略）默认为IncreasingToUpperBoundRegionSplitPolicy
    if (!splitPolicy.shouldSplit()) {
      return null;
    }

//获取具体的split point
    byte[] ret = splitPolicy.getSplitPoint();

    if (ret != null) {
      try {
      //判断row是否在这个region当中
        checkRow(ret, "calculated split");
      } catch (IOException e) {
        LOG.error("Ignoring invalid split", e);
        return null;
      }
    }
    return ret;
  }

默认splitPolicy为：
IncreasingToUpperBoundRegionSplitPolicy
看一下它里面的shouldSplit()方法

  @Override
  protected boolean shouldSplit() {
    if (region.shouldForceSplit()) return true;
    boolean foundABigStore = false;
    // Get count of regions that have the same common table as this.region
    // table的region数量
    int tableRegionsCount = getCountOfCommonTableRegions();
    // Get size to check
    // 获取根据hbase.hregion.max.filesize和region数量以及hbase.hregion.memstore.flush.size计算的CheckSize
    long sizeToCheck = getSizeToCheck(tableRegionsCount);


    //循环遍历region下面所有store
    for (Store store : region.getStores().values()) {
      // 如果有的region不能被split，比如有的region包含引用文件，则返回false
      if ((!store.canSplit())) {
        return false;
      }

      // Mark if any store is big enough
      long size = store.getSize();
      //如果store大于check size，设置foundABigStore为true
      if (size > sizeToCheck) {
        LOG.debug("ShouldSplit because " + store.getColumnFamilyName() +
          " size=" + size + ", sizeToCheck=" + sizeToCheck +
          ", regionsWithCommonTable=" + tableRegionsCount);
        foundABigStore = true;
      }
    }

    return foundABigStore;
  }

IncreasingToUpperBoundRegionSplitPolicy getSizeToCheck()


  /**
   * @return Region max size or <code>count of regions squared * flushsize, which ever is
   * smaller; guard against there being zero regions on this server.
   */
  protected long getSizeToCheck(final int tableRegionsCount) {
    // safety check for 100 to avoid numerical overflow in extreme cases
    //如果 region数=0或者>100 返回 hbase.hregion.max.filesize 值
    //否则 在 max_filesize和 之间选择一个小的值 128M * regionCt * regionCt * regionCt
    initialSize= table属性里设置的MEMSTORE_FLUSHSIZE，或者默认为hbase.hregion.memstore.flush.size(默认128M)
    return tableRegionsCount == 0 || tableRegionsCount > 100 ? getDesiredMaxFileSize():
      Math.min(getDesiredMaxFileSize(),
        this.initialSize * tableRegionsCount * tableRegionsCount * tableRegionsCount);
  }

getDesiredMaxFileSize()方法：
返回IncreasingToUpperBoundRegionSplitPolicy继承的ConstantSizeRegionSplitPolicy类的desiredMaxFileSize值.（hbase.hregion.max.filesize）

desiredMaxFileSize的赋值过程:

  @Override
  protected void configureForRegion(HRegion region) {
    super.configureForRegion(region);
    Configuration conf = getConf();
    HTableDescriptor desc = region.getTableDesc();
    if (desc != null) {
    //如果table设置了MAX_FILESIZE属性，则返回这个属性的值，否则返回-1
      this.desiredMaxFileSize = desc.getMaxFileSize();
    }
    //如果 desc.getMaxFileSize()返回 < 0 的值
    //则获取hbase.hregion.max.filesize属性值，或者默认值：10 * 1024 * 1024 * 1024L=10G
    if (this.desiredMaxFileSize <= 0) {
      this.desiredMaxFileSize = conf.getLong(HConstants.HREGION_MAX_FILESIZE,
        HConstants.DEFAULT_MAX_FILE_SIZE);
    }
  }

上面根据IncreasingToUpperBoundRegionSplitPolicy的shouldSplit()方法判断了：
region数量与max filesize 以及 当前region的store中是否包含引用文件等

下面我们继续看HRegion checkSplit()后面执行了什么:
splitPolicy.getSplitPoint()

IncreasingToUpperBoundRegionSplitPolicy getSplitPoint()

//IncreasingToUpperBoundRegionSplitPolicy getSplitPoint()

经过上面的各种check和get mid ，现在终于要执行requestSplit了
CompactSplitThread requestSplit()

  public synchronized void requestSplit(final HRegion r, byte[] midKey) {
...
//this.splits  线程池，默认线程数为1
      this.splits.execute(new SplitRequest(r, midKey, this.server));
 ...
  }

看看SplitRequest的run()方法吧

  @Override
  public void run() {
   //判断server是否停止服务
    //split metric + 1 
    long startTime = EnvironmentEdgeManager.currentTime();
    SplitTransaction st = new SplitTransaction(parent, midKey);
    try {

      //获取table的读锁TableLock类型
        tableLock.acquire();
      } catch (IOException ex) {
        tableLock = null;
        throw ex;
      }

      // If prepare does not return true, for some reason -- logged inside in
      // the prepare call -- we are not ready to split just now. Just return.
      //st.prepare()也是比较重要的一步
      if (!st.prepare()) return;
      try {
        st.execute(this.server, this.server);
        success = true;
      } catch (Exception e) {
        ...
        try {
          //split失败，进行回滚操作
          if (st.rollback(this.server, this.server)) {
           ...
          } else {
           ...
          }
        } catch (RuntimeException ee) {
          ...
          this.server.abort(msg + " -- Cause: " + ee.getMessage());
        }
        return;
      }
    } catch (IOException ex) {
      ...
      server.checkFileSystem();
    } finally {
      //Coprocessor  postCompleteSplit
      if (parent.shouldForceSplit()) {
        parent.clearSplit();
      }
      //释放TableLock
      releaseTableLock();
      // Split succ LOG
    }//end finally
  }

先看一下prepare():
new了A,B两个HRegionInfo


  /**
   * Does checks on split inputs.
   * @return <code>true</code> if the region is splittable else
   * <code>false</code> if it is not (e.g. its already closed, etc.).
   */
  public boolean prepare() {
    //parent region如果不能被split，则直接return false
    //mid不能为null
    HRegionInfo hri = this.parent.getRegionInfo();
    parent.prepareToSplit();
    // Check splitrow.
    byte [] startKey = hri.getStartKey();
    byte [] endKey = hri.getEndKey();
    if (Bytes.equals(startKey, splitrow) ||
        !this.parent.getRegionInfo().containsRow(splitrow)) {
      LOG.info("Split row is not inside region key range or is equal to " +
          "startkey: " + Bytes.toStringBinary(this.splitrow));
      return false;
    }

    //构造regionId，如果构造的regionId小于parent regionId，则自动加1（保证在meta表中的顺序）
    long rid = getDaughterRegionIdTimestamp(hri);

    //创建A,B两个子region
    this.hri_a = new HRegionInfo(hri.getTable(), startKey, this.splitrow, false, rid);
    this.hri_b = new HRegionInfo(hri.getTable(), this.splitrow, endKey, false, rid);
    this.journal.add(new JournalEntry(JournalEntryType.PREPARED));
    return true;
  }

看看executor

  /**
   * Run the transaction.
   * @param server Hosting server instance.  Can be null when testing
   * @param services Used to online/offline regions.
   * @throws IOException If thrown, transaction failed.
   *          Call {@link #rollback(Server, RegionServerServices)}
   * @return Regions created
   * @throws IOException
   * @see #rollback(Server, RegionServerServices)
   */
  public PairOfSameType<HRegion> execute(final Server server,
      final RegionServerServices services)
  throws IOException {
    useZKForAssignment = server == null ? true :
      ConfigUtil.useZKForAssignment(server.getConfiguration());
    if (useCoordinatedStateManager(server)) {//状态判断
      std =
          ((BaseCoordinatedStateManager) server.getCoordinatedStateManager())
              .getSplitTransactionCoordination().getDefaultDetails();
    }
    PairOfSameType<HRegion> regions = createDaughters(server, services);
    if (this.parent.getCoprocessorHost() != null) {
      this.parent.getCoprocessorHost().preSplitAfterPONR();
    }
    return stepsAfterPONR(server, services, regions);
  }

createDaughters()负责 下线parent region 上线子region


  /**
   * 准备region和region files
   * 参数：services 用来上下线region
   * 返回的是创建的region
   */
  /* package */PairOfSameType<HRegion> createDaughters(final Server server,
      final RegionServerServices services) throws IOException {
    LOG.info("Starting split of region " + this.parent);
    if ((server != null && server.isStopped()) ||
        (services != null && services.isStopping())) {
      throw new IOException("Server is stopped or stopping");
    }
    assert !this.parent.lock.writeLock().isHeldByCurrentThread():
      "Unsafe to hold write lock while performing RPCs";

    journal.add(new JournalEntry(JournalEntryType.BEFORE_PRE_SPLIT_HOOK));

    // Coprocessor callback
    if (this.parent.getCoprocessorHost() != null) {
      // TODO: Remove one of these
      this.parent.getCoprocessorHost().preSplit();
      this.parent.getCoprocessorHost().preSplit(this.splitrow);
    }

    journal.add(new JournalEntry(JournalEntryType.AFTER_PRE_SPLIT_HOOK));

    // If true, no cluster to write meta edits to or to update znodes in.
    boolean testing = server == null? true:
        server.getConfiguration().getBoolean("hbase.testing.nocluster", false);
    this.fileSplitTimeout = testing ? this.fileSplitTimeout :
        server.getConfiguration().getLong("hbase.regionserver.fileSplitTimeout",
          this.fileSplitTimeout);

    PairOfSameType<HRegion> daughterRegions = stepsBeforePONR(server, services, testing);

    List<Mutation> metaEntries = new ArrayList<Mutation>();
    if (this.parent.getCoprocessorHost() != null) {
      if (this.parent.getCoprocessorHost().
          preSplitBeforePONR(this.splitrow, metaEntries)) {
        throw new IOException("Coprocessor bypassing region "
            + this.parent.getRegionNameAsString() + " split.");
      }
      try {
        for (Mutation p : metaEntries) {
          HRegionInfo.parseRegionName(p.getRow());
        }
      } catch (IOException e) {
        LOG.error("Row key of mutation from coprossor is not parsable as region name."
            + "Mutations from coprocessor should only for hbase:meta table.");
        throw e;
      }
    }

    // This is the point of no return.  Adding subsequent edits to .META. as we
    // do below when we do the daughter opens adding each to .META. can fail in
    // various interesting ways the most interesting of which is a timeout
    // BUT the edits all go through (See HBASE-3872).  IF we reach the PONR
    // then subsequent failures need to crash out this regionserver; the
    // server shutdown processing should be able to fix-up the incomplete split.
    // The offlined parent will have the daughters as extra columns.  If
    // we leave the daughter regions in place and do not remove them when we
    // crash out, then they will have their references to the parent in place
    // still and the server shutdown fixup of .META. will point to these
    // regions.
    // We should add PONR JournalEntry before offlineParentInMeta,so even if
    // OfflineParentInMeta timeout,this will cause regionserver exit,and then
    // master ServerShutdownHandler will fix daughter & avoid data loss. (See
    // HBase-4562).
    this.journal.add(new JournalEntry(JournalEntryType.PONR));

    // Edit parent in meta.  Offlines parent region and adds splita and splitb
    // as an atomic update. See HBASE-7721. This update to META makes the region
    // will determine whether the region is split or not in case of failures.
    // If it is successful, master will roll-forward, if not, master will rollback
    // and assign the parent region.

     //不是测试模式******************
    if (!testing && useZKForAssignment) {
      if (metaEntries == null || metaEntries.isEmpty()) {
        MetaTableAccessor.splitRegion(server.getConnection(),
          parent.getRegionInfo(), daughterRegions.getFirst().getRegionInfo(),
          daughterRegions.getSecond().getRegionInfo(), server.getServerName(),
          parent.getTableDesc().getRegionReplication());
      } else {
      //元数据的变化  下线parent，并且更新新的region信息
        offlineParentInMetaAndputMetaEntries(server.getConnection(),
          parent.getRegionInfo(), daughterRegions.getFirst().getRegionInfo(), daughterRegions
              .getSecond().getRegionInfo(), server.getServerName(), metaEntries,
              parent.getTableDesc().getRegionReplication());
      }
    } else if (services != null && !useZKForAssignment) {
      if (!services.reportRegionStateTransition(TransitionCode.SPLIT_PONR,
          parent.getRegionInfo(), hri_a, hri_b)) {
        // Passed PONR, let SSH clean it up
        throw new IOException("Failed to notify master that split passed PONR: "
          + parent.getRegionInfo().getRegionNameAsString());
      }
    }
    return daughterRegions;
  }

executor的最后
stepsAfterPONR(server, services, regions) open新region，修改zookeeper里面的信息

/hbase/region-in-transition

hbase 之 split
牧童的专栏
02-18 722
首先split的触发条件是：
HBase Split
liushaobo的专栏
08-04 7400
HBase表的结构如下： 每个Table由若干个Region组成，每个Region由若干个Store组成(每个列组构成一个Store)，每个由一个MemStore和若干个StoreFiles(HFiles)组成，每个StoreFile由若干个Blocks组成。HBase对表进行split有三种方式：Pre-splitting，Auto splitting，Forced Splits。Pre-s
Hbase split的三种方式和split的过程
weixin_34326558的博客
12-31 531
在Hbase中split是一个很重要的功能，Hbase是通过把数据分配到一定数量的region来达到负载均衡的。一个table会被分配到一个或多个region中，这些region会被分配到一个或者多个regionServer中。在自动split策略中，当一个region达到一定的大小就会自动split成两个region。table在region中是按照row key来排序的，并且一个row key...
hbase split操作
那又怎样？的博客
11-07 4444
转载来自：https://zhuanlan.zhihu.com/p/39648692 HBase - 解析split操作 split操作：意义 HBase数据写入首先会写入缓存，缓存写满会执行一次flush操作，每次flush都会生成一个HFile文件。随着HFile的增多，文件的读取效率势必会降低，HBase采用compact机制不断的对这些文件进行合并，将小文件合并成大文件。然而，对HBa...
Hbase split Region
最新发布
myself_ning的博客
07-21 897
region split是hbases水平扩展一个重要因素。随着数据的不断写入，将一个region切分为两个小region，并将切分后的region放在不同的节点上，以达到将负载进行均衡到其他节点。 随着数据不断插入表，region不断增大，当增大到一个阀值的时候，region就会等分会 两个新的region（裂变）；
hbase region split
weixin_34137799的博客
06-29 176
2019独角兽企业重金招聘Python工程师标准>>> ...
hbase split
mnasd的博客
06-21 1227
Region Split Region大小超过阀值(可以是hbase.hregion.max.filesize也可以是建表时列族配置的大小)后会触发Split，由RegionServer负责来拆分region并且offline下线该region。随后将两个子region添加到hbase:meta并在RegionServer上打开后汇报给HMaster。默认情况下Region会自动触发split,同时也可以手动运行split命令。 Region Split可以手动split也可以自动split(建议),其中
最新版linux hbase-2.3.3-bin.tar.gz
11-05
例如，RegionSplitPolicy优化了区域分裂策略，以提高负载均衡；而Cell级别的ACL增强了数据安全性。 总结来说，Linux上的HBase 2.3.3是一个强大的大数据存储解决方案，尤其适用于需要实时查询和处理大规模数据的应用...
hbase-1.2.0-cdh5.14.0.tar.gz
03-14
用户可以通过设置HBase的Compaction和Split策略来优化数据存储和检索效率。此外，还可以利用BlockCache和MemStore来提高读取性能。 12. **监控和管理** CDH提供了一套全面的管理和监控工具，如Cloudera Manager，...
HBase的split分析
PunC的专栏
07-31 1918
HBase在新建一个表的时候，默认会把所有数据都会放在一个HRegion上，主节点HMaster根据一定的策略把HRegion分配到不同的HRegionServer从节点上，客户端在进行读写操作的时候，就会访问对应HRegionServer的HRegion。当HRegion的数据量超过阀值的时候，为了防止单个热点访问带来的压力，HBase就会对HRegion进行split操作，一个父HRegion
HBase Split 过程
anhuidelinger的专栏
06-07 6569
看了下hbase split的代码 记录一下学习心得  Java代码   private void split(final HRegion parent, final byte [] midKey)   throws IOException {       final long startTime = System.currentTimeMillis();
HBase的Region Split详解
qq_42456324的博客
12-09 1192
region split是hbases随着数据的不断写入，将一个region切分为两个小region，并将切分后的，以达到将到其他节点。
HBase Split分析
dcswin的博客
08-27 5511
本人结合HBase的源代码，对HBase的Split流程做了整体的分析，并结合实际的操作列出了一些注意的点，望能给对HBase感兴趣的人提供一定的帮助。
Hbase Split 解析
Kuzury
07-04 3856
HBase Split是hbase根据一定的触发条件和一定的分裂策略将HBase的一个region进行分裂成两个子region并对父region进行清除处理的过程。Region是HBase中一个非常核心的组织单元，所有的region组成了整个HBase集群，如下面的HBase的体系结构所示：在HBase中，split其实是进行sharding的一种技术手段，通过HBase的split条件和split
hbase-2.0.0.3.0.0.0-1634-bin.tar.gz
08-21
2. Region管理：HBase的Region是数据分区的基本单位，你可以通过Ambari监控Region分布，进行手动Split或Merge操作。 3. 性能调优：通过调整HBase的配置参数，如MemStore大小、BlockCache设置等，可以优化读写性能。...
HBase region split 过程
sysocc的博客
05-19 818
由于写请求是由regionserver处理的，它们会存储在被称作memstore的内存存储系统中。一旦memstore填满，它的内容就会被写到磁盘上，作为额外的存储文件。这个事件被称为memstore的flush。随着存储文件的累积，regionserver将把它们compact成更少，更大的文件。每次flush或compact完成后，该region内存储的数据量就发生了变化。regionserver咨询region split策略，以确定该region是否增长过大，或者是否应该因另一个特定split po
hbase分析之split策略
u012447842的博客
12-24 1763
目录 RegionSplitPolicy IncreasingToUpperBoundRegionSplitPolicy策略： SteppingSplitPolicy策略： ConstantSizeRegionSplitPolicy策略： KeyPrefixRegionSplitPolicy策略： DelimitedKeyPrefixRegionSplitPolicy策略： Busy...
HBase 分裂（split）
weixin_30278311的博客
09-14 493
1. 为什么split 最初一个Table 只有一个region（因此只能存放在一个region server上）。随着数据的不断写入，HRegion越来越大，当到达一定程度后分裂为两个，通过负载均衡可以将不同的region分配到不同的region server上，发挥分布式系统的优点。 注意：compact的对象是针对某几个storefile，但是split的对象是整...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值
>