原因はコードの構造と KeyboardInterrupt の伝播の仕組みにあります。今の書き方だと、KeyboardInterrupt が try ブロックで捕まえられないのは当然です。順を追って説明します。

問題点 1：multiprocessing.Process は親プロセスとは別プロセス

python
multiprocessing.Process(target=dataserverThread).start()

• この行で新しいプロセスを作っています。

• 子プロセス内で asyncio.run() が走ります。

• Ctrl+C を押すと、親プロセスと複数の子プロセスに KeyboardInterrupt が送られる場合がありますが、try/except があるのは親プロセスだけ。

• 子プロセス内で例外が発生しても親プロセスの except KeyboardInterrupt: には届きません。

• そのため「KeyboardInterruptがつかめない」ように見えます。

問題点 2：try ブロックが if __name__ == "__main__": の外にある

python
try:
    if __name__ == "__main__":
        multiprocessing.Process(...).start()

• try ブロックは親プロセス内でしか効かない。

• KeyboardInterrupt は、プロセス内で同期的に待機しているコード (time.sleep や input や asyncio.run) に届きます。

• 親プロセスはすぐに Process.start() を実行したら終了してしまうので、待機していません。

• つまり try ブロックの中では何も待っていないので、KeyboardInterrupt が入っても捕まえられない。

問題点 3：子プロセスの asyncio.run では KeyboardInterrupt は asyncio 内で処理される

• asyncio.run() は KeyboardInterrupt をキャッチすると CancelledError に変換する場合があります。

• そのため、asyncio.run 内で KeyboardInterrupt を捕まえるには、子プロセス内で try/except を使う必要があります。

正しい捕まえ方の例

子プロセス内でも KeyboardInterrupt を捕まえる構造にするのが安全です。

python
def dataserverThread():
    try:
        asyncio.run(dataserver())
    except KeyboardInterrupt:
        print("Dataserver thread stopped by KeyboardInterrupt")

def serviceThread():
    try:
        asyncio.run(tasks.taskController(loadSettings.settings["taskInterval"]))
    except KeyboardInterrupt:
        print("Service thread stopped by KeyboardInterrupt")

if __name__ == "__main__":
    print("This dataserver is started.")
    dataserver_process = multiprocessing.Process(target=dataserverThread)
    service_process = multiprocessing.Process(target=serviceThread)
    dataserver_process.start()
    service_process.start()
    
    try:
        dataserver_process.join()
        service_process.join()
    except KeyboardInterrupt:
        print("Stopping all processes...")
        dataserver_process.terminate()
        service_process.terminate()
        dataserver_process.join()
        service_process.join()
        print("All processes stopped.")
        sys.exit()

ポイント：

1. 子プロセス内でも try/except を使う

2. 親プロセスは join() で待機し、KeyboardInterrupt が来たら terminate()

3. asyncio.run() は子プロセス内で正しくキャンセルされる

まとめると

• あなたのコードで「KeyboardInterrupt がつかめない」のは、try ブロックが親プロセスでしか効かないことと、子プロセス内で async 関数が実行されているため。

• 3つ出ている KeyboardInterrupt は：

  1. 親プロセス

  2. dataserverThread プロセス

  3. serviceThread プロセス
     の3つです。

• 親だけで try/except しても、子プロセスは捕まえられません。

必要なら、子プロセスを安全に終了させる方法もあります。

あなたのコードに近い形で、KeyboardInterrupt を親子両方で正しく処理できる例を作ることもできます。

おっしゃる通りです。親プロセスの try ブロックで KeyboardInterrupt を捕まえられないのは、親プロセス自身がすぐに Process.start() を実行して終了してしまう構造になっていることが原因です。

具体的にいうと、元のコードでは：

python
try:
    if __name__ == "__main__":
        multiprocessing.Process(target=dataserverThread).start()
        multiprocessing.Process(target=serviceThread).start()

• Process.start() はプロセスを起動してすぐに制御を返すだけです。

• 親プロセスは start() を呼んだ後、すぐに try ブロックを抜けて終了してしまいます。

• そのため、親プロセスは KeyboardInterrupt を受け取る待機状態になっていないので、例外が捕まらないように見えます。

一方で、私の例でやったように：

python
dataserver_process.join()
service_process.join()

• join() によって親プロセスは子プロセスの終了を待機する状態になります。

• この待機中に Ctrl+C が押されると、親プロセスは KeyboardInterrupt を受け取り、except ブロックで捕まえられるようになります。

ですので、親プロセスで KeyboardInterrupt を捕まえたい場合は、少なくともどこかでブロック待機（join() など）をして、プロセスが終了するまで親が生きている必要がある、という理解で正しいです。

dataserverThread 内で asyncio.run(dataserver()) を呼んでいる場合、dataserver 関数の中でも例外処理したい場合は、asyncio.run の外ではなく中で try/except を書くことになります。例えば：

python
async def dataserver():
    try:
        async with serve(mainLoop, loadSettings.settings["ip"], loadSettings.settings["port"]) as server:
            await server.serve_forever()
    except KeyboardInterrupt:
        print("Dataserver async function caught KeyboardInterrupt")
        # 必要に応じてサーバを閉じる処理

こうすると、asyncio.run(dataserver()) を呼ぶときに、dataserver 内部で KeyboardInterrupt を捕まえて処理できます。

ポイント：

• asyncio.run は基本的に KeyboardInterrupt をキャッチして asyncio タスクをキャンセルします。

• 上のように async with serve(...) の中で try/except を置くことで、サーバの実行中に Ctrl+C が押されたときに、asyncio 内で捕まえてクリーンアップ処理が可能になります。

• 外側の dataserverThread の try/except は、万一内部で捕まえられなかった例外や他のエラーのために残しておくのが良いです。

この構造だと、mainLoop 内での KeyboardInterrupt は ほとんど捕まえられません。理由は以下の通りです：

理由 1：asyncio.run と KeyboardInterrupt の挙動

• asyncio.run(coro) は、実行中に Ctrl+C が押されると、Python 標準の KeyboardInterrupt を受け取り、内部で全てのタスクを CancelledError に変換してキャンセルします。

• そのため、mainLoop 内で except KeyboardInterrupt: を書いても、通常はそこに例外は届かず、asyncio.CancelledError が発生します。

理由 2：serve_forever の中でのキャンセル

• async with serve(...) as server の中で await server.serve_forever() をしている場合、serve_forever() は内部でタスクを管理しているので、KeyboardInterrupt が入ると サーバ全体のタスクがキャンセルされる形で propagate されます。

• そのため、mainLoop 内で try/except しても、receiveLoop に直接 KeyboardInterrupt が届くことはありません。

実務的に捕まえるには

• mainLoop 内で何かクリーンアップをしたい場合は、CancelledError を捕まえる必要があります：

python
async def mainLoop(websocket):
    try:
        await receiveLoop(websocket, controller.controller)
    except asyncio.CancelledError:
        print("The dataserver mainLoop is cancelled.")
        await websocket.close()

• これで、dataserverThread 内で Ctrl+C が押され、asyncio.run(dataserver()) がキャンセルされた場合でも、mainLoop 内でクリーンアップが可能になります。

ポイント

1. KeyboardInterrupt は asyncio の中では直接届かず、タスクキャンセル (CancelledError) に変換される。

2. mainLoop 内で例外処理したい場合は CancelledError を捕まえる。

3. dataserver 全体で KeyboardInterrupt を処理したい場合は dataserverThread 側で try/except を使う。

この構造を踏まえると、asyncio 内では Ctrl+C に対して CancelledError を使って例外処理するのが正しい方法です。