} ?: return

          logger.logElapsed(task, task.queue!!) {
            var completedNormally = false
            try {
              runTask(task)
              completedNormally = true
            } finally {
              // If the task is crashing start another thread to service the queues.
              if (!completedNormally) {
                lock.withLock {
                  startAnotherThread()
                }

                    sh "mvn clean ${MAVEN_GOAL} -B -U -e -fae -V -Dmaven.test.failure.ignore -PversionlessMavenDist -Dmaven.repo.local=${WORK_DIR}/.repository"
                }
            } finally {
                junit testResults: '**/target/surefire-reports/*.xml,**/target/failsafe-reports/*.xml', allowEmptyResults: true
            }    
        }
    }
}

Map runITsTasks = [:]

    check(executed.compareAndSet(false, true)) { "Already Executed" }

    timeout.enter()
    callStart()
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

  override fun enqueue(responseCallback: Callback) {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    callStart()

                    sh "mvn clean ${MAVEN_GOAL} -B -U -e -fae -V -Dmaven.test.failure.ignore -PversionlessMavenDist -Dmaven.repo.local=${WORK_DIR}/.repository"
                }
            } finally {
                junit testResults: '**/target/surefire-reports/*.xml,**/target/failsafe-reports/*.xml', allowEmptyResults: true
            }    
            dir ('apache-maven/target') {

    val startedTask = startNextTask()
    val otherTasksStarted = startedTask != yieldCompleteTask

    try {
      while (currentTask != self) {
        taskRunner.condition.await()
      }
    } finally {
      serialTaskQueue.remove(yieldCompleteTask)
    }

    // If we're yielding until we're exhausted and a task run, keep going until a task doesn't run.

        val doReadTimeout = callerIsIdle || doReadTimeout()
        if (doReadTimeout) {
          readTimeout.enter()
        }
        try {
          waitForIo()
        } finally {
          if (doReadTimeout) {
            readTimeout.exitAndThrowIfTimedOut()
          }
        }
      }
      if (headersQueue.isNotEmpty()) {
        return headersQueue.removeFirst()
      }

        // This method call results in one or more onRead* methods being called on this thread.
        reader!!.processNextFrame()
      }
    } catch (e: Exception) {
      failWebSocket(e = e)
    } finally {
      finishReader()
    }
  }

  /**
   * For testing: receive a single frame and return true if there are more frames to read. Invoked
   * only by the reader thread.
   */

      connectSocket()
      success = true
      return ConnectResult(plan = this)
    } catch (e: IOException) {
      user.connectFailed(route, null, e)
      return ConnectResult(plan = this, throwable = e)
    } finally {
      user.removePlanToCancel(this)
      if (!success) {
        rawSocket?.closeQuietly()
      }
    }
  }

  override fun connectTlsEtc(): ConnectResult {

While waiting and talking to your crush, from time to time, you check the number displayed on the counter to see if it's your turn already.

Then at some point, it finally is your turn. You go to the counter, get your burgers and come back to the table.

<img src="/img/async/concurrent-burgers/concurrent-burgers-06.png" class="illustration">

    } else if (cache != null) {
      listener.cacheMiss(call)
    }

    var networkResponse: Response? = null
    try {
      networkResponse = chain.proceed(networkRequest)
    } finally {
      // If we're crashing on I/O or otherwise, don't leak the cache body.
      if (networkResponse == null && cacheCandidate != null) {
        cacheCandidate.body.closeQuietly()
      }
    }