Module org.apache.lucene.monitor

Package org.apache.lucene.monitor

Class ConcurrentQueryLoader

java.lang.Object

org.apache.lucene.monitor.ConcurrentQueryLoader

All Implemented Interfaces:

Closeable, AutoCloseable

public class ConcurrentQueryLoader
extends Object
implements Closeable

Utility class for concurrently loading queries into a Monitor.

This is useful to speed up startup times for a Monitor. You can use multiple threads to parse and index queries before starting matches.

Use as follows:

     List<QueryError> errors = new ArrayList<>();
     try (ConcurrentQueryLoader loader = new ConcurrentQueryLoader(monitor, errors)) {
         for (MonitorQuery mq : getQueries()) {
             loader.add(mq);
         }
     }
 

The Monitor's MonitorQueryParser must be thread-safe for this to work correctly.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private class	ConcurrentQueryLoader.Worker

Field Summary

Fields

Modifier and Type	Field	Description
static final int	DEFAULT_QUEUE_SIZE
private List<IOException>	errors
private final ExecutorService	executor
private final Monitor	monitor
private final BlockingQueue<MonitorQuery>	queue
private boolean	shutdown
private final CountDownLatch	shutdownLatch

Constructor Summary

Constructors

Constructor	Description
ConcurrentQueryLoader(Monitor monitor)	Create a new ConcurrentQueryLoader for a Monitor
ConcurrentQueryLoader(Monitor monitor, int threads, int queueSize)	Create a new ConcurrentQueryLoader

Method Summary

Modifier and Type	Method	Description
void	add(MonitorQuery mq)	Add a MonitorQuery to the loader's internal buffer
void	close()
private static <E> int	drain(BlockingQueue<E> q, Collection<? super E> buffer, int numElements, long timeout, TimeUnit unit)	Drains the queue as BlockingQueue.drainTo(Collection, int), but if the requested numElements elements are not available, it will wait for them up to the specified timeout.

Methods inherited from class java.lang.Object

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

Field Details

monitor

private final Monitor monitor

executor

private final ExecutorService executor

shutdownLatch

private final CountDownLatch shutdownLatch

queue

private final BlockingQueue<MonitorQuery> queue

shutdown

private boolean shutdown

errors

private List<IOException> errors

DEFAULT_QUEUE_SIZE

public static final int DEFAULT_QUEUE_SIZE

See Also:

• Constant Field Values

Constructor Details

ConcurrentQueryLoader

public ConcurrentQueryLoader(Monitor monitor)

Create a new ConcurrentQueryLoader for a Monitor

Parameters:

monitor - Monitor

ConcurrentQueryLoader

public ConcurrentQueryLoader(Monitor monitor,
 int threads,
 int queueSize)

Create a new ConcurrentQueryLoader

Parameters:

monitor - the Monitor to load queries to

threads - the number of threads to use

queueSize - the size of the buffer to hold queries in

Method Details

add

public void add(MonitorQuery mq)
         throws InterruptedException

Add a MonitorQuery to the loader's internal buffer

If the buffer is full, this will block until there is room to add the MonitorQuery

Parameters:

mq - the monitor query

Throws:

InterruptedException - if interrupted while waiting

close

public void close()
           throws IOException

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Closeable

Throws:

IOException

drain

private static <E> int drain(BlockingQueue<E> q,
 Collection<? super E> buffer,
 int numElements,
 long timeout,
 TimeUnit unit)
                      throws InterruptedException

Drains the queue as BlockingQueue.drainTo(Collection, int), but if the requested numElements elements are not available, it will wait for them up to the specified timeout.

Taken from Google Guava 18.0 Queues

Type Parameters:

E - the type of the queue

Parameters:

q - the blocking queue to be drained

buffer - where to add the transferred elements

numElements - the number of elements to be waited for

timeout - how long to wait before giving up, in units of unit

unit - a TimeUnit determining how to interpret the timeout parameter

Returns:

the number of elements transferred

Throws:

InterruptedException - if interrupted while waiting