import java.util.concurrent.TimeUnit;

            public class Block {
                public static void main(String[] args) throws InterruptedException {
                    new CountDownLatch(1).await(90, TimeUnit.SECONDS);
                }
            }
        """
        buildFile << """
            apply plugin: 'java'
            task block(type: JavaExec) {

  //      */
  //     public void await(AtomicBoolean flag) {
  //         await(flag, LONG_DELAY_MS);
  //     }

  //     /**
  //      * Spin-waits up to the specified timeout until flag becomes true.
  //      */
  //     public void await(AtomicBoolean flag, long timeoutMillis) {
  //         long startTime = System.nanoTime();
  //         while (!flag.get()) {

                            client.inputStream.skip(client.inputStream.available())
                        }
                        client.shutdownOutput()
                        latch.await() // wait for the end of the test before closing the connection
                        println("Closing client ${client.remoteSocketAddress}")
                    }
                } catch (SocketException e) {

    public @Nullable Void call() throws InterruptedException {
      running = true;
      startLatch.countDown();
      stopLatch.await();
      running = false;
      return null;
    }

    public void waitForStart() throws InterruptedException {
      startLatch.await();
    }

    public void stop() {
      stopLatch.countDown();
    }

    public boolean isRunning() {

              }
            })
        .start();

    // wait for the computingEntry to be created
    computationStarted.await();
    cache.invalidateAll();
    // let the computation proceed
    computingLatch.countDown();
    // don't check cache.size() until we know the get("b") call is complete
    computationComplete.await();

                    submitWorkItem("workItem1")
                    submitWorkItem("workItem2")

                    if (${waitForResults}) {
                        workerExecutor.await()
                    }
                }
            }
        """
        blockingHttpServer.expectConcurrent("workItem0", "workItem1", "workItem2")

        expect:
        args("--max-workers=3")

          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
        ) {
          try {
            // Wait for request2 to guarantee we make 2 separate connections to the server.
            latch1.await()
          } catch (e: InterruptedException) {
            throw AssertionError(e)
          }
        }

        override fun connectionAcquired(

                        }
                    }
                }
            }
        }
        when:
        latch.await(5, TimeUnit.SECONDS)
        10_000.times {
            defaultSerializerRegistry.build(SerializableParent)
        }
        then:
        noExceptionThrown()
        conditions.await(5.0)
        where:
        // Rerun this test 10 times
        testIteration << (0..9)
    }

        }
    }

    void waitForRequests(int requestCount) {
        lock.lock();
        try {
            while (this.requestsStarted < requestCount) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
        } finally {
            lock.unlock();

```Python
results = await some_library()
```

В этом случае *функции обработки пути* необходимо объявлять с использованием синтаксиса `async def`:

```Python hl_lines="2"
@app.get('/')
async def read_results():
    results = await some_library()
    return results
```

!!! note
    `await` можно использовать только внутри функций, объявленных с использованием `async def`.

---