/*
(non-Javadoc)

@see org.archive.wayback.accesscontrol.ExclusionFilterFactory#shutdown()
177289
public void shutdown() {
		Iterator<ExclusionFilterFactory> itr = factories.iterator();
		while (itr.hasNext()) {
			ExclusionFilterFactory i = itr.next();
			i.shutdown();
		}
	}
979346
public void shutdown() {
        lock.lock();
        try {
            isShutdown = true;
            notEmpty.signalAll();
            notFull.signalAll();
        }
        finally {
            lock.unlock();
        }
    }
1273425
public void shutdown ()
    {
        // shut down all active places
        for (Iterator<PlaceManager> iter = enumeratePlaceManagers(); iter.hasNext(); ) {
            PlaceManager pmgr = iter.next();
            try {
                pmgr.shutdown();
            } catch (Exception e) {
                log.warning("Place manager failed shutting down", "where", pmgr.where(), e);
            }
        }
    }
44569
@Override
  public void stop(ShutdownModeAmp mode)
  {
    _lifecycle.toDestroy();
    
    _activeService.set(null);
    
    FailSafeHaltThread failSafeThread = _failSafeHaltThread;
    
    if (failSafeThread != null) {
      failSafeThread.wake();
    }
    
    FailSafeMemoryFreeThread memoryFreeThread = _failSafeMemoryFreeThread;
    
    if (memoryFreeThread != null)
      memoryFreeThread.startShutdown();
    
    ShutdownThread shutdownThread = _shutdownThread;
    
    if (shutdownThread != null)
      shutdownThread.wake();
  }
920873
public void shutdown() {
    if (shutdown) {
      return;
    }
    cache.clear();
    stats.shutdown();
    dispatcher.shutdown();
    if (closeableCache != null) {
      try {
        closeableCache.close();
      } catch (IOException ignored) {
      }
    }
    for (DeferredRequestCreator deferredRequestCreator : targetToDeferredRequestCreator.values()) {
      deferredRequestCreator.cancel();
    }
    targetToDeferredRequestCreator.clear();
    shutdown = true;
  }
429083
@Override
    public void shutdown() {
        // Since Aeron's poll isn't blocking, all we need is just special flag
        runner.set(false);
        try {
            threadA.join();

            if (threadB != null)
                threadB.join();
        } catch (Exception e) {
            //
        }
        CloseHelper.quietClose(driver);
        try {
            Thread.sleep(500);
        } catch (Exception e) {

        }
    }
862724
public void shutdown ()
    {
        // close all of the connections
        for (Map.Entry<String, Mapping> entry : _keys.entrySet()) {
            entry.getValue().closeConnection(entry.getKey());
        }

        // clear out our mapping tables
        _keys.clear();
        _idents.clear();
    }
1230627
@Override
	public void shutdown() {
		if (detectChanges) {
			es.shutdown();
			try {
				if (!es.awaitTermination(1000, TimeUnit.MILLISECONDS)) {
					es.shutdownNow();
				}
			} catch (InterruptedException e) {
				es.shutdownNow();
			}
		}
	}
1337511
@Override
    public synchronized void shutdown() throws JournalException {
        try {
            if (open) {
                reader.close();
                open = false;
            }
        } catch (XMLStreamException e) {
            throw new JournalException(e);
        }
    }
183097
public void shutdown() {
    this.shouldRun = false;
    this.namespaceSliceDUMap.clear();
    if(this.refreshUsed != null) {
      this.refreshUsed.interrupt();
      try {
        this.refreshUsed.join();
        this.refreshUsed = null;
      } catch (InterruptedException ie) {
      }
    }
  }
58591
@Override
    public void shutdown() throws JournalException {
        synchronized (JournalWriter.SYNCHRONIZER) {
            if (state == SHUTDOWN) {
                return;
            }
            if (state == FILE_OPEN) {
                closeFile();
            }

            logger.debug("Shutting down.");
            sendRequestToAllTransports(new ShutdownRequest());
            state = SHUTDOWN;
        }
    }
1205332
public static synchronized void shutdown()
    {
        if( c_factories == null ) return; // Nothing to do

        for( Iterator<Entry<String, StopWatchFactory>> i = c_factories.entrySet().iterator(); i.hasNext() ; )
        {
            Map.Entry<String,StopWatchFactory> e = i.next();

            StopWatchFactory swf = e.getValue();
            swf.internalShutdown();

            i.remove();
        }

        c_factories = null;
    }
658649
@Override
  public void shutdown(ShutdownModeAmp mode)
  {
    if (mode == ShutdownModeAmp.IMMEDIATE) {
      _stateRef.set(State.CLOSED);
    }
  }
998893
public static void shutdown() {
		UdpResources resources = udpResources.getAndSet(null);
		if (resources != null) {
			resources._dispose();
		}
	}
712557
@Override
    public void shutdown() {
        ArrayList mbeanSvrs = MBeanServerFactory.findMBeanServer(null);
        if (mbeanSvrs != null && mbeanSvrs.size() > 0 && _statsModuleObjectName != null) {
            MBeanServer svr = (MBeanServer) mbeanSvrs.get(0);

            try {
                svr.unregisterMBean(_statsModuleObjectName);
            } catch (InstanceNotFoundException e) {
                com.ibm.ws.ffdc.FFDCFilter.processException(e, "com.ibm.ws.session.SessionManager.shutdown", "263", this);
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.SEVERE, methodClassName, methodNames[SHUTDOWN], "CommonMessage.exception", e);
            } catch (MBeanRegistrationException e) {
                com.ibm.ws.ffdc.FFDCFilter.processException(e, "com.ibm.ws.session.SessionManager.shutdown", "265", this);
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.SEVERE, methodClassName, methodNames[SHUTDOWN], "CommonMessage.exception", e);
            }
        }
    }
1360330
@Override
  public void shutdown(ShutdownModeAmp mode)
  {
    for (WorkerDeliver<M> worker : _workers) {
      worker.shutdown(mode);
    }
  }
1291143
public synchronized final void shutdown() throws RepositoryException {
        preShutdown();

        delegateWriter = NoOpQueryIndexWriter.INSTANCE;
        try {
            // Shutdown each of the provided indexes ...
            for (Map<String, AtomicIndex> byWorkspaceName : providedIndexesByWorkspaceNameByIndexName.values()) {
                for (AtomicIndex provided : byWorkspaceName.values()) {
                    provided.shutdown(false);
                }
            }
        } finally {
            providedIndexesByWorkspaceNameByIndexName.clear();
            providedIndexesByIndexNameByWorkspaceName.clear();
            postShutdown();
        }
    }