// k は kNNの k, IndexSearcher は名前のまんま
KnnCollectorManager knnCollectorManager = getKnnCollectorManager(k, indexSearcher);
// TaskExecutor は平行実行を担当する
TaskExecutor taskExecutor = indexSearcher.getTaskExecutor();
// LeafReaderContext はセグメントレベルで検索を効率的に実行可能なコンポーネント
List<LeafReaderContext> leafReaderContexts = reader.leaves();
List<Callable<TopDocs>> tasks = new ArrayList<>(leafReaderContexts.size());
for (LeafReaderContext context : leafReaderContexts) {

  tasks.add(() -> searchLeaf(context, filterWeight, knnCollectorManager));
}

protected KnnCollectorManager getKnnCollectorManager(int k, IndexSearcher searcher) {
  return new TopKnnCollectorManager(k, searcher);
}

public class TopKnnCollectorManager implements KnnCollectorManager {

  // 何個のドキュメントを収集するか
  private final int k;
  // すべてのセグメントを跨いで収集されたトップスコアを追跡するために使用される、グローバルスコアキュー
  private final BlockingFloatHeap globalScoreQueue;

  public TopKnnCollectorManager(int k, IndexSearcher indexSearcher) {
	  // 複数のセグメントが存在するかを確認
	  // ここでやっと理解したが、 leaves って segment を指している模様... (segment は index の leaves と考えられるから? )
    boolean isMultiSegments = indexSearcher.getIndexReader().leaves().size() > 1;
    this.k = k;
    // 複数のセグメントがあった場合に、k要素を持つBlockingFloatHeapインスタンスを初期化してglobalScoreQueueに割り当てる。そうでなければ、globalScoreQueueをnullに設定
    this.globalScoreQueue = isMultiSegments ? new BlockingFloatHeap(k) : null;
  @Override
  public KnnCollector newCollector(int visitedLimit, LeafReaderContext context) throws IOException {
	 // 単一セグメントの場合
    if (globalScoreQueue == null) {
      return new TopKnnCollector(k, visitedLimit);
    // 複数セグメントの場合
    } else {
	   // 複数セグメントを並行検索する MultiLeafKnnCollector を利用する
      return new MultiLeafKnnCollector(k, globalScoreQueue, new TopKnnCollector(k, visitedLimit));
    }
  }
}

public final class MultiLeafKnnCollector implements KnnCollector {

  //  [0,1] の範囲で探索の貪欲度を制御する定数。値が1に近づくほど、より多くの最高類似度を局所的に保持しようとする。
  private static final float DEFAULT_GREEDINESS = 0.9f;
  // 全てのセグメントを通じて収集された最高の類似度スコアを保持するグローバルなキュー。
  private final BlockingFloatHeap globalSimilarityQueue;

  // そのセグメントがグローバルレベルで競争力を持たない場合に、最高の類似度（類似性スコア）をローカルに蓄積するためのキュー
  private final FloatHeap nonCompetitiveQueue;
  // 初期値DEFAULT_GREEDINESSを使用する探索の貪欲度
  private final float greediness;
  // 定期的にグローバルキューに更新る局所的な類似度スコアを保持するキュー
  private final FloatHeap updatesQueue;
  // 局所的なキューとグローバルなキューを同期するための訪問されたベクターの数の間隔
  private final int interval = 0xff; // 255
  private boolean kResultsCollected = false;
  private float cachedGlobalMinSim = Float.NEGATIVE_INFINITY;
  // サブコレクター、つまり局所的な収集を行う抽象的なコレクター実装
  private final AbstractKnnCollector subCollector;

  /**
   * Create a new MultiLeafKnnCollector.   *   * @param k 収集する近似近傍探索の結果数
   * @param globalSimilarityQueue 全セグメントで収集された最高類似度スコアのグローバルキュー
  * @param subCollector 局所的な収集を行うためのサブコレクター
   */  public MultiLeafKnnCollector(
      int k, BlockingFloatHeap globalSimilarityQueue, AbstractKnnCollector subCollector) {
    this.greediness = DEFAULT_GREEDINESS;
    this.subCollector = subCollector;
    this.globalSimilarityQueue = globalSimilarityQueue;
	 // 例えば、`k`が10で、`greediness`が0.9（90%の貪欲度）の場合、`(1 - 0.9) * 10` に基づいてこのキューのサイズは `1`（最小でも1）となります。これは、セグメントがグローバルに競争力がない場合にも、少なくとも1つの最高類似度スコアをローカルに保持することを保証します。
    this.nonCompetitiveQueue = new FloatHeap(Math.max(1, Math.round((1 - greediness) * k)));
    this.updatesQueue = new FloatHeap(k);
  }

  @Override
  public boolean earlyTerminated() {
    return subCollector.earlyTerminated();
  }

  @Override
  public void incVisitedCount(int count) {
    subCollector.incVisitedCount(count);
  }

  @Override
  public long visitedCount() {
    return subCollector.visitedCount();
  }

  @Override
  public long visitLimit() {
    return subCollector.visitLimit();
  }

  @Override
  public int k() {
    return subCollector.k();
  }

  @Override
  // 与えられた document id と類似度スコアから、サブコレクターとローカル、グローバルキューにそれを追加する
  public boolean collect(int docId, float similarity) {
	 // localSimUpdated は ローカルで類似度の更新があったかどうかのフラグ
    boolean localSimUpdated = subCollector.collect(docId, similarity);
    // 最初にk結果が全部集まった瞬間かどうかを判断する。
    boolean firstKResultsCollected =
        (kResultsCollected == false && subCollector.numCollected() == k());
    // この瞬間に一度だけkResultsCollectedをtrueに設定する。
    if (firstKResultsCollected) {
      kResultsCollected = true;
    }
    updatesQueue.offer(similarity);
    // グローバルレベルで更新が生じたかどうかを判定するフラグ
    boolean globalSimUpdated = nonCompetitiveQueue.offer(similarity);

    if (kResultsCollected) {
      // もしk件の結果が既に集まっていれば、与えられた間隔（interval）ごとに、updatesQueueの内容をglobalSimilarityQueueに送り、キャッシュされたグローバル最小類似度(cachedGlobalMinSim)を更新し、updatesQueueをクリアする。
      if (firstKResultsCollected || (subCollector.visitedCount() & interval) == 0) {
        cachedGlobalMinSim = globalSimilarityQueue.offer(updatesQueue.getHeap());
        updatesQueue.clear();
        globalSimUpdated = true;
      }
    }
    // ローカルまたはグローバルキュのどちらかが更新された場合にtrueを返す。つまり、呼び出し元はさらなる探索を適切に調整できるようになる。
    return localSimUpdated || globalSimUpdated;
  }

  @Override
  // 競争力のある最小類似度（つまり、これより低い類似度のドキュメントは考慮しない基準類似度）を返す
  public float minCompetitiveSimilarity() {
    if (kResultsCollected == false) {
	    // k件の結果が集まっていない場合、Float.NEGATIVE_INFINITYを返すことで、現存するすべての類似度が競争力を持っているとみなす
      return Float.NEGATIVE_INFINITY;
    }
    // k件集まっている場合、サブコレクターの競争力のある最小類似度と`nonCompetitiveQueue`の最高類似度（または`cachedGlobalMinSim`）を比較して大きい方を返す。これにより、ローカルとグローバルの両方のコンテキストでの最小限の競争力のある類似度が確定される。
    return Math.max(
        subCollector.minCompetitiveSimilarity(),
        Math.min(nonCompetitiveQueue.peek(), cachedGlobalMinSim));
  }

  ...
}