🚥 👆 ⚙️ 🥉 🥳 🗃 👈 💬 👆 🤙 👫 ⏮️ `await`, 💖:

```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`.

///

---

# هم‌زمانی و async / await

جزئیات در مورد سینتکس `async def` برای *توابع عملیات مسیر* و یه کم پیش‌زمینه در مورد کد ناهم‌زمان، هم‌زمانی و موازی‌سازی.

## عجله داری؟

<abbr title="خیلی طولانی بود؛ نخوندم"><strong>TL;DR:</strong></abbr>

اگه از کتابخونه‌های سوم‌شخصی استفاده می‌کنی که بهت می‌گن با `await` صداشون کنی، مثل:

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

اون وقت، *توابع عملیات مسیرت* رو با `async def` تعریف کن، اینجوری:

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

  @ParameterizedTest
  @ArgumentsSource(ProtocolParamProvider::class)
  fun noRecoveryFromRefusedStreamWithRetryDisabled(protocol: Protocol) {

            te = null;
            thread = new Thread(this, name);
            thread.setDaemon(true);

            synchronized (thread) {
                thread.start();
                thread.wait(timeout); /* wait for doConnect */

                switch (state) {
                case 1: /* doConnect never returned */
                    state = 0;
                    thread = null;

Luego podemos crear un `AsyncClient` con la app y enviar requests asíncronos a ella, usando `await`.

{* ../../docs_src/async_tests/test_main.py hl[9:12] *}

Esto es equivalente a:

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

...que usábamos para hacer nuestros requests con el `TestClient`.

/// tip | Consejo

Nota que estamos usando async/await con el nuevo `AsyncClient`: el request es asíncrono.

///

            assertTrue(processHelper.isProcessRunning());

            // Wait a bit for the processes to start
            Thread.sleep(50);

            // Destroy all processes
            processHelper.destroy();

            // Wait a bit for destruction to complete
            Thread.sleep(100);

            assertFalse(processHelper.isProcessRunning());

 * Object x = new MyClass() {
 *   ...
 *   protected void finalize() { latch.countDown(); ... }
 * };
 * x = null;  // Hint to the JIT that x is stack-unreachable
 * GcFinalization.await(latch);
 * }
 *
 * <p>Here's an example that uses a user-defined finalization predicate:
 *
 * {@snippet :
 * final WeakHashMap<Object, Object> map = new WeakHashMap<>();
 * map.put(new Object(), Boolean.TRUE);

			}

			now := time.Now()
			if now.Sub(u.Queued) < time.Second {
				// let recently failed networks to reconnect
				// making MRF wait for 1s before retrying,
				// i.e 4 reconnect attempts.
				time.Sleep(time.Second)
			}

			// wait on timer per heal
			wait := healSleeper.Timer(context.Background())

			scan := madmin.HealNormalScan
			if u.BitrotScan {
				scan = madmin.HealDeepScan
			}

 * Marker interface for objects that use the JVM's `synchronized` mechanism and the related
 * `wait()` and `notify()` functions.
 *
 * The Lockable interface is particularly handy because it ensures we lock the right `this` when
 * there are multiple `this` objects in scope.
 */
interface Lockable

internal inline fun Lockable.wait() = (this as Object).wait()

internal inline fun Lockable.notify() = (this as Object).notify()

# 並行処理と async / await

*path operation 関数*のための `async def` に関する詳細と非同期 (asynchronous) コード、並行処理 (Concurrency)、そして、並列処理 (Parallelism) の背景について。

## 急いでいますか？

<abbr title="too long; didn't read (長すぎて読めない人のための要約という意味のスラング)"><strong>TL;DR:</strong></abbr>

次のような、`await` を使用して呼び出すべきサードパーティライブラリを使用している場合:

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

以下の様に `async def` を使用して*path operation 関数*を宣言します。

```Python hl_lines="2"
@app.get('/')