Package org.apache.lucene.monitor

Class PartitionMatcher<T extends QueryMatch>

java.lang.Object

org.apache.lucene.monitor.CandidateMatcher<T>

org.apache.lucene.monitor.PartitionMatcher<T>

Type Parameters:

T - the type of QueryMatch to return

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

A multi-threaded matcher that collects all possible matches in one pass, and then partitions them amongst a number of worker threads to perform the actual matching.

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

Use this if your query sets contain large numbers of very fast queries, where the synchronization overhead of ParallelMatcher can outweigh the benefit of multithreading.

See Also:

ParallelMatcher

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private class	PartitionMatcher.MatcherWorker
private static class	PartitionMatcher.MatchTask
private static class	PartitionMatcher.PartitionMatcherFactory<T extends QueryMatch>

Field Summary

Fields

Modifier and Type	Field	Description
private java.util.concurrent.ExecutorService	executor
private MatcherFactory<T>	matcherFactory
private CandidateMatcher<T>	resolvingMatcher
private java.util.List<PartitionMatcher.MatchTask>	tasks
private int	threads

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

searcher

Constructor Summary

Constructors

Modifier	Constructor	Description
private	PartitionMatcher(IndexSearcher searcher, java.util.concurrent.ExecutorService executor, MatcherFactory<T> matcherFactory, int threads)

Method Summary

Modifier and Type	Method	Description
protected void	doFinish()	Called when all monitoring of a batch of documents is complete
static <T extends QueryMatch> MatcherFactory<T>	factory(java.util.concurrent.ExecutorService executor, MatcherFactory<T> matcherFactory)	Create a new MatcherFactory for a PartitionMatcher
static <T extends QueryMatch> MatcherFactory<T>	factory(java.util.concurrent.ExecutorService executor, MatcherFactory<T> matcherFactory, int threads)	Create a new MatcherFactory for a PartitionMatcher
protected void	matchQuery(java.lang.String queryId, Query matchQuery, java.util.Map<java.lang.String,java.lang.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
(package private) static <T> java.util.List<java.util.List<T>>	partition(java.util.List<T> items, int slices)
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, finish, reportError

Methods inherited from class java.lang.Object

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

Field Detail

executor

private final java.util.concurrent.ExecutorService executor

matcherFactory

private final MatcherFactory<T extends QueryMatch> matcherFactory

threads

private final int threads

resolvingMatcher

private final CandidateMatcher<T extends QueryMatch> resolvingMatcher

tasks

private final java.util.List<PartitionMatcher.MatchTask> tasks

Constructor Detail

PartitionMatcher

private PartitionMatcher(IndexSearcher searcher,
                         java.util.concurrent.ExecutorService executor,
                         MatcherFactory<T> matcherFactory,
                         int threads)

Method Detail

matchQuery

protected void matchQuery(java.lang.String queryId,
                          Query matchQuery,
                          java.util.Map<java.lang.String,java.lang.String> metadata)

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

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(java.util.concurrent.ExecutorService executor,
                                                               MatcherFactory<T> matcherFactory,
                                                               int threads)

Create a new MatcherFactory for a PartitionMatcher

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(java.util.concurrent.ExecutorService executor,
                                                               MatcherFactory<T> matcherFactory)

Create a new MatcherFactory for a PartitionMatcher

This factory will create a PartitionMatcher 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

partition

static <T> java.util.List<java.util.List<T>> partition(java.util.List<T> items,
                                                       int slices)