override fun isDone(): Boolean = result != null

    override fun get(): T {
        outcomeLatch.await()
        return getOrThrow()
    }

    override fun get(timeout: Long, unit: TimeUnit): T =
        if (outcomeLatch.await(timeout, unit)) getOrThrow()
        else throw TimeoutException()

    private
    fun getOrThrow() = (result as Result<T>).getOrThrow()

        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 {
                    doneSignal.countDown()
                } finally {

                    def workQueue2 = submit(ParallelWorkAction.class, [ "item3" ])

                    signal("submitted")

                    workQueue1.await()

                    signal("finished")
                }
            }
        """

        def started = blockingHttpServer.expectConcurrentAndBlock("item1", "item2", "item3", "submitted")

```Python hl_lines="9-10"
{!../../../docs_src/async_tests/test_main.py!}
```

Das ist das Äquivalent zu:

```Python
response = client.get('/')
```

... welches wir verwendet haben, um unsere Requests mit dem `TestClient` zu machen.

!!! tip "Tipp"

Then we can create an `AsyncClient` with the app, and send async requests to it, using `await`.

```Python hl_lines="9-10"
{!../../../docs_src/async_tests/test_main.py!}
```

This is the equivalent to:

```Python
response = client.get('/')
```

...that we used to make our requests with the `TestClient`.

!!! tip
    Note that we're using async/await with the new `AsyncClient` - the request is asynchronous.

!!! warning

* `read(size)`：按指定数量的字节或字符（`size` (`int`)）读取文件内容；
* `seek(offset)`：移动至文件 `offset` （`int`）字节处的位置；
    * 例如，`await myfile.seek(0) ` 移动到文件开头；
    * 执行 `await myfile.read()` 后，需再次读取已读取内容时，这种方法特别好用；
* `close()`：关闭文件。

因为上述方法都是 `async` 方法，要搭配「await」使用。

例如，在 `async` *路径操作函数* 内，要用以下方式读取文件内容：

```Python
contents = await myfile.read()
```

在普通 `def` *路径操作函数*  内，则可以直接访问 `UploadFile.file`，例如：

```Python

                    assert lockIsHeld(sharedResourceLock)
                    coordinationService.withStateLock(unlock(sharedResourceLock))
                }
            }
            started.await()
            instant.releaseAll
        }

        then:
        noExceptionThrown()
    }

    def "locks on different shared resources can be concurrently held"() {
        given:

      throw RuntimeException("boom!")
    }

    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(200)) {
      log.put("normal task running")
      return@schedule -1L
    }

    queue.idleLatch().await(500, TimeUnit.MILLISECONDS)

    assertThat(log.take()).isEqualTo("failing task running")
    assertThat(log.take()).isEqualTo("uncaught exception: java.lang.RuntimeException: boom!")

                doLast {
                  startLatch.countDown() // allow b to finish
                  stopLatch.await() // wait for d to start
                }
              }
            }

            project(":b") {
              task t {
                doLast {
                  startLatch.await() // wait for a to start
                }
              }
            }

            client.connection.connect()
            client.outgoingService1.doStuff("from client 1")
            client.outgoingService1.doStuff("from client 2")
        }
        received.await()
        client.stop()
        server.stop()

        then:
        1 * serverService.doStuff("from client 1")
        1 * serverService.doStuff("from client 2") >> { received.countDown() }