});

                if (logger.isDebugEnabled()) {
                    logger.debug("Terminating process {}.", p);
                }
                try {
                    if (!p.destroyForcibly().waitFor(timeout, TimeUnit.MILLISECONDS)) {
                        logger.warn("Terminating process {} is timed out.", p);
                    } else if (logger.isDebugEnabled()) {

            this.process = process;
            this.timeout = timeout;
        }

        /**
         * Runs the monitor thread, sleeping for the timeout duration and terminating the process if needed.
         */
        @Override
        public void run() {
            ThreadUtil.sleepQuietly(timeout);

            if (!finished) {
                try {

// invocation of F then behaves like a call to panic, terminating G's
// execution and running any deferred functions. This continues until all
// functions in the executing goroutine have stopped, in reverse order. At
// that point, the program is terminated with a non-zero exit code. This
// termination sequence is called panicking and can be controlled by the
// built-in function recover.
//

   * characters which constitute a machine-sensible address or routing information. Such a sequence
   * is referred to as the "heading." An STX character has the effect of terminating a heading.
   *
   * @since 8.0
   */
  public static final byte SOH = 1;

  /**
   * Start of Text: A communication control character which precedes a sequence of characters that

                        }
                    }
                }

                if (emptyListCount >= maxEmptyListCount) {
                    if (logger.isInfoEnabled()) {
                        logger.info("Terminating indexUpdater. emptyListCount is over {}.", maxEmptyListCount);
                    }
                    // terminate crawling
                    finishCrawling = true;
                    forceStop();

    the web socket's connections back to the pool before their resources were cleaned up.

 *  Fix: Don't infinite loop when a received web socket message has self-terminating compressed
    data.

 *  Fix: Don't fail the call when the response code is ‘HTTP 102 Processing’ or ‘HTTP 103 Early
    Hints’.

 *  Fix: Honor interceptors' changes to connect and read timeouts.

<p>
While programmers should write Go programs without data races,
there are limitations to what a Go implementation can do in response to a data race.
An implementation may always react to a data race by reporting the race and terminating the program.
Otherwise, each read of a single-word-sized or sub-word-sized memory location
must observe a value actually written to that location (perhaps by a concurrent executing goroutine)
and not yet overwritten.

	var tok lex.ScanToken
	for {
		tok = p.nextToken()
		// We save the line number here so error messages from this instruction
		// are labeled with this line. Otherwise we complain after we've absorbed
		// the terminating newline and the line numbers are off by one in errors.
		p.lineNum = p.lex.Line()
		switch tok {
		case '\n', ';':
			continue
		case scanner.EOF:
			return "", "", nil, false
		}
		break
	}

			ChangeTime: time.Unix(1389782956, 794414986),
			Xattrs: map[string]string{
				"user.key":  "value",
				"user.key2": "value2",
				// Interestingly, selinux encodes the terminating null inside the xattr
				"security.selinux": "unconfined_u:object_r:default_t:s0\x00",
			},
			PAXRecords: map[string]string{
				"mtime":                         "1386065770.44825232",

    * This is one of the reasons why it's very useful when the same TLS Termination Proxy also takes care of the certificate renewal process.