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
`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