Package org.optaplanner.core.impl.solver.termination

Class BasicPlumbingTermination<Solution_>

java.lang.Object
org.optaplanner.core.impl.solver.event.SolverLifecycleListenerAdapter<Solution_>
org.optaplanner.core.impl.phase.event.PhaseLifecycleListenerAdapter<Solution_>
org.optaplanner.core.impl.solver.termination.AbstractTermination<Solution_>
org.optaplanner.core.impl.solver.termination.BasicPlumbingTermination<Solution_>
All Implemented Interfaces:
EventListener, PhaseLifecycleListener<Solution_>, SolverLifecycleListener<Solution_>, Termination<Solution_>
public class BasicPlumbingTermination<Solution_> extends AbstractTermination<Solution_>
Concurrency notes: Condition predicate on (problemFactChangeQueue is not empty or terminatedEarly is true).

  • Field Details

    • daemon

      protected final boolean daemon

    • terminatedEarly

      protected boolean terminatedEarly

    • problemFactChangeQueue

      protected BlockingQueue<ProblemChangeAdapter<Solution_>> problemFactChangeQueue

    • problemFactChangesBeingProcessed

      protected boolean problemFactChangesBeingProcessed

  • Constructor Details

    • BasicPlumbingTermination

      public BasicPlumbingTermination(boolean daemon)

  • Method Details

    • resetTerminateEarly

      public void resetTerminateEarly()
      This method is thread-safe.

    • terminateEarly

      public boolean terminateEarly()
      This method is thread-safe.

      Concurrency note: unblocks waitForRestartSolverDecision().

      Returns:
      true if successful

    • isTerminateEarly

      public boolean isTerminateEarly()
      This method is thread-safe.

    • waitForRestartSolverDecision

      public boolean waitForRestartSolverDecision()
      If this returns true, then the problemFactChangeQueue is definitely not empty.

      Concurrency note: Blocks until problemFactChangeQueue is not empty or terminatedEarly is true.

      Returns:
      true if the solver needs to be restarted

    • addProblemChange

      public boolean addProblemChange(ProblemChangeAdapter<Solution_> problemChange)
      Concurrency note: unblocks waitForRestartSolverDecision().
      Parameters:
      problemChange - never null
      Returns:
      as specified by Collection.add(E)

    • addProblemChanges

      public boolean addProblemChanges(List<ProblemChangeAdapter<Solution_>> problemChangeList)
      Concurrency note: unblocks waitForRestartSolverDecision().
      Parameters:
      problemChangeList - never null
      Returns:
      as specified by Collection.add(E)

    • startProblemFactChangesProcessing

      public BlockingQueue<ProblemChangeAdapter<Solution_>> startProblemFactChangesProcessing()

    • endProblemFactChangesProcessing

      public void endProblemFactChangesProcessing()

    • isEveryProblemFactChangeProcessed

      public boolean isEveryProblemFactChangeProcessed()

    • isSolverTerminated

      public boolean isSolverTerminated(SolverScope<Solution_> solverScope)
      Description copied from interface: Termination
      Called by the Solver after every phase to determine if the search should stop.
      Parameters:
      solverScope - never null
      Returns:
      true if the search should terminate.

    • isPhaseTerminated

      public boolean isPhaseTerminated(AbstractPhaseScope<Solution_> phaseScope)
      Description copied from interface: Termination
      Called by the Phase after every step and every move to determine if the search should stop.
      Parameters:
      phaseScope - never null
      Returns:
      true if the search should terminate.

    • calculateSolverTimeGradient

      public double calculateSolverTimeGradient(SolverScope<Solution_> solverScope)
      Description copied from interface: Termination
      A timeGradient is a relative estimate of how long the search will continue.

      Clients that use a timeGradient should cache it at the start of a single step because some implementations are not time-stable.

      If a timeGradient cannot be calculated, it should return -1.0. Several implementations (such a SimulatedAnnealingAcceptor) require a correctly implemented timeGradient.

      A Termination's timeGradient can be requested after they are terminated, so implementations should be careful not to return a timeGradient above 1.0.

      Parameters:
      solverScope - never null
      Returns:
      timeGradient t for which 0.0 <= t <= 1.0 or -1.0 when it is not supported. At the start of a solver t is 0.0 and at the end t would be 1.0.

    • calculatePhaseTimeGradient

      public double calculatePhaseTimeGradient(AbstractPhaseScope<Solution_> phaseScope)
      Description copied from interface: Termination
      See Termination.calculateSolverTimeGradient(SolverScope).
      Parameters:
      phaseScope - never null
      Returns:
      timeGradient t for which 0.0 <= t <= 1.0 or -1.0 when it is not supported. At the start of a phase t is 0.0 and at the end t would be 1.0.

    • createChildThreadTermination

      public Termination<Solution_> createChildThreadTermination(SolverScope<Solution_> solverScope, ChildThreadType childThreadType)
      Description copied from interface: Termination
      Create a Termination for a child Thread of the Solver.
      Specified by:
      createChildThreadTermination in interface Termination<Solution_>
      Overrides:
      createChildThreadTermination in class AbstractTermination<Solution_>
      Parameters:
      solverScope - never null
      childThreadType - never null
      Returns:
      not null

    • toString

      public String toString()
      Overrides:
      toString in class Object