public List<KeyValueScanner> getScanners(boolean cacheBlocks, boolean usePread,
  boolean isCompaction, ScanQueryMatcher matcher, byte[] startRow, boolean includeStartRow,
  byte[] stopRow, boolean includeStopRow, long readPt, boolean onlyLatestVersion)
  throws IOException {
  Collection<HStoreFile> storeFilesToScan;
  List<KeyValueScanner> memStoreScanners;
  this.storeEngine.readLock();
  try {
    storeFilesToScan = this.storeEngine.getStoreFileManager().getFilesForScan(startRow,
      includeStartRow, stopRow, includeStopRow, onlyLatestVersion);
    memStoreScanners = this.memstore.getScanners(readPt);
    // NOTE: here we must increase the refCount for storeFiles because we would open the
    // storeFiles and get the StoreFileScanners for them.If we don't increase the refCount here,
    // HStore.closeAndArchiveCompactedFiles called by CompactedHFilesDischarger may archive the
    // storeFiles after a concurrent compaction.Because HStore.requestCompaction is under
    // storeEngine lock, so here we increase the refCount under storeEngine lock. see HBASE-27484
    // for more details.
    HStoreFile.increaseStoreFilesRefeCount(storeFilesToScan);
  } finally {
    this.storeEngine.readUnlock();
  }
  try {
    // First the store file scanners

    // TODO this used to get the store files in descending order,
    // but now we get them in ascending order, which I think is
    // actually more correct, since memstore get put at the end.
    List<StoreFileScanner> sfScanners = StoreFileScanner.getScannersForStoreFiles(
      storeFilesToScan, cacheBlocks, usePread, isCompaction, false, matcher, readPt);
    List<KeyValueScanner> scanners = new ArrayList<>(sfScanners.size() + 1);
    scanners.addAll(sfScanners);
    // Then the memstore scanners
    scanners.addAll(memStoreScanners);
    return scanners;
  } catch (Throwable t) {
    clearAndClose(memStoreScanners);
    throw t instanceof IOException ? (IOException) t : new IOException(t);
  } finally {
    HStoreFile.decreaseStoreFilesRefeCount(storeFilesToScan);
  }
}

@RestrictedApi(explanation = "Should only be called in TestHStore", link = "",
    allowedOnPath = ".*/(HStore|TestHStore).java")
void replaceStoreFiles(Collection<HStoreFile> compactedFiles, Collection<HStoreFile> result,
  boolean writeCompactionMarker) throws IOException {
  storeEngine.replaceStoreFiles(compactedFiles, result, () -> {
    if (writeCompactionMarker) {
      writeCompactionWalRecord(compactedFiles, result);
    }
  }, () -> {
    synchronized (filesCompacting) {
      filesCompacting.removeAll(compactedFiles);
    }
  });
  // These may be null when the RS is shutting down. The space quota Chores will fix the Region
  // sizes later so it's not super-critical if we miss these.
  RegionServerServices rsServices = region.getRegionServerServices();
  if (rsServices != null && rsServices.getRegionServerSpaceQuotaManager() != null) {
    updateSpaceQuotaAfterFileReplacement(
      rsServices.getRegionServerSpaceQuotaManager().getRegionSizeStore(), getRegionInfo(),
      compactedFiles, result);
  }
}

public void replaceStoreFiles(Collection<HStoreFile> compactedFiles,
  Collection<HStoreFile> newFiles, IOExceptionRunnable walMarkerWriter, Runnable actionUnderLock)
  throws IOException {
  storeFileTracker.replace(StoreUtils.toStoreFileInfo(compactedFiles),
    StoreUtils.toStoreFileInfo(newFiles));
  walMarkerWriter.run();
  writeLock();
  try {
    storeFileManager.addCompactionResults(compactedFiles, newFiles);
    actionUnderLock.run();
  } finally {
    writeUnlock();
  }
}

  /**
   * Add the store files to store file manager, and also record it in the store file tracker.
   * <p/>
   * The {@code actionAfterAdding} will be executed after the insertion to store file manager, under
   * the lock protection. Usually this is for clear the memstore snapshot.
   */
  public void addStoreFiles(Collection<HStoreFile> storeFiles,
    IOExceptionRunnable actionAfterAdding) throws IOException {
    storeFileTracker.add(StoreUtils.toStoreFileInfo(storeFiles));
    writeLock();
    try {
      storeFileManager.insertNewFiles(storeFiles);
      actionAfterAdding.run();
    } finally {
      // We need the lock, as long as we are updating the storeFiles
      // or changing the memstore. Let us release it before calling
      // notifyChangeReadersObservers. See HBASE-4485 for a possible
      // deadlock scenario that could have happened if continue to hold
      // the lock.
      writeUnlock();
    }
  }

// CompactionChecker 定期检查实现
private static class CompactionChecker extends ScheduledChore {
  private final HRegionServer instance;
  
  @Override
  protected void chore() {
    for (HRegion hr : this.instance.onlineRegions.values()) {
      if (hr == null || hr.isReadOnly() || !hr.getTableDescriptor().isCompactionEnabled()) {
        continue;
      }

      for (HStore s : hr.stores.values()) {
        if (s.needsCompaction()) {  // 检查 compaction 必要性
          this.instance.compactSplitThread.requestSystemCompaction(
            hr, s, "Periodic compaction"  // 提交系统级 compaction 请求
          );
        }
      }
    }
  }
}