Indicates whether the async deletion thread should be startable or not.

@param isStartable
768675
private void setIsAsyncDeletionThreadStartable(boolean isStartable)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "setIsAsyncDeletionThreadStartable", new Boolean(isStartable));

        synchronized (deletionThreadLock)
        {
            _isAsyncDeletionThreadStartable = isStartable;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "setIsAsyncDeletionThreadStartable");
    }
950199
@Override
    public java.util.concurrent.Future<ListTablesResult> listTablesAsync(String exclusiveStartTableName) {

        return listTablesAsync(new ListTablesRequest().withExclusiveStartTableName(exclusiveStartTableName));
    }
1330046
@Override void onShutdown() {
        BlockingQueue<Runnable> q = super.getQueue();
        boolean keepDelayed =
            getExecuteExistingDelayedTasksAfterShutdownPolicy();
        boolean keepPeriodic =
            getContinueExistingPeriodicTasksAfterShutdownPolicy();
        if (!keepDelayed && !keepPeriodic) {
            for (Object e : q.toArray())
                if (e instanceof RunnableScheduledFuture<?>)
                    ((RunnableScheduledFuture<?>) e).cancel(false);
            q.clear();
        }
        else {
            // Traverse snapshot to avoid iterator exceptions
            for (Object e : q.toArray()) {
                if (e instanceof RunnableScheduledFuture) {
                    RunnableScheduledFuture<?> t =
                        (RunnableScheduledFuture<?>)e;
                    if ((t.isPeriodic() ? !keepPeriodic : !keepDelayed) ||
                        t.isCancelled()) { // also remove if already cancelled
                        if (q.remove(t))
                            t.cancel(false);
                    }
                }
            }
        }
        tryTerminate();
    }
1184239
public void threadStarted(ThreadPool tp, int activeThreads, int maxThreads)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "threadStarted", new Object[]{tp, new Integer(activeThreads), new Integer(maxThreads)});
    
    if (TraceComponent.isAnyTracingEnabled() && (tc.isDebugEnabled() || tc.isDumpEnabled() || tc.isEntryEnabled() || tc.isEventEnabled()))
      SibTr.push(_messageProcessor.getMessagingEngine());  
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "threadStarted");
  }
294902
def __thread_started(self):
		
		if self.__task is None:
			raise RuntimeError('Unable to start thread without "start" method call')
		self.__task.start()
		self.__task.start_event().wait(self.__scheduled_task_startup_timeout__)
786032
@Override
  public void start()
  {
    LOGGER.debug("Start Loading");
    // validate parameters
    validateParameters();

    if (_op == null)
    {
      this.abort(new ConnectionError("Loader started with no operation"));
      return;
    }

    initDateFormats();

    initQueues();

    if (_is_first_start_call)
    {
      // is this the first start call?

      try
      {
        if (_startTransaction)
        {
          LOGGER.debug("Begin Transaction");
          _processConn.createStatement().execute("begin transaction");
        }
        else
        {
          LOGGER.debug("No Transaction started");
        }
      }
      catch (SQLException ex)
      {
        abort(new Loader.ConnectionError("Failed to start Transaction",
                                         Utils.getCause(ex)));
      }

      if (_truncate)
      {
        truncateTargetTable();
      }

      try
      {
        if (_before != null)
        {
          LOGGER.debug("Running Execute Before SQL");
          _processConn.createStatement().execute(_before);
        }
      }
      catch (SQLException ex)
      {
        abort(new Loader.ConnectionError(
            String.format("Execute Before SQL failed to run: %s", _before),
            Utils.getCause(ex)));
      }
    }
  }
1289661
public synchronized void initialRequestDone() {
        initialRequestDone = true;
        if (previousAsyncContext != null) {
            previousAsyncContext.onAsyncStart(this);
            previousAsyncContext = null;
        }
        if (!processingAsyncTask) {
            processAsyncTask();
        }
        initiatingThread = null;
    }
1014401
private void start(boolean daemon) {
        if (daemon == Thread.currentThread().isDaemon()) {
            server.start();
        } else {
            FutureTask<Void> startTask = new FutureTask<Void>(new Runnable() {
                @Override
                public void run() {
                    server.start();
                }
            }, null);
            NamedDaemonThreadFactory.defaultThreadFactory(daemon).newThread(startTask).start();
            try {
                startTask.get();
            } catch (ExecutionException e) {
                throw new RuntimeException("Unexpected exception on starting HTTPSever", e);
            } catch (InterruptedException e) {
                // This is possible only if the current tread has been interrupted,
                // but in real use cases this should not happen.
                // In any case, there is nothing to do, except to propagate interrupted flag.
                Thread.currentThread().interrupt();
            }
        }
    }
276146
public final void serverStarted() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "serverStarted", this);

        if (okayToSendServerStarted()) {

            Iterator<ComponentList> vIter = jmeComponents.iterator();
            while (vIter.hasNext()) {
                vIter.next().getRef().serverStarted();
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "serverStarted");
    }
703536
public void executeInIoThread(Runnable task, boolean alwaysAsync) {
        if (!alwaysAsync && isIoThread()) {
            task.run();
        } else {
            registerTask(task);
        }
    }
587501
@Handler
    public void onStart(Start event) {
        synchronized (this) {
            if (runner != null) {
                return;
            }
            buffers = new ManagedBufferPool<>(ManagedBuffer::new,
                () -> {
                    return ByteBuffer.allocateDirect(bufferSize);
                }, 2);
            runner = new Thread(this, Components.simpleObjectName(this));
            // Because this cannot reliably be stopped, it doesn't prevent
            // shutdown.
            runner.setDaemon(true);
            runner.start();
        }
    }
486903
public synchronized void start() {
    if (!running) {
      running = true;
      Thread t = new Thread(new CpuStatRunnable(), "ThreadCpuStatsCollector");
      t.setDaemon(true);
      t.start();
    }
  }
1102916
public void setStart(final double START) {
        if (null == start) {
            _start = START;
            fireSectionEvent(UPDATE_EVENT);
        } else {
            start.set(START);
        }
    }
675045
private void checkStarted() throws SIResourceException {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.entry(tc, "checkStarted");

        synchronized (_mpStartStopLock) {
            if (!isStarted()) {
                if (TraceComponent.isAnyTracingEnabled()
                    && tc.isEntryEnabled())
                    SibTr.exit(tc, "checkStarted", "ME not started");

                throw new SIResourceException(nls.getFormattedMessage(
                                                                      "MESSAGE_PROCESSOR_NOT_STARTED_ERROR_CWSIP0211",
                                                                      new Object[] { getMessagingEngineName(),
                                                                                    getMessagingEngineBus() }, null));
            }
        }

        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.exit(tc, "checkStarted");
    }
579083
public void start(String taskName) throws IllegalStateException {
		if (this.running) {
			throw new IllegalStateException("Can't start StopWatch: it's already running");
		}
		this.startTimeMillis = System.currentTimeMillis();
		this.running = true;
		this.currentTaskName = taskName;
	}
1271203
final boolean abort(boolean removeFromQueue, Throwable cause) {
        if (removeFromQueue && executor.queue.remove(this))
            executor.maxQueueSizeConstraint.release();
        if (nsAcceptEnd == nsAcceptBegin - 1) // currently unset
            nsRunEnd = nsQueueEnd = nsAcceptEnd = System.nanoTime();
        boolean aborted = result.compareAndSet(state, cause);
        if (aborted)
            try {
                state.releaseShared(ABORTED);
                if (nsQueueEnd == nsAcceptBegin - 2) // currently unset
                    nsRunEnd = nsQueueEnd = System.nanoTime();
                if (callback != null)
                    callback.onEnd(task, this, null, true, 0, cause);
            } finally {
                if (latch != null)
                    latch.countDown();
                if (cancellableStage != null) {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        Tr.debug(this, tc, "completion stage to complete exceptionally: " + cancellableStage);
                    cancellableStage.completeExceptionally(cause);
                }
            }
        else {
            // Prevent premature return from abort that would allow subsequent getState() to indicate
            // that the task is still in SUBMITTED state.
            while (state.get() < RUNNING)
                Thread.yield();
        }
        return aborted;
    }
1208021
private boolean waitForRemove(long waitStart, long maxWait) throws InterruptedException {
        if (this.size == this.capacity) {
            if (!waitOnCondition(this.notFull, maxWait, waitStart)) {
                return false;
            }
        }

        return true;
    }