apiVersion: release-notes/v2
kind: feature
area: traffic-management

releaseNotes:
- |
  **Added** an experimental feature to enable cluster creation on worker threads inline during requests.
  This will save memory and CPU cycles in cases where there are lots of inactive clusters and > 1 worker thread.

     *
     * The implementation blocks when multiple threads producing the same value concurrently, so that only a single thread produces the value and the other threads reuse the result.
     *
     * Production of the value always happens synchronously by the calling thread. However, the implementation may update the backing store with new value synchronously or asynchronously.
     *

        //
        // This situation can happen when the last task in an included build is executed by the thread that called process() and all other workers are waiting for work to be enabled in the
        // other builds in the tree. The thread will signal the other threads and then stop running as a worker. At this point in time, work will be ready to start but all the (other) workers will

          // thread.
          executionList.execute();
          return;
        }

        // TODO(lukes): handle RejectedExecutionException
        adapterExecutor.execute(
            () -> {
              try {
                /*
                 * Threads from our private pool are never interrupted. Threads from a

			wg.Done()
			select {}
		}()
	}
	wg.Wait()
	mem2, err := getPagefileUsage()
	if err != nil {
		panic(err)
	}
	// assumes that this process creates 1 thread for each
	// thread locked goroutine plus extra 10 threads
	// like sysmon and others
	print((mem2 - mem1) / (threadCount + 10))

  /**
   * Returns an exception handler that exits the system. This is particularly useful for the main
   * thread, which may start up other, non-daemon threads, but fail to fully initialize the
   * application successfully.
   *
   * <p>Example usage:
   *
   * <pre>
   * public static void main(String[] args) {
   *   Thread.currentThread().setUncaughtExceptionHandler(UncaughtExceptionHandlers.systemExit());
   *   ...
   * </pre>
   *

// RunGoroutines starts some goroutines that don't do anything.
// The idea is to get some threads going, so that a signal will be delivered
// to a thread started by Go.
//
//export RunGoroutines
func RunGoroutines() {
	for i := 0; i < 4; i++ {
		go func() {
			runtime.LockOSThread()
			select {}
		}()
	}
}

// Block blocks the current thread while running Go code.
//
//export Block
func Block() {
	select {}
}

     * However, it is currently easy for state to leak from one project to another so this is not a strong guarantee.
     */
    void applyToMutableState(Consumer<? super T> action);

    /**
     * Returns whether or not the current thread has access to the mutable model.
     */
    boolean hasMutableState();

    /**

    }

    def "can be used in parallel"() {
        def threads = 5
        def startSignal = new CountDownLatch(1)
        def doneSignal = new CountDownLatch(threads)

        when:
        threads.times {
            new Thread({
                startSignal.await()
                def spawnedProject = ProjectBuilder.builder().build()
                try {

        // Use a single reader thread, and make it a daemon thread so that it does not block process shutdown
        // In most cases, we try to cleanly shut down all threads. However, in this case it is difficult to disconnect a thread blocked trying to read from the
        // process' stdin, so use a daemon thread instead.
        executor = Executors.newSingleThreadExecutor(r -> {
            Thread thread = new Thread(r);