org.optaplanner.core.impl.heuristic.thread

## Class OrderByMoveIndexBlockingQueue<Solution_>

- java.lang.Object
- - org.optaplanner.core.impl.heuristic.thread.OrderByMoveIndexBlockingQueue<Solution_>

-     public class OrderByMoveIndexBlockingQueue<Solution_>
      extends Object

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `OrderByMoveIndexBlockingQueue.MoveResult<Solution_>`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `OrderByMoveIndexBlockingQueue(int capacity)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addExceptionThrown(int moveThreadIndex, Throwable throwable)` This method is thread-safe.
    `void` | `addMove(int moveThreadIndex, int stepIndex, int moveIndex, Move<Solution_> move, Score score)` This method is thread-safe.
    `void` | `addUndoableMove(int moveThreadIndex, int stepIndex, int moveIndex, Move<Solution_> move)` This method is thread-safe.
    `void` | `startNextStep(int stepIndex)` Not thread-safe.
    `OrderByMoveIndexBlockingQueue.MoveResult<Solution_>` | `take()` Not thread-safe.

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

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

- - ### Constructor Detail

    - #### OrderByMoveIndexBlockingQueue

          public OrderByMoveIndexBlockingQueue(int capacity)

  - ### Method Detail

    - #### startNextStep

          public void startNextStep(int stepIndex)

      Not thread-safe. Can only be called from the solver thread.
      Parameters:
        `stepIndex` - at least 0

    - #### addUndoableMove

          public void addUndoableMove(int moveThreadIndex,
                                      int stepIndex,
                                      int moveIndex,
                                      Move<Solution_> move)

      This method is thread-safe. It can be called from any move thread.
      Parameters:
        `moveThreadIndex` - `0 <= moveThreadIndex < moveThreadCount`
        `stepIndex` - at least 0
        `moveIndex` - at least 0
        `move` - never null
      See Also:
        `BlockingQueue.add(Object)`

    - #### addMove

          public void addMove(int moveThreadIndex,
                              int stepIndex,
                              int moveIndex,
                              Move<Solution_> move,
                              Score score)

      This method is thread-safe. It can be called from any move thread.
      Parameters:
        `moveThreadIndex` - `0 <= moveThreadIndex < moveThreadCount`
        `stepIndex` - at least 0
        `moveIndex` - at least 0
        `move` - never null
        `score` - never null
      See Also:
        `BlockingQueue.add(Object)`

    - #### addExceptionThrown

          public void addExceptionThrown(int moveThreadIndex,
                                         Throwable throwable)

      This method is thread-safe. It can be called from any move thread. Previous results (that haven't been consumed yet), will still be returned during iteration before the iteration throws an exception, unless there's a lower moveIndex that isn't in the queue yet.
      Parameters:
        `moveThreadIndex` - `0 <= moveThreadIndex < moveThreadCount`
        `throwable` - never null

    - #### take

          public OrderByMoveIndexBlockingQueue.MoveResult<Solution_> take()
                                                                   throws InterruptedException

      Not thread-safe. Can only be called from the solver thread.
      Returns:
        never null
      Throws:
        `InterruptedException` - if interrupted
      See Also:
        `BlockingQueue.take()`

Copyright © 2006–2021 JBoss by Red Hat. All rights reserved.