kanes

import multiprocessing
import time
import os

def process_task(name, duration):
    """時間のかかるタスクをシミュレート"""
    print(f"プロセス {name} (PID: {os.getpid()}) が開始、所要時間 {duration} 秒...")
    time.sleep(duration)
    print(f"プロセス {name} (PID: {os.getpid()}) が終了")

if __name__ == "__main__": # Windows ではこの保護が必要
    print("--- マルチプロセスの例を開始 ---")
    start_time = time.time()

    # 2つのプロセスを作成
    p1 = multiprocessing.Process(target=process_task, args=("プロセスA", 2))
    p2 = multiprocessing.Process(target=process_task, args=("プロセスB", 3))

    # プロセスを開始
    p1.start()
    p2.start()

    # すべてのプロセスが完了するのを待つ
    p1.join()
    p2.join()

    end_time = time.time()
    print(f"--- マルチプロセスの例が終了、総所要時間: {end_time - start_time:.2f} 秒 ---")
    # 理論的には、CPU がマルチコアで、2つのタスクがどちらも CPU 集中型の場合、総所要時間は max(2, 3)=3秒に近くなる
    # しかし、ここでは sleep を使って I/O をシミュレートしているため、総所要時間は依然として max(2, 3)=3秒に近くなるが、重要なのはそれらが並行して実行されていること

import threading
import time
import os

def thread_task(name, duration):
    """時間のかかるタスクをシミュレート"""
    # 注意：ここでは I/O 集中型タスク（待機）をシミュレートしています
    print(f"スレッド {name} (PID: {os.getpid()}) が開始、所要時間 {duration} 秒...")
    time.sleep(duration)
    print(f"スレッド {name} (PID: {os.getpid()}) が終了")

if __name__ == "__main__": # threading は強制ではありませんが、慣習的にここに置きます
    print("--- マルチスレッドの例を開始 ---")
    start_time = time.time()

    # 2つのスレッドを作成
    t1 = threading.Thread(target=thread_task, args=("スレッドA", 2))
    t2 = threading.Thread(target=thread_task, args=("スレッドB", 3))

    # スレッドを開始
    t1.start()
    t2.start()

    # すべてのスレッドが完了するのを待つ
    t1.join()
    t2.join()

    end_time = time.time()
    print(f"--- マルチスレッドの例が終了、総所要時間: {end_time - start_time:.2f} 秒 ---")
    # I/O をシミュレートしているため（sleep は GIL を解放します）、総所要時間は max(2, 3)=3秒に近くなります。
    # もし純粋な CPU 計算タスクであれば、GIL の影響を受け、総所要時間は 2+3=5秒に近くなるでしょう。

import asyncio
import time
import os

async def async_task(name, duration):
    """非同期の時間のかかるタスクをシミュレート"""
    # 注意：ここでは必ず await asyncio.sleep() を使用して非同期待機をシミュレートする必要があります
    print(f"コルーチン {name} (PID: {os.getpid()}) が開始、所要時間 {duration} 秒...")
    await asyncio.sleep(duration) # <-- 重要：コルーチンはここで制御を放棄します
    print(f"コルーチン {name} (PID: {os.getpid()}) が終了")

async def main():
    """メインコルーチン、他のコルーチンを作成して実行します"""
    print("--- コルーチンの例を開始 ---")
    start_time = time.time()

    # 2つのコルーチンオブジェクトを作成
    task1 = async_task("コルーチンA", 2)
    task2 = async_task("コルーチンB", 3)

    # asyncio.gather を使用してコルーチンを並行して実行し、完了を待つ
    await asyncio.gather(task1, task2)

    end_time = time.time()
    print(f"--- コルーチンの例が終了、総所要時間: {end_time - start_time:.2f} 秒 ---")
    # 総所要時間は max(2, 3)=3秒に近くなります。なぜなら、待機中に切り替えが可能だからです。
    
if __name__ == "__main__":
    asyncio.run(main()) # イベントループを起動し、メインコルーチンを実行します

    # エラー例：通常の関数内で await を使用
    # def blocking_function(): # async が欠けている
    #     await asyncio.sleep(1) # SyntaxError: 'await' not in async function
    #     print("これは実行できません")

# これは Python コルーチン (asyncio) の一般的なコードテンプレートです

import asyncio
import time
import random # 異なるタスクの所要時間をシミュレートするために random をインポート

# =============================================================================
# ステップ 1: 独立した非同期タスク (コルーチン関数) を定義
# async def キーワードを使用して定義し、これはコルーチン関数であることを示します。
# コルーチン関数内では await を使用して他の待機可能オブジェクト（非同期 I/O 操作、asyncio が提供する非同期ツール、または他のコルーチン）を呼び出します。
# これらの関数には通常、実際の非同期作業負荷が含まれます。
# =============================================================================
async def async_worker_task(task_id: int, simulate_duration: int):
    """
    非同期作業タスクのコルーチン関数を定義します。

    Args:
        task_id: タスクの一意の識別子。
        simulate_duration: タスクがかかる秒数をシミュレートします（実際には await asyncio.sleep の時間）。
    """
    # タスク開始時の印刷、通常、複数のタスクの「開始」印刷がほぼ同時に表示されます
    print(f"[タスク {task_id}] 実行を開始、予想所要時間 {simulate_duration} 秒...")

    # await を使用して非同期操作を実行します。
    # asyncio.sleep() は待機可能オブジェクトであり、await すると現在のコルーチンは一時停止し、
    # 制御がイベントループに渡され、イベントループは他の準備が整ったコルーチンを実行できます。
    # これは、ネットワーク応答、データベースクエリ結果などの非同期 I/O 操作を待機するプロセスをシミュレートし、その間スレッド全体をブロックしません。
    await asyncio.sleep(simulate_duration)

    # タスク完了時の印刷
    print(f"[タスク {task_id}] 実行完了。")

    # タスクは結果を返すことができます
    return f"タスク {task_id} 完了、所要時間 {simulate_duration} 秒。"


# =============================================================================
# ステップ 2: メイン非同期関数 (オーケストレーター / エントリ)
# これは全体の非同期プログラムのエントリポイントであり、async def 関数でもあります。
# 他のコルーチンタスクを作成、組織、スケジュールする役割を担います。
# 通常、ここで asyncio.gather または asyncio.create_task を使用して複数のタスクの並行実行を管理します。
# =============================================================================
async def main_async_orchestrator():
    """
    メイン非同期関数、worker タスクを作成して実行します。
    """
    print("主オーケストレーター: 非同期プロセス開始")
    start_time = time.time()

    # タスクのパラメータを準備
    task_configurations = [
        (1, random.randint(1, 4)), # タスク1、1-4秒のランダム所要時間
        (2, random.randint(2, 5)), # タスク2、2-5秒のランダム所要時間
        (3, random.randint(1, 3)), # タスク3、1-3秒のランダム所要時間
        (4, random.randint(3, 6)), # タスク4、3-6秒のランダム所要時間
    ]

    # =========================================================================
    # ステップ 3: コルーチンオブジェクトを作成
    # async def 関数を呼び出すとコルーチンオブジェクトが返されます。この時点ではコルーチン内部のコードはまだ実行されていません。
    # =========================================================================
    # コルーチンオブジェクトのリストを作成
    coroutine_objects = [
        async_worker_task(task_id, duration)
        for task_id, duration in task_configurations
    ]
    print(f"主オーケストレーター: {len(coroutine_objects)} 個のコルーチンオブジェクトを作成しました。")


    # =========================================================================
    # ステップ 4: コルーチンタスクを並行して実行
    # asyncio.gather() を使用することが最も一般的な方法であり、リスト内のすべての「待機可能オブジェクト」
    # （コルーチンオブジェクトや Task オブジェクトを含む）を並行して実行し、すべての完了を待ちます。
    # await asyncio.gather(...) は現在のメインコルーチンを一時停止し、制御をイベントループに渡します。
    # イベントループは coroutine_objects 内のコルーチンを同時にスケジュールして実行します。
    # すべてのコルーチンが完了すると、gather はすべてのコルーチンの返り値を含むリストを返します。
    # =========================================================================
    print("主オーケストレーター: asyncio.gather を使用してタスクを並行して実行します...")
    # await はここでの重要な部分であり、メインコルーチンはここでサブタスクがすべて完了するのを待ちます
    results = await asyncio.gather(*coroutine_objects)

    print("主オーケストレーター: すべての並行タスクが完了しました。")
    print("主オーケストレーター: すべてのタスクの結果は以下の通りです:")
    for res in results:
        print(f"- {res}")

    # =========================================================================
    # オプション: asyncio.create_task を使用してタスクを作成し、すぐに待機しない
    # 特定のタスクを待機せずにバックグラウンドで実行させたい場合、asyncio.create_task() を使用できます。
    # background_task = asyncio.create_task(some_other_async_task())
    # print("主オーケストレーター: バックグラウンドタスクを起動しました...")
    # 注意：メインコルーチンがバックグラウンドタスクが完了する前に終了すると、バックグラウンドタスクはキャンセルされる可能性があります。
    # バックグラウンドタスクが完了することを確実にするには、どこかで await background_task をする必要があります。
    # =========================================================================

    end_time = time.time()
    print(f"主オーケストレーター: 非同期プロセス終了。総所要時間: {end_time - start_time:.2f} 秒")


# =============================================================================
# ステップ 5: プログラムのエントリポイント
# 標準の if __name__ == "__main__": 保護ブロックを使用します。
# ここで asyncio.run() を呼び出してイベントループを起動し、トップレベルのメイン非同期関数を実行します。
# asyncio.run() は Python 3.7+ で推奨される方法であり、イベントループを作成し、
# 渡されたコルーチンを完了するまで実行し、最後にイベントループを閉じます。
# =============================================================================
if __name__ == "__main__":
    print("プログラム開始")
    # asyncio.run() を呼び出して私たちのメイン非同期関数 main_async_orchestrator を実行します
    asyncio.run(main_async_orchestrator())
    print("プログラムは完全に終了しました。")

プログラム開始
主オーケストレーター: 非同期プロセス開始
主オーケストレーター: 4 個のコルーチンオブジェクトを作成しました。
主オーケストレーター: asyncio.gather を使用してタスクを並行して実行します...
[タスク 1] 実行を開始、予想所要時間 2 秒...
[タスク 2] 実行を開始、予想所要時間 5 秒...
[タスク 3] 実行を開始、予想所要時間 2 秒...
[タスク 4] 実行を開始、予想所要時間 5 秒...
[タスク 1] 実行完了。
[タスク 3] 実行完了。
[タスク 2] 実行完了。
[タスク 4] 実行完了。
主オーケストレーター: すべての並行タスクが完了しました。
主オーケストレーター: すべてのタスクの結果は以下の通りです: 
- タスク 1 完了、所要時間 2 秒。    
- タスク 2 完了、所要時間 5 秒。
- タスク 3 完了、所要時間 2 秒。
- タスク 4 完了、所要時間 5 秒。
主オーケストレーター: 非同期プロセス終了。総所要時間: 5.00 秒
プログラムは完全に終了しました。