Not synchronized as to be meant for the watch dog exclusively

Do not call it unsynchronized
486709
public void conditionViolated() {
        if (this.watchdogReference.isStale()) {
            throw new IllegalStateException("Watchdog is stale and does not exist any longer");
        }

        Watchdog wd = this.watchdogReference.getWatchdog();

        wd.restart();
        if (log.isInfoEnabled()) {
            log.info(new ConditionViolatedLog(this, "Watchdog " + wd.getId() + " is restarted by Condition  " + this.toString()).toString());
        }

    }
769709
def synchronizer(self):
        
        if not self.synchronizer_path or self.synchronizer_path == 'None' or not self.layer:
            return False
        # ensure data is up to date
        if (self._synchronizer is not None and self._synchronizer_class.__name__ not in self.synchronizer_path):
            self._synchronizer = None
            self._synchronizer_class = None
        # init synchronizer only if necessary
        if not self._synchronizer:
            self._synchronizer = (self.synchronizer_class)(self.layer)
        return self._synchronizer
1164884
def synchronous(self):
        '''
        
        '''
        if self._transport is None:
            if self._close_info and len(self._close_info['reply_text']) > 0:
                raise ConnectionClosed("connection is closed: %s : %s" %
                                       (self._close_info['reply_code'],
                                        self._close_info['reply_text']))
            raise ConnectionClosed("connection is closed")
        return self.transport.synchronous or self._synchronous
915773
public boolean isAsync() {
        return invokeType != null && (RpcConstants.INVOKER_TYPE_CALLBACK.equals(invokeType)
            || RpcConstants.INVOKER_TYPE_FUTURE.equals(invokeType));
    }
486355
protected void scheduleRunAsync(Runnable runnable, long delay, TimeUnit unit) {
		rpcServer.scheduleRunAsync(runnable, unit.toMillis(delay));
	}
924828
protected final void updateLastNotReadyTime()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(this, tc, "updateLastNotReadyTime");
    if (readAhead)
    { // only relevant when prefetching
      synchronized (this)
      {
        // it is possible that both the CP and the RCD try to transition to !ready concurrently.
        // we only remember the time from the first transition.
        if (!usable)
        {
          lastNotReadyTime = System.currentTimeMillis();
          usable = true;
        }
      }
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(this, tc, "updateLastNotReadyTime");
  }
906082
def watchdog_handler(self):
        """"""
        _LOGGING.debug('%s Watchdog expired. Resetting connection.', self.name)
        self.watchdog.stop()
        self.reset_thrd.set()
988777
def run_sync(self):
        
        while self.connected:
            try:
                self.pump_reader()
            except PacketDecodeError as e:
                logger.warning("Packet decode failed: %s", e)
            except ConnectionError:
                break
1098600
def modify_stack_synchronously
      watch do |watcher|
        handling_cf_errors do
          yield
        end
        loop do
          watcher.each_new_event(&event_handler)
          status = self.status
          logger.debug("stack_status=#{status}")
          return status if status.nil? || status =~ /_(COMPLETE|FAILED)$/
          sleep(wait_poll_interval)
        end
      end
    end
485731
def signal
      synchronize do
        while(t = @threads.shift)
          if(t && t.alive? && t.stop?)
            t.wakeup
            break
          else
            next
          end
        end
      end
    end
1359666
def start_watching(self):
        
        if not self.is_sync:
            return

        self._stop = False
        while not self._stop:
            self.reactor.doIteration(0)
1245978
private boolean switchToIdle() throws SIConnectionDroppedException {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "switchToIdle");
      final boolean noMoreWork;
      synchronized (priorityQueue) {
         synchronized (this) {
            noMoreWork = !isWorkAvailable();
            idle = noMoreWork;
         }
      }
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "switchToIdle", Boolean.valueOf(noMoreWork));
      return noMoreWork;
   }
683219
@Override
    public void onKnownIssueAlreadySynchronized(final AcraReport pReport, final Issue pIssue)
            throws SynchronizationException {

        pReport.setStatus(SyncStatus.SUCCESS);
    }
611208
public boolean isSyncCurrentPosition(int syncmode) throws BitstreamException
	{
		int read = readBytes(syncbuf, 0, 4);
		int headerstring = ((syncbuf[0] << 24) & 0xFF000000) | ((syncbuf[1] << 16) & 0x00FF0000) | ((syncbuf[2] << 8) & 0x0000FF00) | ((syncbuf[3] << 0) & 0x000000FF);

		try
		{
			source.unread(syncbuf, 0, read);
		}
		catch (IOException ex)
		{
		}

		boolean sync = false;
		switch (read)
		{
			case 0:
				sync = true;
				break;
			case 4:
				sync = isSyncMark(headerstring, syncmode, syncword);
				break;
		}

		return sync;
	}
654468
def wait(self):
        
        self._wait_called = True
        while self.tracked_coordinator_count() > 0 or \
                self.waiting_coordinator_count() > 0:
            time.sleep(1)
            super(AsperaTransferCoordinatorController, self).wait()
        self._wait_called = False
230242
def IsSynced(self):
        
        if Blockchain.Default().Height == 0:
            return False

        if (int(100 * self._current_height / Blockchain.Default().Height)) < 100:
            return False
        else:
            return True
797671
def until_not_synced(self, timeout=None):
        """"""
        not_synced_states = [state for state in self._state.valid_states
                             if state != 'synced']
        not_synced_futures = [self._state.until_state(state)
                              for state in not_synced_states]
        return until_any(*not_synced_futures, timeout=timeout)