override fun ensureLoaded() {
    if (!listRead.get() && listRead.compareAndSet(false, true)) {
      readTheListUninterruptibly()
    } else {
      try {
        readCompleteLatch.await()
      } catch (_: InterruptedException) {
        Thread.currentThread().interrupt() // Retain interrupted status.
      }
    }

    if (!::bytes.isInitialized) {
      // May have failed with an IOException

En este caso, la función de tarea escribirá en un archivo (simulando el envío de un email).

Y como la operación de escritura no usa `async` y `await`, definimos la función con un `def` normal:

{* ../../docs_src/background_tasks/tutorial001_py39.py hl[6:9] *}

## Agregar la tarea en segundo plano { #add-the-background-task }

/// note | 技術詳細

`from starlette.websockets import WebSocket` を使用しても構いません.

**FastAPI** は開発者の利便性のために、同じ `WebSocket` を提供します。しかし、こちらはStarletteから直接提供されるものです。

///

## メッセージの送受信

WebSocketルートでは、 `await` を使ってメッセージの送受信ができます。

{* ../../docs_src/websockets/tutorial001.py hl[48:52] *}

バイナリやテキストデータ、JSONデータを送受信できます。

## 試してみる

ファイル名が `main.py` である場合、以下の方法でアプリケーションを実行します。

<div class="termy">

```console

      Future<?> possiblyIgnoredError = executorService.submit(executeTask);
      returnValue += (int) listenerLatch.getCount();
      listenerLatch.await();
    }
    return returnValue;
  }

  @Benchmark
  int executeThenAdd_multiThreaded(int reps) throws InterruptedException {
    Runnable addTask =
        new Runnable() {
          @Override

	readSetAt               time.Time
	writeDeadline           time.Duration // sets the write deadline on a connection.
	writeSetAt              time.Time
	abortReads, abortWrites atomic.Bool // A deadline was set to indicate caller wanted the conn to time out.
	infReads, infWrites     atomic.Bool
	mu                      sync.Mutex
}

// Unwrap will unwrap the connection and remove the deadline if applied.

	}
	for i, testCase := range testCases {
		if _, s3Error := checkAdminRequestAuth(ctx, testCase.Request, policy.AllAdminActions, globalSite.Region()); s3Error != testCase.ErrCode {
			t.Errorf("Test %d: Unexpected s3error returned wanted %d, got %d", i, testCase.ErrCode, s3Error)
		}
	}
}

func TestValidateAdminSignature(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

```Python
with open("file.txt") as file:
    file.read()
```

Python 的最近几个版本也有了一个**异步上下文管理器**，你可以通过 `async with` 来使用：

```Python
async with lifespan(app):
    await do_stuff()
```

你可以像上面一样创建了一个上下文管理器或者异步上下文管理器，它的作用是在进入 `with` 块时，执行 `yield` 之前的代码，并且在离开 `with` 块时，执行 `yield` 后面的代码。

但在我们上面的例子里，我们并不是直接使用，而是传递给 FastAPI 来供其使用。

   * missRate =~ 1.0}. Cache misses include all requests which weren't cache hits, including
   * requests which resulted in either successful or failed loading attempts, and requests which
   * waited for other threads to finish loading. It is thus the case that {@code missCount >=
   * loadSuccessCount + loadExceptionCount}. Multiple concurrent misses for the same key will result
   * in a single load operation.
   */

   * missRate =~ 1.0}. Cache misses include all requests which weren't cache hits, including
   * requests which resulted in either successful or failed loading attempts, and requests which
   * waited for other threads to finish loading. It is thus the case that {@code missCount >=
   * loadSuccessCount + loadExceptionCount}. Multiple concurrent misses for the same key will result
   * in a single load operation.
   */

          fail("")
        }
      },
    )
    assertThat(server.takeRequest().exchangeIndex)
      .isEqualTo(expectedSequenceNumber)
    responseDequeuedLatch!!.await()
    call.cancel()
    requestCanceledLatch!!.countDown()
    latch.await()
  }

  @Test
  fun noRecoveryFromRefusedStreamWithRetryDisabled() {
    noRecoveryFromErrorWithRetryDisabled(ErrorCode.REFUSED_STREAM)
  }

  @Test