Shuts down the threads used by the commit log, blocking until completion.
514270
public void shutdownBlocking() throws InterruptedException
    {
        executor.shutdown();
        executor.awaitTermination();
        allocator.shutdown();
        allocator.awaitTermination();
    }
148707
private void endWaitingForUsage() {
        synchronized (permanentUserReadWriteLock) {
            if (permissionWithoutUsageLimit != null)
                permissionWithoutUsageLimit = null;
            if (permissionWithoutUsageCloseThread != null) {
                permissionWithoutUsageCloseThread.cancel(true);
                permissionWithoutUsageLimit = null;
            }
        }
    }
514623
public void shutdown()
	{
		try {
			thread.signalShutdown();
			thread.join();
			thread = null;
		} catch (InterruptedException e) {
			LOGGER.warn("Interrupted while waiting for queue shutdown, may not have completed cleanly", e);
		}
	}
1154268
def stop(self):
        
        if self._io_thread is not None:
            self.log.info("Waiting for I/O thread to stop...")
            self.closed = True
            self._io_thread.join()

        if self._writer_thread is not None:
            self.log.info("Waiting for Writer Thread to stop...")
            self.closed = True
            self._writer_thread.join()

        self.log.info("All worker threads stopped.")
944003
def shutdown(self):
        
        with self._lock:
            for cid in list(self.connections.keys()):
                if self.connections[cid].executing:
                    raise ConnectionBusyError(cid)
                if self.connections[cid].locked:
                    self.connections[cid].free()
                self.connections[cid].close()
                del self.connections[cid]
1004035
public void shutdown() {
    logger.warn("Shutting down FlowRunnerManager...");
    if (this.azkabanProps.getBoolean(ConfigurationKeys.AZKABAN_POLL_MODEL, false)) {
      this.pollingService.shutdown();
    }
    this.executorService.shutdown();
    boolean result = false;
    while (!result) {
      logger.info("Awaiting Shutdown. # of executing flows: " + getNumRunningFlows());
      try {
        result = this.executorService.awaitTermination(1, TimeUnit.MINUTES);
      } catch (final InterruptedException e) {
        logger.error(e);
      }
    }
    logger.warn("Shutdown FlowRunnerManager complete.");
  }
1278947
public void shutdownNow() {
      log.tracef("Stopping limited executor %s", name);
      running = false;
      lock.lock();
      try {
         queue.clear();

         for (Thread t : threads.keySet()) {
            t.interrupt();
         }
      } finally {
         lock.unlock();
      }
   }
928871
public void shutdownInvocations() {
        logger.finest("Shutting down invocations");

        invocationRegistry.shutdown();
        invocationMonitor.shutdown();
        inboundResponseHandlerSupplier.shutdown();

        try {
            invocationMonitor.awaitTermination(TERMINATION_TIMEOUT_MILLIS);
        } catch (InterruptedException e) {
            // TODO: we need a better mechanism for dealing with interruption and waiting for termination
            Thread.currentThread().interrupt();
        }
    }
199322
public void shutdown() {
        // shutdown each single thread executor in the managed collection
        for (ExecutorService singleThreadExecutorService : singleThreadExecutorServices) {
            shutdownExecutor(singleThreadExecutorService);
        }

        // shutdown scheduled executor instance
        shutdownExecutor(getInternalScheduledExecutorService());
        shutdownExecutor(getInternalGpioExecutorService());

    }
410646
@Override
  public void shutdown() {

    synchronized (nextRunnableLock) {
      isShutdown = true;

      if (workers == null) {
        return;
      }

      // signal each worker thread to shut down
      Iterator<WorkerThread> workerThreads = workers.iterator();
      while (workerThreads.hasNext()) {
        WorkerThread wt = workerThreads.next();
        JobRunShell jobRunShell = wt.getRunnable();
        if (jobRunShell != null) {
          log.info("Waiting for Job to shutdown: {}", wt.getRunnable().getJobName());
        }
        wt.shutdown();

        availWorkers.remove(wt);
      }

      // Active worker threads will shut down after finishing their
      // current job.
      nextRunnableLock.notifyAll();
    }
  }
219802
private void shutdown(){
    parent.workerThreads.get(plan).remove(this);
    if (zk != null) {
      try {
        logger.debug("closing " + zk.getSessionId());
        zk.close();
        zk = null;
      } catch (InterruptedException e1) {
        logger.debug(e1);
      }
      logger.debug("shutdown complete");
    }
  }
1142988
def shutdown(self, wait=True):
        
        self.scheduler_thread.stop()
        self.worker_message_handler_thread.stop()

        if wait:
            self.scheduler_thread.join()
            self.worker_message_handler_thread.join()
911372
private void finish(boolean commit)
   {
      for (Synchronization s : syncs)
      {
         s.beforeCompletion();
      }

      if (commit)
      {
         status = Status.STATUS_COMMITTED;
      }
      else
      {
         status = Status.STATUS_ROLLEDBACK;
      }

      for (Synchronization s : syncs)
      {
         s.afterCompletion(status);
      }

      status = Status.STATUS_UNKNOWN;
      syncs.clear();
      resources.clear();
   }
177289
public void shutdown() {
		Iterator<ExclusionFilterFactory> itr = factories.iterator();
		while (itr.hasNext()) {
			ExclusionFilterFactory i = itr.next();
			i.shutdown();
		}
	}
961484
public void stopAllThreads()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "stopAllThreads");
      
    synchronized (this)
    {
      Iterator iterator = ((ArrayList)_threadCache.clone()).iterator();
      while (iterator.hasNext())
      {        
        StoppableThread thread = (StoppableThread)iterator.next();
        
        if (tc.isDebugEnabled())
          SibTr.debug(tc, "Attempting to stop thread " + thread);
        
        // Stop the thread  
        thread.stopThread(this);
        
        // Remove from the iterator
        iterator.remove();
        // Remove from the cache
        _threadCache.remove(thread);          
      }
    }
      
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "stopAllThreads");
  }
1357472
public void stop() {
        if (!this.isActive) {
            return;
        }

        cpuThread.shutdown();

        try {
            Thread.sleep(40);
        } catch (InterruptedException e) {
        }

        for (int i = 0; i < taskQueues.length; i++)
            taskQueues[i].clear();

        heartBeatQueue.clear();
    }
1056041
void shutdownNow() {
    shutdown = true;
    for (int i = 0; i < clients.length; i++) {
      clients[i].close();
    }
    fixedThreadPool.shutdownNow();
    system.terminate();
  }