It's called "asynchronous" because the computer / program doesn't have to be "synchronized" with the slow task, waiting for the exact moment that the task finishes, while doing nothing, to be able to take the task result and continue the work.

# o schema   -- The schema name.
# o user     -- The database user name.
# o password -- The database password.
# o propertiesMap -- The properties that depends on the database.
# o variousMap    -- The various settings about JDBC task.
#
# *The line that starts with '#' means comment-out.
#
map:{
    ; driver   = org.h2.Driver
    ; url      = jdbc:h2:file:../src/test/resources/dummydb/dummydb
    ; schema   =  
    ; user     = sa

                logger.debug("Job {} is running.", id);
            }
            return;
        }

        TimeoutTask task = null;
        try {
            if (scheduledJob.isLoggingEnabled()) {
                jobHelper.store(jobLog);
                task = jobHelper.startMonitorTask(jobLog);
            }

            if (logger.isDebugEnabled()) {

    params {
        text(
            testTaskParameterName,
            ":core:embeddedIntegTest",
            display = ParameterDisplay.PROMPT,
            allowEmpty = false,
            description = "The test task you want to run"
        )
        text(
            testNameParameterName,
            """org.gradle.api.tasks.CachedTaskExecutionIntegrationTest.outputs*are*correctly*loaded*from*cache""",

   * running with have the given name.
   *
   * @param task The Runnable to wrap
   * @param nameSupplier The supplier of thread names, {@link Supplier#get get} will be called once
   *     for each invocation of the wrapped callable.
   */
  @J2ktIncompatible
  @GwtIncompatible // threads
  static Runnable threadRenaming(Runnable task, Supplier<String> nameSupplier) {
    checkNotNull(nameSupplier);

        val taskPathToReports = allTasks.associate { it.path to it.customReports() + it.attachedReportLocations() }.filter { it.value.isNotEmpty() }
        globalExtension.taskPathToReports = taskPathToReports
    }
}

fun Task.customReports(): List<File> = when (this) {
    is ValidatePlugins -> listOf(outputFile.get().asFile)
    is FindBrokenInternalLinks -> listOf(reportFile.get().asFile)
    is DistributionTest -> listOf(

        Thread.sleep(10);
        int count = expiredCount;
        task.stop();
        TimeoutManager.getInstance().start();
        assertNotNull(TimeoutManager.getInstance().thread);
        Thread.sleep(2000);
        assertEquals(count, expiredCount);
        assertEquals(1, TimeoutManager.getInstance().getTimeoutTaskCount());
        task.cancel();
        Thread.sleep(2000);

    /* the implementation class to collect information from task execution result */
    klass: Class<T>,
    /* which tasks we need to monitor? For example, cache-miss-monitor monitors `AbstractCompile` tasks */
    taskFilter: (Task) -> Boolean,
    /* pass the collected information in build-logic and main build to build scan */

  }

  /**
   * Submits a blocking task for the given {@link Future} to provide {@link ListenableFuture}
   * functionality.
   *
   * <p><b>Warning:</b> If the input future does not already implement {@code ListenableFuture}, the
   * returned future will emulate {@link ListenableFuture#addListener} by submitting a task to the
   * given executor at the first call to {@code addListener}. The task must be started by the

// on each underlying device.
//
// For example if `device_name` is
//   "/job:localhost/replica:0/task:0/device:CUSTOM:0"
// and `underlying_devices` is
//   {"/job:localhost/replica:0/task:0/device:GPU:0",
//    "/job:localhost/replica:0/task:0/device:GPU:1"}
// Then executing an operation on CUSTOM:0 will execute it on GPU:0 and GPU:1.
//