/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until the we move out of SUSPENDED mode * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} */ private void doSuspendedWait() { while (getMode() == Mode.SUSPENDED) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }
/** * resume scanning operations * * This switches the recovery operation mode from SUSPENDED to RESUMED. Any threads which suspended when * they tried to start a scan will be woken up by this transition. */ public void resumeScan () { synchronized (_stateLock) { if (getMode() == Mode.SUSPENDED) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: Mode <== ENABLED"); } setMode(Mode.ENABLED); _stateLock.notifyAll(); } } }