*
   * <p>This is mainly for fixed thread pools. See {@link Executors#newFixedThreadPool(int)}.
   *
   * @param executor the executor to modify to make sure it exits when the application is finished
   * @param terminationTimeout how long to wait for the executor to finish before terminating the
   *     JVM
   * @return an unmodifiable version of the input which will not hang the JVM
   * @since 28.0 (but only since 33.4.0 in the Android flavor)
   */

    }

    @Override
    public void start(String context) {
        contextStack.addFirst(context);
    }

    @Override
    public void finish() {
        contextStack.removeFirst();
    }

   * into user code.
   *
   * @param enqueuedCall a call to enqueue in the synchronized block
   * @param finishedCall a call to finish in the synchronized block
   * @param finishedAsyncCall an async call to finish in the synchronized block
   */
  private fun promoteAndExecute(
    enqueuedCall: AsyncCall? = null,
    finishedCall: RealCall? = null,

		writer.payloadBufferIndex = 0
	}
	return result
}

// Finish is the last call to the message writer - it sends any
// remaining record payload, then sends statistics and finally the end
// message.
func (writer *messageWriter) Finish(bytesScanned, bytesProcessed int64) error {
	select {
	case <-writer.doneCh:
		return fmt.Errorf("messageWriter is done")
	default:

    CRAWLING_EXCEPTION,
    /** Indicates no URL is available in the queue. */
    NO_URL_IN_QUEUE,
    /** Indicates the start of a crawler thread. */
    START_THREAD,
    /** Indicates the finish of a crawler thread. */
    FINISHED_THREAD,
    /** Indicates no response processor is available. */
    NO_RESPONSE_PROCESSOR,
    /** Indicates no rule is available for processing. */
    NO_RULE,

            propertiesBuilder.build(classDoc);
            methodsBuilder.build(classDoc);
            extensionsBuilder.build(classDoc);
            classDoc.mergeContent();
        } finally {
            listener.finish();
        }
    }

        infoLine('-');

        Instant finish = MonotonicClock.now();

        Duration time = Duration.between(session.getRequest().getStartInstant(), finish);

        String wallClock = session.getRequest().getDegreeOfConcurrency() > 1 ? " (Wall Clock)" : "";

        logger.info("Total time:  {}{}", formatDuration(time), wallClock);

	}
	// Wait for all parallel RLock()s to succeed.
	for range numReaders {
		<-clocked
	}
	for range numReaders {
		cunlock <- true
	}
	// Wait for the goroutines to finish.
	for range numReaders {
		<-cdone
	}
}

// Borrowed from rwmutex_test.go
func TestParallelReaders(t *testing.T) {
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(-1))
	doTestParallelReaders(1, 4)

            chapter.setAttribute("id", classDoc.getId());
            descriptionRenderer.renderTo(classDoc, chapter);
            merge(classDoc, chapter);
        } finally {
            listener.finish();
        }
    }

    void merge(ClassDoc classDoc, Element chapter) {
        for (ClassDocMemberRenderer memberRenderer : memberRenderers) {
            memberRenderer.renderSummaryTo(classDoc, chapter);
        }

    void projectFinished(String projectId);

    void executionFailure(String projectId, boolean halted, String exception);

    void mojoStarted(ExecutionEvent event);

    void finish(int exitCode) throws Exception;

    void fail(Throwable t) throws Exception;

    void log(String msg);

    void transfer(String projectId, TransferEvent e);