org.apache.lucene.index

## Class ConcurrentMergeScheduler

- java.lang.Object
- - org.apache.lucene.index.MergeScheduler
  - - org.apache.lucene.index.ConcurrentMergeScheduler

-     public class ConcurrentMergeScheduler
      extends MergeScheduler

  A `MergeScheduler` that runs each merge using a separate thread, up until a maximum number of threads (`setMaxThreadCount(int)`) at which when a merge is needed, the thread(s) that are updating the index will pause until one or more merges completes. This is a simple way to use concurrency in the indexing process without having to create and manage application level threads.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected class` | `ConcurrentMergeScheduler.MergeThread`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Directory` | `dir`
    `protected int` | `mergeThreadCount`
    `protected java.util.List` | `mergeThreads`
    `protected IndexWriter` | `writer`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ConcurrentMergeScheduler()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static boolean` | `anyUnhandledExceptions()` Used for testing
    `static void` | `clearUnhandledExceptions()`
    `void` | `close()` Close this MergeScheduler.
    `protected void` | `doMerge(MergePolicy.OneMerge merge)` Does the actual merge, by calling `IndexWriter.merge(org.apache.lucene.index.MergePolicy.OneMerge)`
    `int` | `getMaxThreadCount()` Get the max # simultaneous threads that may be running.
    `protected ConcurrentMergeScheduler.MergeThread` | `getMergeThread(IndexWriter writer, MergePolicy.OneMerge merge)` Create and return a new MergeThread
    `int` | `getMergeThreadPriority()` Return the priority that merge threads run at.
    `protected void` | `handleMergeException(java.lang.Throwable exc)` Called when an exception is hit in a background merge thread
    `void` | `merge(IndexWriter writer)` Run the merges provided by `IndexWriter.getNextMerge()`.
    `void` | `setMaxThreadCount(int count)` Sets the max # simultaneous threads that may be running.
    `void` | `setMergeThreadPriority(int pri)` Return the priority that merge threads run at.
    `static void` | `setTestMode()`
    `void` | `sync()`

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

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

- - ### Field Detail

    - #### mergeThreads

          protected java.util.List mergeThreads

    - #### dir

          protected Directory dir

    - #### writer

          protected IndexWriter writer

    - #### mergeThreadCount

          protected int mergeThreadCount

  - ### Constructor Detail

    - #### ConcurrentMergeScheduler

          public ConcurrentMergeScheduler()

  - ### Method Detail

    - #### setMaxThreadCount

          public void setMaxThreadCount(int count)

      Sets the max # simultaneous threads that may be running. If a merge is necessary yet we already have this many threads running, the incoming thread (that is calling add/updateDocument) will block until a merge thread has completed.

    - #### getMaxThreadCount

          public int getMaxThreadCount()

      Get the max # simultaneous threads that may be running. @see #setMaxThreadCount.

    - #### getMergeThreadPriority

          public int getMergeThreadPriority()

      Return the priority that merge threads run at. By default the priority is 1 plus the priority of (ie, slightly higher priority than) the first thread that calls merge.

    - #### setMergeThreadPriority

          public void setMergeThreadPriority(int pri)

      Return the priority that merge threads run at.

    - #### close

          public void close()

      Description copied from class: `MergeScheduler`
      Close this MergeScheduler.

    - #### sync

          public void sync()

    - #### merge

          public void merge(IndexWriter writer)
                     throws CorruptIndexException,
                            java.io.IOException

      Description copied from class: `MergeScheduler`
      Run the merges provided by `IndexWriter.getNextMerge()`.
      Throws:
        `CorruptIndexException`
        `java.io.IOException`

    - #### doMerge

          protected void doMerge(MergePolicy.OneMerge merge)
                          throws java.io.IOException

      Does the actual merge, by calling `IndexWriter.merge(org.apache.lucene.index.MergePolicy.OneMerge)`
      Throws:
        `java.io.IOException`

    - #### getMergeThread

          protected ConcurrentMergeScheduler.MergeThread getMergeThread(IndexWriter writer,
                                                                        MergePolicy.OneMerge merge)
                                                                 throws java.io.IOException

      Create and return a new MergeThread
      Throws:
        `java.io.IOException`

    - #### handleMergeException

          protected void handleMergeException(java.lang.Throwable exc)

      Called when an exception is hit in a background merge thread

    - #### anyUnhandledExceptions

          public static boolean anyUnhandledExceptions()

      Used for testing

    - #### clearUnhandledExceptions

          public static void clearUnhandledExceptions()

    - #### setTestMode

          public static void setTestMode()

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