org.apache.lucene.monitor

## Class ParallelMatcher<T extends QueryMatch>

- java.lang.Object
- - org.apache.lucene.monitor.CandidateMatcher<T>
  - - org.apache.lucene.monitor.ParallelMatcher<T>

- Type Parameters:
    `T` - the QueryMatch type returned

      public class ParallelMatcher<T extends QueryMatch>
      extends CandidateMatcher<T>

  Matcher class that runs matching queries in parallel.

  This class delegates the actual matching to separate CandidateMatcher classes, built from a passed in MatcherFactory.

  Use this when individual queries can take a long time to run, and you want to minimize latency. The matcher distributes queries amongst its worker threads using a BlockingQueue, and synchronization overhead may affect performance if the individual queries are very fast.

  See Also:
    `PartitionMatcher`

- - ### Field Summary

    - ### Fields inherited from class org.apache.lucene.monitor.CandidateMatcher

      `searcher`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `doFinish()` Called when all monitoring of a batch of documents is complete
    `static <T extends QueryMatch> MatcherFactory<T>` | `factory(ExecutorService executor, MatcherFactory<T> matcherFactory)` Create a new MatcherFactory for a ParallelMatcher
    `static <T extends QueryMatch> MatcherFactory<T>` | `factory(ExecutorService executor, MatcherFactory<T> matcherFactory, int threads)` Create a new MatcherFactory for a ParallelMatcher
    `protected void` | `matchQuery(String queryId, Query matchQuery, Map<String,String> metadata)` Runs the supplied query against this CandidateMatcher's set of documents, storing any resulting match, and recording the query in the presearcher hits
    `T` | `resolve(T match1, T match2)` If two matches from the same query are found (for example, two branches of a disjunction), combine them.

    - ### Methods inherited from class org.apache.lucene.monitor.CandidateMatcher

      `addMatch, copyMatches`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### matchQuery

          protected void matchQuery(String queryId,
                                    Query matchQuery,
                                    Map<String,String> metadata)
                             throws IOException

      Description copied from class: `CandidateMatcher`
      Runs the supplied query against this CandidateMatcher's set of documents, storing any resulting match, and recording the query in the presearcher hits
      Specified by:
        `matchQuery` in class `CandidateMatcher<T extends QueryMatch>`
      Parameters:
        `queryId` - the query id
        `matchQuery` - the query to run
        `metadata` - the query metadata
      Throws:
        `IOException` - on IO errors

    - #### resolve

          public T resolve(T match1,
                           T match2)

      Description copied from class: `CandidateMatcher`
      If two matches from the same query are found (for example, two branches of a disjunction), combine them.
      Specified by:
        `resolve` in class `CandidateMatcher<T extends QueryMatch>`
      Parameters:
        `match1` - the first match found
        `match2` - the second match found
      Returns:
        a Match object that combines the two

    - #### doFinish

          protected void doFinish()

      Description copied from class: `CandidateMatcher`
      Called when all monitoring of a batch of documents is complete
      Overrides:
        `doFinish` in class `CandidateMatcher<T extends QueryMatch>`

    - #### factory

          public static <T extends QueryMatch> MatcherFactory<T> factory(ExecutorService executor,
                                                                         MatcherFactory<T> matcherFactory,
                                                                         int threads)

      Create a new MatcherFactory for a ParallelMatcher
      Type Parameters:
        `T` - the type of QueryMatch generated
      Parameters:
        `executor` - the ExecutorService to use
        `matcherFactory` - the MatcherFactory to use to create submatchers
        `threads` - the number of threads to use

    - #### factory

          public static <T extends QueryMatch> MatcherFactory<T> factory(ExecutorService executor,
                                                                         MatcherFactory<T> matcherFactory)

      Create a new MatcherFactory for a ParallelMatcher

      This factory will create a ParallelMatcher that uses as many threads as there are cores available to the JVM (as determined by `Runtime.getRuntime().availableProcessors()`).

      Type Parameters:
        `T` - the type of QueryMatch generated
      Parameters:
        `executor` - the ExecutorService to use
        `matcherFactory` - the MatcherFactory to use to create submatchers

Copyright © 2000-2019 Apache Software Foundation. All Rights Reserved.