Pythonにおけるquitとexitの使い分けや注意点を解説まとめ

●Pythonにおけるquitとexitの基本
- ○quitとexitの違いとは？
- ○それぞれの使用シーンと注意点
●Pythonプログラムの終了方法を詳しく解説
●quitとexitの応用テクニック
●Pythonプログラムの中断と再開
●よくあるエラーと対処法
●Pythonの終了処理ベストプラクティス
まとめ

●Pythonにおけるquitとexitの基本

Pythonプログラミングを始めて間もない方や、プログラムの終了処理に不安を感じている方も多いのではないでしょうか。

プログラムの適切な終了方法を知ることは、安定したアプリケーションを開発する上で非常に重要です。

今回は、Pythonにおけるquitとexitの基本的な使い方と違いについて詳しく解説します。

○quitとexitの違いとは？

quitとexitは一見似たような機能を持つように見えますが、実際にはいくつかの重要な違いがあります。

まず、quitは対話モードで使用されることが多い関数です。

一方、exitはプログラムを終了するために使用される関数です。

quitは、Pythonの対話モードを終了するために使用されます。

通常、対話モードでプログラムを書いている際に、セッションを終了したい場合に使用します。

例えば、次のように使用します。

>>> quit()

exitは、Pythonスクリプトを終了するために使用されます。

プログラムの実行中に特定の条件が満たされた場合や、エラーが発生した際にプログラムを終了させたい場合に使用します。

exitは、sysモジュールからインポートして使用します。

import sys

# プログラムの途中で終了させたい場合
if condition:
    sys.exit()

○それぞれの使用シーンと注意点

quitとexitの使用シーンは異なります。

quitは主に対話モードで使用され、exitはスクリプト内でプログラムを終了させるために使用されます。

quitの使用シーン

対話モードでPythonセッションを終了したい場合
IPythonなどの対話型環境を終了する場合

exitの使用シーン

スクリプト内でプログラムを終了させたい場合
エラーが発生した際にプログラムを安全に終了させたい場合
特定の条件が満たされた時にプログラムを終了させたい場合

注意点として、quitやexitを頻繁に使用することは推奨されません。

プログラムの流れを制御するためには、適切な条件分岐や例外処理を使用することが望ましいです。

また、exitを使用する際は、sys.exitを使用することが一般的です。

import sys

def main():
    # プログラムのメイン処理
    pass

if __name__ == "__main__":
    try:
        main()
    except Exception as e:
        print(f"エラーが発生しました: {e}")
        sys.exit(1)

上記の例では、メイン処理で例外が発生した場合にエラーメッセージを表示し、sys.exit(1)を使用してプログラムを終了させています。

終了コード1は、一般的にエラーが発生したことを表すために使用されます。

●Pythonプログラムの終了方法を詳しく解説

Pythonプログラムの適切な終了方法を理解することは、安定したアプリケーションを開発する上で非常に重要です。

プログラムが予期せぬ動作をした場合や、特定の条件が満たされた際に正しく終了させる必要があります。

ここでは、Pythonプログラムの終了方法について詳しく解説します。

○sys.exitを使った終了方法

sys.exitは、Pythonプログラムを終了させるための標準的な方法です。

sysモジュールをインポートして使用します。

sys.exitを使用すると、プログラムはクリーンアップ処理を行ってから終了します。

sys.exitの基本的な使い方は次の通りです。

import sys

# プログラムの処理

sys.exit()

sys.exitは引数を取ることができ、終了コードを指定することができます。

終了コードを指定しない場合、デフォルトで0（正常終了）となります。

○サンプルコード1：sys.exitの基本的な使い方

では、実際にsys.exitを使用したサンプルコードを見てみましょう。

import sys

def process_data(data):
    if not data:
        print("データが空です。プログラムを終了します。")
        sys.exit(1)

    # データ処理のロジック
    print(f"データ {data} を処理しました。")

# メイン処理
if __name__ == "__main__":
    user_data = input("データを入力してください: ")
    process_data(user_data)
    print("プログラムが正常に終了しました。")

このコードでは、ユーザーからの入力データが空の場合、sys.exit(1)を使用してプログラムを終了させています。

終了コード1は、一般的にエラーが発生したことを示すために使用されます。

実行結果

データを入力してください: 
データが空です。プログラムを終了します。

もし、データを入力した場合

データを入力してください: テストデータ
データ テストデータ を処理しました。
プログラムが正常に終了しました。

○os._exitを使った強制終了

時には、プログラムを即座に終了させる必要がある場合があります。

そのような場合、os._exitを使用することができます。

os._exitは、クリーンアップ処理を行わずにプログラムを強制的に終了させます。

os._exitの使用は慎重に行う必要があります。

なぜなら、ファイルが適切に閉じられなかったり、リソースが解放されなかったりする可能性があるためです。

os._exitの基本的な使い方は次の通りです。

import os

# プログラムの処理

os._exit(status)

statusは終了コードを指定します。

○サンプルコード2：os._exitの使用例

os._exitを使用したサンプルコードを見てみましょう。

import os
import time

def long_running_task():
    print("長時間の処理を開始します...")
    time.sleep(5)  # 5秒間スリープ
    print("長時間の処理が完了しました。")

def monitor_task():
    start_time = time.time()
    while True:
        elapsed_time = time.time() - start_time
        if elapsed_time > 3:  # 3秒以上経過したら強制終了
            print("処理時間が3秒を超えました。プログラムを強制終了します。")
            os._exit(1)
        time.sleep(0.1)  # 0.1秒ごとにチェック

if __name__ == "__main__":
    try:
        import threading
        task_thread = threading.Thread(target=long_running_task)
        monitor_thread = threading.Thread(target=monitor_task)

        task_thread.start()
        monitor_thread.start()

        task_thread.join()
        monitor_thread.join()
    except KeyboardInterrupt:
        print("ユーザーによって処理が中断されました。")
        os._exit(1)

print("このメッセージは表示されません。")

このサンプルコードでは、長時間実行されるタスクをシミュレートし、3秒以上経過した場合にos._exitを使用してプログラムを強制終了させています。

実行結果

長時間の処理を開始します...
処理時間が3秒を超えました。プログラムを強制終了します。

os._exitを使用したため、「このメッセージは表示されません。」という行は出力されません。

プログラムが即座に終了するためです。

sys.exitとos._exitの使い分けは重要です。

通常はsys.exitを使用し、プログラムを適切にクリーンアップして終了させることをお勧めします。

os._exitは、緊急時や特殊な状況でのみ使用するべきです。

●quitとexitの応用テクニック

Pythonプログラミングにおいて、quitとexitの基本的な使い方を理解したら、次はより高度な応用テクニックを学ぶ段階です。

プログラムの終了処理をより細かく制御することで、より堅牢なアプリケーションを開発することができます。

ここでは、終了コードの指定方法やatexitモジュールを使った終了時の処理について詳しく解説します。

○終了コードの指定方法

プログラムが終了する際、オペレーティングシステムに対して終了コードを返すことができます。

終了コードは、プログラムが正常に終了したか、エラーで終了したかを表す重要な情報です。

一般的に、終了コード0は正常終了を、0以外の値はエラーを意味します。

終了コードを指定することで、プログラムの実行結果を他のプログラムやシステムに伝えることができます。

sys.exitやos._exitを使用する際に、引数として終了コードを指定することができます。

○サンプルコード3：終了コードを使ったプログラムの終了

終了コードを使用したプログラムの例を見てみましょう。

import sys

def process_data(data):
    if not data:
        print("エラー: データが空です")
        sys.exit(1)  # エラーを示す終了コード1
    elif len(data) < 5:
        print("警告: データが短すぎます")
        sys.exit(2)  # 警告を示す終了コード2
    else:
        print(f"データ '{data}' を正常に処理しました")
        sys.exit(0)  # 正常終了を示す終了コード0

if __name__ == "__main__":
    user_input = input("データを入力してください: ")
    process_data(user_input)

このプログラムは、ユーザーからの入力に基づいて異なる終了コードを返します。

実行結果を見てみましょう。

データが空の場合

データを入力してください: 
エラー: データが空です

データが短い場合

データを入力してください: abc
警告: データが短すぎます

正常な場合

データを入力してください: abcdef
データ 'abcdef' を正常に処理しました

終了コードは、コマンドラインでecho $?（Unix系システム）やecho %ERRORLEVEL%（Windows）を使用して確認できます。

○atexitモジュールを使った終了時の処理

atexitモジュールは、プログラムが終了する際に実行される関数を登録することができる便利なツールです。

クリーンアップ処理や、終了時に必ず実行したい処理がある場合に使用します。

atexitモジュールを使用すると、プログラムがどのように終了するかに関わらず（正常終了、例外発生、sys.exit()の呼び出しなど）、登録した関数が実行されます。

○サンプルコード4：atexitの活用例

atexitモジュールを使用したサンプルコードを見てみましょう。

import sys
import atexit

def cleanup():
    print("クリーンアップ処理を実行しています...")
    print("一時ファイルの削除や接続のクローズなどの処理をここで行います。")

def main():
    atexit.register(cleanup)
    print("メイン処理を開始します。")

    # ここでメインの処理を行う
    user_input = input("'quit'と入力するとプログラムが終了します: ")

    if user_input.lower() == 'quit':
        print("プログラムを終了します。")
        sys.exit(0)
    else:
        print("'quit'以外が入力されました。プログラムを異常終了します。")
        sys.exit(1)

if __name__ == "__main__":
    main()

このプログラムでは、atexit.register()を使用してcleanup関数を登録しています。

プログラムがどのように終了するかに関わらず、cleanup関数が実行されます。

実行結果を見てみましょう。

正常終了の場合

メイン処理を開始します。
'quit'と入力するとプログラムが終了します: quit
プログラムを終了します。
クリーンアップ処理を実行しています...
一時ファイルの削除や接続のクローズなどの処理をここで行います。

異常終了の場合

メイン処理を開始します。
'quit'と入力するとプログラムが終了します: hello
'quit'以外が入力されました。プログラムを異常終了します。
クリーンアップ処理を実行しています...
一時ファイルの削除や接続のクローズなどの処理をここで行います。

atexitモジュールを使用することで、プログラムの終了時に必ず実行したい処理を確実に行うことができます。

データベース接続のクローズ、一時ファイルの削除、ログの書き込みなど、重要なクリーンアップ処理に適しています。

終了コードの指定とatexitモジュールの活用は、Pythonプログラムの終了処理をより堅牢にするための重要なテクニックです。

このテクニックを適切に使用することで、予期せぬエラーや異常終了時でも、適切なクリーンアップ処理を行い、システムの安定性を向上させることができます。

●Pythonプログラムの中断と再開

Pythonプログラムの開発において、適切な終了処理を理解することは重要ですが、同様に重要なのがプログラムの中断と再開の制御です。

長時間実行されるプログラムや、ユーザー入力を待つプログラムでは、予期せぬ中断や一時停止に対応する必要があります。

ここでは、KeyboardInterruptの処理方法や、プログラムの一時停止と再開のテクニックについて詳しく解説します。

○KeyboardInterruptの処理方法

KeyboardInterruptは、ユーザーがCtrl+Cを押してプログラムを中断しようとした際に発生する例外です。

プログラムを適切に終了させるために、KeyboardInterruptを適切に処理することが重要です。

KeyboardInterruptを処理しない場合、プログラムは突然終了し、必要なクリーンアップ処理が実行されない可能性があります。

適切に処理することで、ユーザーに中断の確認を求めたり、必要なクリーンアップ処理を実行したりすることができます。

○サンプルコード5：Ctrl+Cによる中断のハンドリング

KeyboardInterruptを処理する方法を示すサンプルコードを見てみましょう。

import time

def long_running_task():
    try:
        print("長時間の処理を開始します。Ctrl+Cで中断できます。")
        for i in range(10):
            print(f"処理中... {i + 1}秒経過")
            time.sleep(1)
        print("処理が正常に完了しました。")
    except KeyboardInterrupt:
        print("\nユーザーによって処理が中断されました。")
        print("クリーンアップ処理を実行します...")
        # ここでクリーンアップ処理を行う
        print("クリーンアップ完了。プログラムを終了します。")
    finally:
        print("プログラムを終了します。お疲れ様でした！")

if __name__ == "__main__":
    long_running_task()

このプログラムは、10秒間のカウントダウンを行いますが、ユーザーがCtrl+Cを押すことで中断することができます。

実行結果を見てみましょう。

正常に完了した場合

長時間の処理を開始します。Ctrl+Cで中断できます。
処理中... 1秒経過
処理中... 2秒経過
処理中... 3秒経過
処理中... 4秒経過
処理中... 5秒経過
処理中... 6秒経過
処理中... 7秒経過
処理中... 8秒経過
処理中... 9秒経過
処理中... 10秒経過
処理が正常に完了しました。
プログラムを終了します。お疲れ様でした！

ユーザーが中断した場合（例：5秒後にCtrl+Cを押した場合）

長時間の処理を開始します。Ctrl+Cで中断できます。
処理中... 1秒経過
処理中... 2秒経過
処理中... 3秒経過
処理中... 4秒経過
処理中... 5秒経過
^C
ユーザーによって処理が中断されました。
クリーンアップ処理を実行します...
クリーンアップ完了。プログラムを終了します。
プログラムを終了します。お疲れ様でした！

このように、KeyboardInterruptを適切に処理することで、ユーザーによる中断時でも必要なクリーンアップ処理を実行し、プログラムを適切に終了させることができます。

○プログラムの一時停止と再開テクニック

プログラムの実行中に一時停止し、後で再開する必要がある場合があります。

例えば、リソースの使用を制限したい場合や、定期的に処理を中断してステータスを確認したい場合などです。

Pythonでは、time.sleepを使用してプログラムを一時停止することができます。

○サンプルコード6：time.sleepを使った一時停止

time.sleepを使用してプログラムを一時停止し、再開する例を見てみましょう。

import time
import random

def process_data(data):
    print(f"データ '{data}' の処理を開始します...")
    time.sleep(random.uniform(0.5, 2.0))  # 0.5〜2.0秒のランダムな時間処理を模倣
    print(f"データ '{data}' の処理が完了しました。")

def main():
    data_list = ["A", "B", "C", "D", "E"]

    for i, data in enumerate(data_list, 1):
        process_data(data)

        if i < len(data_list):
            pause_time = 3
            print(f"{pause_time}秒間一時停止します。")
            for remaining in range(pause_time, 0, -1):
                print(f"再開まで {remaining} 秒...", end="\r")
                time.sleep(1)
            print("\n処理を再開します。")

    print("全てのデータ処理が完了しました。")

if __name__ == "__main__":
    main()

このプログラムは、複数のデータを処理し、各処理の間に3秒間の一時停止を入れます。

実行結果を見てみましょう。

データ 'A' の処理を開始します...
データ 'A' の処理が完了しました。
3秒間一時停止します。
再開まで 1 秒...
処理を再開します。
データ 'B' の処理を開始します...
データ 'B' の処理が完了しました。
3秒間一時停止します。
再開まで 1 秒...
処理を再開します。
データ 'C' の処理を開始します...
データ 'C' の処理が完了しました。
3秒間一時停止します。
再開まで 1 秒...
処理を再開します。
データ 'D' の処理を開始します...
データ 'D' の処理が完了しました。
3秒間一時停止します。
再開まで 1 秒...
処理を再開します。
データ 'E' の処理を開始します...
データ 'E' の処理が完了しました。
全てのデータ処理が完了しました。

このプログラムでは、time.sleepを使用して処理間に一時停止を入れています。

また、カウントダウン表示を使用することで、ユーザーに再開までの時間を視覚的に表しています。

プログラムの中断と再開を適切に制御することで、リソースの効率的な使用や、長時間実行されるプログラムの管理が容易になります。

また、ユーザーとの対話性を高めることもできます。

●よくあるエラーと対処法

Pythonプログラミングを学ぶ過程で、多くの方がquitやexitの使用に関連するエラーに遭遇します。

ここでは、よく発生するエラーとその対処法について詳しく解説します。

エラーメッセージを理解し、適切に対処することで、より堅牢なプログラムを作成できるようになります。

○「NameError: name ‘quit’ is not defined」の解決方法

「NameError: name ‘quit’ is not defined」というエラーは、quitが定義されていない状態で使用しようとした際に発生します。

Pythonの対話モードでは、quitは組み込み関数として利用可能ですが、スクリプトモードでは明示的にインポートする必要があります。

このエラーを解決するには、次のように__builtin__モジュールからquitをインポートします。

from __builtin__ import quit

# プログラムのコード

quit()  # プログラムを終了

ただし、スクリプト内でquitを使用することは推奨されません。

代わりにsys.exitを使用することをお勧めします。

import sys

# プログラムのコード

sys.exit()  # プログラムを終了

sys.exitを使用することで、プログラムをより適切に終了させ、終了コードを指定することもできます。

○「SystemExit」エラーの意味と対処

「SystemExit」は、実際にはエラーではなく、sys.exitが呼び出された際に発生する例外です。

通常、プログラムはこの例外をキャッチせずに終了しますが、時にはこの例外をキャッチして特別な処理を行いたい場合があります。

例えば、次のようなコードで「SystemExit」をキャッチできます。

import sys

def main():
    print("プログラムを開始します")
    # ここで何らかの処理を行う
    sys.exit("プログラムを終了します")

if __name__ == "__main__":
    try:
        main()
    except SystemExit as e:
        print(f"SystemExit例外をキャッチしました: {e}")
        # ここで終了前の特別な処理を行う
    finally:
        print("プログラムが完全に終了しました")

このプログラムを実行すると、次のような出力が得られます。

プログラムを開始します
SystemExit例外をキャッチしました: プログラムを終了します
プログラムが完全に終了しました

「SystemExit」例外をキャッチすることで、プログラムの終了前に特別なクリーンアップ処理や、ログ記録などを行うことができます。

ただし、通常はsys.exitを使ってプログラムを終了させ、「SystemExit」例外はキャッチせずにプログラムを終了させることが一般的です。

○プログラムが終了しない場合のデバッグ手順

時として、プログラムが予期せず終了しない状況に遭遇することがあります。

このような場合、次のデバッグ手順を踏むことで問題を特定し、解決することができます。

□ログの追加

プログラムの重要な箇所にログ出力を追加し、どこまで処理が進んでいるかを確認します。

import logging

logging.basicConfig(level=logging.DEBUG)

def some_function():
    logging.debug("some_functionが呼び出されました")
    # 関数の処理
    logging.debug("some_functionが終了しました")

# プログラムのメイン部分
logging.info("プログラムを開始します")
some_function()
logging.info("プログラムを終了します")

□タイムアウトの設定

長時間実行される可能性のある処理にタイムアウトを設定します。

import signal

def timeout_handler(signum, frame):
    raise TimeoutError("処理がタイムアウトしました")

signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(10)  # 10秒後にタイムアウト

try:
    # 長時間実行される可能性のある処理
    pass
except TimeoutError as e:
    print(f"エラー: {e}")
finally:
    signal.alarm(0)  # タイマーをリセット

□プロファイリング

cProfileモジュールを使用して、どの部分の処理に時間がかかっているかを特定します。

import cProfile

def main():
    # プログラムのメイン処理

cProfile.run('main()')

□デバッガの使用

pdbモジュールを使用して、プログラムの実行を一時停止し、変数の状態を確認します。

import pdb

def problematic_function():
    x = 10
    y = 0
    pdb.set_trace()  # ここでデバッガが起動
    result = x / y  # ゼロ除算エラーが発生する箇所
    return result

problematic_function()

このデバッグ手順を順番に適用することで、プログラムが終了しない原因を特定し、適切に対処することができます。

●Pythonの終了処理ベストプラクティス

Pythonプログラムの終了処理は、適切に行うことでプログラムの信頼性と安定性を大きく向上させることができます。

ここでは、Pythonの終了処理におけるベストプラクティスについて詳しく解説します。

適切な終了方法の選び方から、安全な終了処理の実装方法、さらにはマルチスレッドプログラムにおける注意点まで、実践的なテクニックを学んでいきましょう。

○適切な終了方法の選び方

Pythonプログラムを終了させる方法には複数の選択肢がありますが、状況に応じて適切な方法を選ぶことが重要です。

一般的には、sys.exitを使用することが推奨されます。

sys.exitは、プログラムをクリーンに終了させ、終了コードを指定することができます。

ただし、特殊な状況下では他の方法を選択する場合もあります。

例えば、os._exitは即座にプログラムを終了させるため、クリティカルな状況下で使用することがあります。

また、raiseを使用してSystemExit例外を発生させる方法もあります。

適切な終了方法を選ぶ際は、次の点を考慮しましょう。

プログラムの状態/通常の終了なのか、エラー時の終了なのか
クリーンアップの必要性/ファイルやリソースを適切に閉じる必要があるか
呼び出し元への情報伝達/終了コードを通じて状態を伝える必要があるか

○サンプルコード7：try-exceptを使った安全な終了処理

安全な終了処理を実装するためには、try-except文を使用してエラーをキャッチし、適切に処理することが重要です。

次のサンプルコードでは、ファイル操作を行うプログラムにおいて、安全な終了処理を実装しています。

import sys

def process_file(filename):
    try:
        with open(filename, 'r') as file:
            content = file.read()
            # ファイルの内容を処理する
            print(f"ファイル '{filename}' の内容を処理しました。")
    except FileNotFoundError:
        print(f"エラー: ファイル '{filename}' が見つかりません。")
        sys.exit(1)
    except IOError as e:
        print(f"エラー: ファイル '{filename}' の読み込み中にIOエラーが発生しました: {e}")
        sys.exit(2)
    except Exception as e:
        print(f"予期せぬエラーが発生しました: {e}")
        sys.exit(3)

def main():
    if len(sys.argv) < 2:
        print("使用方法: python script.py <filename>")
        sys.exit(1)

    filename = sys.argv[1]
    process_file(filename)
    print("プログラムが正常に終了しました。")

if __name__ == "__main__":
    main()

このプログラムは、コマンドライン引数で指定されたファイルを処理します。

try-except文を使用して様々な例外をキャッチし、適切なエラーメッセージを表示して終了コードを設定しています。

実行結果（正常な場合）

$ python script.py example.txt
ファイル 'example.txt' の内容を処理しました。
プログラムが正常に終了しました。

実行結果（ファイルが見つからない場合）

$ python script.py nonexistent.txt
エラー: ファイル 'nonexistent.txt' が見つかりません。

このように、try-except文を使用することで、予期せぬエラーにも適切に対応し、プログラムを安全に終了させることができます。

○マルチスレッドプログラムの終了時の注意点

マルチスレッドプログラムの終了処理は、シングルスレッドのプログラムよりも複雑です。

すべてのスレッドを適切に終了させ、リソースのリークを防ぐ必要があります。

マルチスレッドプログラムを終了する際の主な注意点は次の通りです。

メインスレッドが終了する前に、すべての子スレッドが終了していることを確認する
スレッドの強制終了は避け、適切な終了フラグを使用してスレッドを終了させる
スレッドセーフな方法でリソースを解放する
デッドロックを避けるため、スレッド間の依存関係に注意する

○サンプルコード8：スレッドの適切な終了方法

次のサンプルコードでは、マルチスレッドプログラムにおける適切な終了処理を実装しています。

import threading
import time
import sys

class WorkerThread(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name
        self.stop_flag = threading.Event()

    def run(self):
        while not self.stop_flag.is_set():
            print(f"スレッド {self.name} が動作中...")
            time.sleep(1)
        print(f"スレッド {self.name} が終了しました。")

    def stop(self):
        self.stop_flag.set()

def main():
    threads = []
    try:
        # スレッドを作成して開始
        for i in range(3):
            thread = WorkerThread(f"Worker-{i}")
            thread.start()
            threads.append(thread)

        # メインスレッドで5秒間待機
        time.sleep(5)

    except KeyboardInterrupt:
        print("\nKeyboardInterrupt を検知しました。プログラムを終了します。")
    finally:
        # すべてのスレッドを停止
        for thread in threads:
            thread.stop()

        # すべてのスレッドが終了するのを待つ
        for thread in threads:
            thread.join()

        print("すべてのスレッドが終了しました。プログラムを終了します。")

if __name__ == "__main__":
    main()

このプログラムでは、3つのワーカースレッドを作成し、5秒間実行した後、または KeyboardInterrupt が発生した時点ですべてのスレッドを適切に終了させます。

実行結果

スレッド Worker-0 が動作中...
スレッド Worker-1 が動作中...
スレッド Worker-2 が動作中...
スレッド Worker-0 が動作中...
スレッド Worker-1 が動作中...
スレッド Worker-2 が動作中...
スレッド Worker-0 が動作中...
スレッド Worker-1 が動作中...
スレッド Worker-2 が動作中...
スレッド Worker-0 が動作中...
スレッド Worker-1 が動作中...
スレッド Worker-2 が動作中...
スレッド Worker-0 が動作中...
スレッド Worker-1 が動作中...
スレッド Worker-2 が動作中...
スレッド Worker-0 が終了しました。
スレッド Worker-1 が終了しました。
スレッド Worker-2 が終了しました。
すべてのスレッドが終了しました。プログラムを終了します。

このサンプルコードでは、各スレッドに停止フラグを設定し、メインスレッドからそのフラグを制御することで、スレッドを適切に終了させています。

また、finallyブロックを使用することで、例外が発生した場合でも確実にすべてのスレッドが終了するようにしています。