Python の async/await を徹底解説！コルーチンの仕組み

[![Group182.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/1308b208-a261-45ca-81ca-bab0ff77cd66.png)](https://leapcell.io/?lc_t=d_pyawait)



**[Leapcell: サーバーレスWebホスティングの最適選択](https://leapcell.io/?lc_t=d_pyawait)**

### Pythonの非同期プログラミング

Pythonには、コルーチン、マルチスレッディング、マルチプロセッシングなど、複数の非同期アプローチがあります。さらに、いくつかの従来の方法やサードパーティの非同期ライブラリもあります。この記事では主にコルーチンに焦点を当て、マルチスレッディングとマルチプロセッシングについても簡単に紹介します。

#### async/await
Pythonでは、`async`で宣言された関数は非同期関数で、しばしばコルーチンと呼ばれます。例えば：
```python
import asyncio

async def hello():
    await asyncio.sleep(1)
    print("hello leapcell")
```

##### 呼び出し方法
非同期関数の呼び出し方法は通常の関数と少し異なります。例えば、通常の関数の呼び出し方法は次の通りです：
```python
def hello():
    print("hello leapcell")

hello()
```

そして、非同期関数の呼び出し方法は次の通りです：
```python
import asyncio

async def hello():
    await asyncio.sleep(1)
    print("hello leapcell")

h = hello()
asyncio.run(h)
```

非同期関数を呼び出すとき、まず`h = hello()`を使うとコルーチンオブジェクトが返され、関数内のコードは実行されません。`asyncio.run(h)`関数または`await h`文を使った後で初めてコードが実行されます。次の例を見てください：
```python
import asyncio

async def async_function():
    print("This is inside the async function")
    await asyncio.sleep(1)
    return "Async function result"

# 正しい使い方
async def correct_usage():
    print("Correct usage:")
    result = await async_function()
    print(f"Result: {result}")

# awaitを使わずに呼び出す
def incorrect_usage():
    print("\nIncorrect usage:")
    coroutine = async_function()
    print(f"Returned object: {coroutine}")
    # 注意: "This is inside the async function"はここでは表示されません

# 待機されていないコルーチンを処理する
async def handle_unawaited_coroutine():
    print("\nHandling unawaited coroutine:")
    coroutine = async_function()
    try:
        # asyncio.run()を使ってコルーチンを実行する
        result = await coroutine
        print(f"Result after handling: {result}")
    except RuntimeWarning as e:
        print(f"Caught warning: {e}")

async def main():
    await correct_usage()
    incorrect_usage()
    await handle_unawaited_coroutine()

asyncio.run(main())
```

#### 非同期関数の一般的な呼び出し方法

##### asyncio.gather()
`gather`を使うと、複数のタスクを同時に開始し、並行して実行できます。すべてのタスクが完了して結果が返された後、その後のコードが続けて実行されます。例えば：
```python
import asyncio

async def num01():
    await asyncio.sleep(1)
    return 1

async def num02():
    await asyncio.sleep(1)
    return 2

async def combine():
    results = await asyncio.gather(num01(), num02())
    print(results)

asyncio.run(combine())
```
**出力**:
```
[1, 2]
```

上記には2つの非同期関数があります。ここで`asyncio.gather`を使ってこれら2つの関数を並行して実行し、`await`を使って結果を待ちます。返された結果は`results`に格納されます。

##### 直接awaitを使う
上記の`gather`メソッドは複数の非同期関数をまとめて並行して実行します。この方法以外にも、直接`await`キーワードを使うこともできます。次の例を見てください：
```python
import asyncio

async def hello():
    await asyncio.sleep(1)
    return "hello leapcell"

async def example():
    result = await hello()
    print(result)

asyncio.run(example())
```
**出力**:
```
hello leapcell
```

上記の`example`関数では、`await`を使って非同期関数の結果を待ちます。結果が返された後、それをコンソールに表示します。この方法は実際には逐次的に実行されます。なぜなら、コードは`await`文で結果が返されるまで待機し、その後のコードを続けて実行するからです。

ここで待たない場合はどうなるでしょうか？`result = hello()`を使うと、`hello()`内のコードは実行されず、返される`result`はコルーチンオブジェクトになります。

##### asyncio.create_task()
上記の方法以外に、もっと柔軟な方法があります。それは`asyncio.create_task()`を使う方法です。このメソッドはタスクを作成し、すぐにバックグラウンドで実行します。このとき、メイン関数は他の操作を行うことができます。非同期タスクの結果を取得する必要があるときは、`await`を使って取得します。次の例を見てください：
```python
import asyncio

async def number():
    await asyncio.sleep(1)
    return 1

async def float_num():
    await asyncio.sleep(1)
    return 1.0

async def example():
    n = asyncio.create_task(number())
    f = asyncio.create_task(float_num())
    print("do something...")

    print(await n)
    print(await f)

asyncio.run(example())
```
**出力**:
```
do something...
1
1.0
```

上記の出力からわかるように、`create_task`はまずタスクを作成して開始します。このとき、メイン関数はブロックされず、その後のコードを続けて実行します。非同期関数の結果が必要になったら、`await n`を呼び出して結果を取得します。このように、時間のかかるタスクを非同期コードに入れて実行し、必要なときにこれらの非同期関数の結果を取得することができます。

注意: `create_task`を使って非同期関数を呼び出す方法は、通常の関数の呼び出し方法とは異なります。通常の関数呼び出し方法`number()`を使うと、関数は実行されません。しかし、`create_task`を使って非同期関数を呼び出すと、関数はすぐに実行されます。`await`を使って結果を取得しなくても、関数はメイン関数が終了する前に実行を完了します。

#### セマフォ
`asyncio.Semaphore`はPythonの`asyncio`ライブラリにある同期プリミティブで、共有リソースへのアクセスを制御します。非同期プログラミングで非常に役立ち、特定のリソースに同時にアクセスできるコルーチンの数を制限できます。次のコードを見てください：
```python
import asyncio
import aiohttp

async def fetch(url, session, semaphore):
    async with semaphore:
        print(f"Fetching {url}")
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = [
        "http://example.com",
        "http://example.org",
        "http://example.net",
        "http://example.edu",
        "http://example.io",
    ]

    semaphore = asyncio.Semaphore(2)  # 同時リクエスト数を2に制限
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(url, session, semaphore) for url in urls]
        responses = await asyncio.gather(*tasks)

    for url, response in zip(urls, responses):
        print(f"URL: {url}, Response length: {len(response)}")

asyncio.run(main())
```

上記のコードでは、`asyncio.Semaphore(2)`を作成して同時リクエスト数を2に制限しています。非同期関数`fetch`では、`async with semaphore`を使ってセマフォを取得および解放しています。入る前には自動的に`acquire()`メソッドが呼び出されてセマフォを取得し、`with`ブロックを抜けるときに`release()`メソッドが呼び出されてセマフォを解放します。`Semaphore`を使うことで、同時リクエスト数を制御でき、サーバーに過度の負荷をかけることを防ぐことができます。データベース接続などの制限されたリソースを扱うときに非常に役立ちます。同時に、システムパフォーマンスを最適化し、並行性のバランスを見つけることができます。

##### セマフォの原理
内部的にはカウンターを維持しています。カウンターがゼロより大きいときはアクセスが許可され、ゼロに等しいときはアクセスが禁止されます。カウンターを取得および解放するメソッドはそれぞれ`acquire()`と`release()`です。初期化時に初期カウンター値を指定する必要があります。その後、コード内でカウンター値を制御することで、同時リクエスト数を制御します。

#### マルチスレッディング
マルチスレッディングは従来の並行タスク実行方法で、I/Oバウンドタスクに適しています。次の例を見てください：
```python
import threading
import time

def worker(name):
    print(f"Worker {name} starting")
    time.sleep(2)  # 時間のかかる操作をシミュレート
    print(f"Worker {name} finished")

def main():
    threads = []
    for i in range(3):
        t = threading.Thread(target=worker, args=(i,))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

    print("All workers finished")

if __name__ == "__main__":
    main()
```

マルチスレッディングの`t.join()`は、3つのスレッドの完了を待つために使われます。スレッドまたはプロセスオブジェクトで`join()`メソッドを呼び出すと、呼び出し元のスレッド（通常はメインスレッド）は、`join()`が呼び出されたスレッドまたはプロセスが実行を完了するまでブロックされます。

#### マルチプロセッシング
マルチプロセッシングはCPUバウンドタスクに適しており、マルチコアプロセッサを最大限に活用できます。次の例を見てください：
```python
import multiprocessing
import time

def worker(name):
    print(f"Worker {name} starting")
    time.sleep(2)  # 時間のかかる操作をシミュレート
    print(f"Worker {name} finished")

if __name__ == "__main__":
    processes = []
    for i in range(3):
        p = multiprocessing.Process(target=worker, args=(i,))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    print("All workers finished")
```

### まとめ
上記の非同期方法以外にも、Pythonには他の非同期アプローチがあります。例えば、コールバック関数を使う方法やGeventなどのサードパーティライブラリを使う方法です。それぞれの方法には独自の利点と制限があります。例えば、スレッドはI/Oバウンドタスクに適していますが、GIL（グローバルインタープリターロック）の制限を受けます。マルチプロセッシングはCPUバウンドタスクに適していますが、メモリオーバーヘッドが大きいです。サードパーティライブラリは特殊な機能や最適化を提供しますが、プロジェクトの複雑さを増す可能性があります。これに対して、`async/await`構文はより現代的で読みやすい非同期プログラミング方法を提供しており、現在Pythonで非同期操作を扱うために推奨される方法です。 

# [Leapcell: サーバーレスWebホスティングの最適選択](https://leapcell.io/?lc_t=d_pyawait)

最後に、Pythonサービスのデプロイに最適なプラットフォームを紹介します：**[Leapcell](https://leapcell.io/?lc_t=d_pyawait)**

[![brandpic7.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/c0c6d11e-ea80-48fb-ba5a-ad22a64512c3.png)](https://leapcell.io/?lc_t=d_pyawait)


### 🚀 好きな言語で構築
JavaScript、Python、Go、またはRustで簡単に開発できます。  

### 🌍 無制限のプロジェクトを無料でデプロイ
使用した分だけ料金がかかります。リクエストがなければ料金はかかりません。  

### ⚡ 従量課金制、隠れた費用は一切ありません
アイドル料金はなく、スムーズなスケーラビリティが保証されます。  

[![Frame3-withpadding2x.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/d4fe6030-f211-43e5-875a-d605c4acf2b9.png)](https://leapcell.io/?lc_t=d_pyawait)


[📖 ドキュメントを探索する](https://docs.leapcell.io/)  

🔹 Twitterでフォローしましょう: [@LeapcellHQ](https://x.com/LeapcellHQ)