/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
/** * wait until some other thread stops scanning * * <b>Caveats:</b> this must only be called when synchronized on {@link PeriodicRecovery#_stateLock} and when * _currentStatus is SCANNING */ private void doScanningWait() { while (getStatus() == Status.SCANNING) { try { _stateLock.wait(); } catch (InterruptedException e) { // we can ignore this exception } } }
public void resumeScan () { /* * If it's suspended, then it has to be blocked * on the lock. */ if (getStatus() == State.suspended) { setStatus(State.active); synchronized (_suspendLock) { _suspendLock.notify(); } } }
/** * called by the listener worker to wake the periodic recovery thread and get it to start a scan if one * is not already in progress */ public void wakeUp() { synchronized (_stateLock) { _workerScanRequested = true; // wake up the periodic recovery thread if no scan is in progress if (getStatus() != Status.SCANNING) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: listener worker interrupts background thread"); } _stateLock.notifyAll(); } } }
/** * called by the listener worker to wake the periodic recovery thread and get it to start a scan if one * is not already in progress */ public void wakeUp() { synchronized (_stateLock) { _workerScanRequested = true; // wake up the periodic recovery thread if no scan is in progress if (getStatus() != Status.SCANNING) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: listener worker interrupts background thread"); } _stateLock.notifyAll(); } } }
/** * called by the listener worker to wake the periodic recovery thread and get it to start a scan if one * is not already in progress */ public void wakeUp() { synchronized (_stateLock) { _workerScanRequested = true; // wake up the periodic recovery thread if no scan is in progress if (getStatus() != Status.SCANNING) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: listener worker interrupts background thread"); } _stateLock.notifyAll(); } } }
/** * called by the listener worker to wake the periodic recovery thread and get it to start a scan if one * is not already in progress */ public void wakeUp() { synchronized (_stateLock) { _workerScanRequested = true; // wake up the periodic recovery thread if no scan is in progress if (getStatus() != Status.SCANNING) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: listener worker interrupts background thread"); } _stateLock.notifyAll(); } } }
/** * called by the listener worker to wake the periodic recovery thread and get it to start a scan if one * is not already in progress */ public void wakeUp() { synchronized (_stateLock) { _workerScanRequested = true; // wake up the periodic recovery thread if no scan is in progress if (getStatus() != Status.SCANNING) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: listener worker interrupts background thread"); } _stateLock.notifyAll(); } } }
/** * called by the listener worker to wake the periodic recovery thread and get it to start a scan if one * is not already in progress */ public void wakeUp() { synchronized (_stateLock) { _workerScanRequested = true; // wake up the periodic recovery thread if no scan is in progress if (getStatus() != Status.SCANNING) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: listener worker interrupts background thread"); } _stateLock.notifyAll(); } } }
/** * called by the listener worker to wake the periodic recovery thread and get it to start a scan if one * is not already in progress */ public void wakeUp() { synchronized (_stateLock) { _workerScanRequested = true; // wake up the periodic recovery thread if no scan is in progress if (getStatus() != Status.SCANNING) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: listener worker interrupts background thread"); } _stateLock.notifyAll(); } } }
/** * called by the listener worker to wake the periodic recovery thread and get it to start a scan if one * is not already in progress */ public void wakeUp() { synchronized (_stateLock) { _workerScanRequested = true; // wake up the periodic recovery thread if no scan is in progress if (getStatus() != Status.SCANNING) { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("PeriodicRecovery: listener worker interrupts background thread"); } _stateLock.notifyAll(); } } }