MENU
  1. ホーム
  2. Python
  3. スレッド
  4. 【Python】マルチスレッドでスレッド間で変数を共有する方法を解説

【Python】マルチスレッドでスレッド間で変数を共有する方法を解説

スレッド

Pythonでマルチスレッドプログラミングを行う際、スレッド間で変数を共有する方法を知ることは非常に重要です。

この記事では、初心者向けにスレッド間で変数を共有する必要性や具体的な方法、注意点とベストプラクティスについて詳しく解説します。

グローバル変数の使用からthreadingモジュール、queueモジュール、concurrent.futuresモジュールまで、さまざまな方法をサンプルコードとともに紹介しますので、ぜひ参考にしてください。

目次から探す

スレッド間で変数を共有する必要性

Pythonでマルチスレッドプログラミングを行う際、スレッド間で変数を共有することは非常に重要です。

スレッドは独立して動作するため、各スレッドが独自のデータを持つことが一般的ですが、特定の状況ではスレッド間でデータを共有する必要があります。

ここでは、スレッド間で変数を共有する必要性について詳しく解説します。

共有変数の重要性

スレッド間で変数を共有することは、以下のような理由で重要です。

  1. データの一貫性の確保:

複数のスレッドが同じデータにアクセスする場合、データの一貫性を保つことが重要です。

例えば、銀行の口座残高を管理するシステムでは、複数のスレッドが同時に残高を更新することがあります。

この場合、共有変数を適切に管理しないと、データの不整合が発生する可能性があります。

  1. リソースの効率的な利用:

スレッド間でデータを共有することで、リソースの効率的な利用が可能になります。

例えば、大量のデータを処理する場合、データを分割して複数のスレッドで並行処理することで、処理時間を短縮できます。

この際、共有変数を使ってデータを管理することで、スレッド間の協調動作が可能になります。

  1. タスクの分担と協調:

複雑なタスクを複数のスレッドで分担して実行する場合、スレッド間でデータを共有することで、各スレッドが協調して動作することができます。

例えば、ウェブサーバーでは、複数のスレッドが同時にリクエストを処理しますが、共有変数を使ってリクエストのキューを管理することで、効率的なリクエスト処理が可能になります。

共有変数の使用例

具体的な使用例をいくつか挙げてみましょう。

  1. カウンターの更新:

複数のスレッドが同時にカウンターを更新する場合、共有変数を使ってカウンターの値を管理します。

以下は、threadingモジュールを使ってカウンターを更新する例です。

import threading
    counter = 0
    lock = threading.Lock()
    def increment_counter():
        global counter
        with lock:
            counter += 1
    threads = []
    for _ in range(10):
        thread = threading.Thread(target=increment_counter)
        threads.append(thread)
        thread.start()
    for thread in threads:
        thread.join()
    print(f"Final counter value: {counter}")

この例では、lockを使って排他制御を行い、複数のスレッドが同時にカウンターを更新する際のデータ競合を防いでいます。

  1. タスクキューの管理:

複数のスレッドが同時にタスクを処理する場合、共有変数を使ってタスクキューを管理します。

以下は、queueモジュールを使ってタスクキューを管理する例です。

import threading
    import queue
    task_queue = queue.Queue()
    def worker():
        while True:
            task = task_queue.get()
            if task is None:
                break
            print(f"Processing task: {task}")
            task_queue.task_done()
    threads = []
    for _ in range(5):
        thread = threading.Thread(target=worker)
        threads.append(thread)
        thread.start()
    for task in range(10):
        task_queue.put(task)
    task_queue.join()
    for _ in range(5):
        task_queue.put(None)
    for thread in threads:
        thread.join()

この例では、queue.Queueを使ってタスクキューを管理し、複数のスレッドが協調してタスクを処理しています。

これらの例からもわかるように、スレッド間で変数を共有することは、データの一貫性を保ち、リソースを効率的に利用し、タスクを協調して実行するために非常に重要です。

次のセクションでは、具体的な方法について詳しく解説していきます。

スレッド間で変数を共有する方法

Pythonでマルチスレッドプログラミングを行う際、スレッド間で変数を共有する方法はいくつかあります。

ここでは、代表的な方法をいくつか紹介します。

グローバル変数の使用

グローバル変数の定義と使用方法

グローバル変数は、プログラム全体で共有される変数です。

スレッド間で変数を共有する最も簡単な方法の一つです。

以下に、グローバル変数を使った簡単な例を示します。

import threading
# グローバル変数
shared_variable = 0
def increment():
    global shared_variable
    for _ in range(100000):
        shared_variable += 1
# スレッドの作成
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
# スレッドの開始
thread1.start()
thread2.start()
# スレッドの終了を待つ
thread1.join()
thread2.join()
print(f"最終的な共有変数の値: {shared_variable}")

この例では、shared_variableというグローバル変数を2つのスレッドでインクリメントしています。

グローバル変数の利点と欠点

グローバル変数を使う利点は、そのシンプルさです。

特別なモジュールやクラスを使わずに、簡単にスレッド間で変数を共有できます。

しかし、以下のような欠点もあります。

  • データ競合: 複数のスレッドが同時に変数を変更しようとすると、予期しない結果になることがあります。
  • 可読性の低下: グローバル変数が多くなると、コードの可読性が低下し、バグの原因になります。

threadingモジュールの使用

threadingモジュールの基本

Pythonのthreadingモジュールは、マルチスレッドプログラミングをサポートするための基本的な機能を提供します。

スレッドの作成、開始、終了を簡単に行うことができます。

threading.Lockを使った排他制御

threading.Lockは、スレッド間でのデータ競合を防ぐための排他制御を提供します。

以下に、threading.Lockを使った例を示します。

import threading
# グローバル変数
shared_variable = 0
lock = threading.Lock()
def increment():
    global shared_variable
    for _ in range(100000):
        with lock:
            shared_variable += 1
# スレッドの作成
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
# スレッドの開始
thread1.start()
thread2.start()
# スレッドの終了を待つ
thread1.join()
thread2.join()
print(f"最終的な共有変数の値: {shared_variable}")

この例では、lockを使って、shared_variableへのアクセスを排他制御しています。

これにより、データ競合を防ぐことができます。

threading.RLockの使用例

threading.RLockは、再帰的なロックを提供します。

これは、同じスレッドが複数回ロックを取得する必要がある場合に便利です。

以下に、threading.RLockを使った例を示します。

import threading
# グローバル変数
shared_variable = 0
rlock = threading.RLock()
def increment():
    global shared_variable
    for _ in range(100000):
        with rlock:
            shared_variable += 1
# スレッドの作成
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
# スレッドの開始
thread1.start()
thread2.start()
# スレッドの終了を待つ
thread1.join()
thread2.join()
print(f"最終的な共有変数の値: {shared_variable}")

この例では、rlockを使って、shared_variableへのアクセスを排他制御しています。

RLockは、同じスレッドが複数回ロックを取得する場合に便利です。

queueモジュールの使用

queue.Queueの基本

queueモジュールは、スレッド間での安全なデータのやり取りをサポートします。

queue.Queueは、スレッド間でデータをキューに入れたり取り出したりするためのクラスです。

queue.Queueを使ったスレッド間通信

以下に、queue.Queueを使ったスレッド間通信の例を示します。

import threading
import queue
# キューの作成
q = queue.Queue()
def producer():
    for i in range(5):
        q.put(i)
        print(f"生産者: {i}をキューに追加")
def consumer():
    while True:
        item = q.get()
        if item is None:
            break
        print(f"消費者: {item}をキューから取得")
        q.task_done()
# スレッドの作成
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
# スレッドの開始
producer_thread.start()
consumer_thread.start()
# 生産者スレッドの終了を待つ
producer_thread.join()
# キューに終了シグナルを送る
q.put(None)
# 消費者スレッドの終了を待つ
consumer_thread.join()

この例では、producerスレッドがデータをキューに追加し、consumerスレッドがキューからデータを取り出して処理しています。

concurrent.futuresモジュールの使用

concurrent.futures.ThreadPoolExecutorの基本

concurrent.futuresモジュールは、スレッドプールを使った並行処理を簡単に行うための機能を提供します。

ThreadPoolExecutorを使うことで、スレッドの管理が容易になります。

concurrent.futuresを使った共有変数の管理

以下に、concurrent.futures.ThreadPoolExecutorを使った例を示します。

import concurrent.futures
# グローバル変数
shared_variable = 0
lock = threading.Lock()
def increment():
    global shared_variable
    for _ in range(100000):
        with lock:
            shared_variable += 1
# スレッドプールの作成
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
    futures = [executor.submit(increment) for _ in range(2)]
# 全てのスレッドの終了を待つ
concurrent.futures.wait(futures)
print(f"最終的な共有変数の値: {shared_variable}")

この例では、ThreadPoolExecutorを使って、2つのスレッドでincrement関数を実行しています。

lockを使って、shared_variableへのアクセスを排他制御しています。

以上が、Pythonでスレッド間で変数を共有する方法です。

それぞれの方法には利点と欠点があるため、具体的な用途に応じて適切な方法を選択してください。

共有変数の同期と排他制御

スレッド間で変数を共有する際には、データの整合性を保つために同期と排他制御が必要です。

これにより、複数のスレッドが同時に同じ変数にアクセスしてもデータが破損しないようにします。

排他制御の必要性

排他制御は、複数のスレッドが同時に共有変数にアクセスすることを防ぐための手法です。

例えば、あるスレッドが変数の値を更新している最中に、別のスレッドがその変数の値を読み取ると、予期しない結果が生じる可能性があります。

これを防ぐために、排他制御が必要です。

threading.Lockの詳細

threading.Lockは、Pythonの標準ライブラリで提供される排他制御のための基本的なロックオブジェクトです。

ロックを取得したスレッドだけが共有変数にアクセスできるようにします。

以下は、threading.Lockを使った例です。

import threading
# 共有変数
shared_variable = 0
# ロックオブジェクトの作成
lock = threading.Lock()
def increment():
    global shared_variable
    for _ in range(100000):
        with lock:
            shared_variable += 1
# スレッドの作成
threads = []
for _ in range(10):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()
# スレッドの終了を待つ
for thread in threads:
    thread.join()
print(f"最終的な共有変数の値: {shared_variable}")

この例では、10個のスレッドが同時にshared_variableをインクリメントしますが、lockを使うことでデータの整合性が保たれます。

threading.RLockの詳細

threading.RLockは、再帰的なロックオブジェクトです。

RLockは同じスレッドが複数回ロックを取得できる点がLockと異なります。

これにより、再帰的な関数呼び出しや複雑なロジックでのロックの使用が容易になります。

以下は、threading.RLockを使った例です。

import threading
# 共有変数
shared_variable = 0
# 再帰的ロックオブジェクトの作成
rlock = threading.RLock()
def increment():
    global shared_variable
    for _ in range(100000):
        with rlock:
            shared_variable += 1
def double_increment():
    with rlock:
        increment()
        increment()
# スレッドの作成
threads = []
for _ in range(10):
    thread = threading.Thread(target=double_increment)
    threads.append(thread)
    thread.start()
# スレッドの終了を待つ
for thread in threads:
    thread.join()
print(f"最終的な共有変数の値: {shared_variable}")

この例では、double_increment関数内でincrement関数が呼び出され、再帰的にロックが取得されます。

threading.Conditionの使用

threading.Conditionは、特定の条件が満たされるまでスレッドを待機させるための同期プリミティブです。

条件が満たされると、待機中のスレッドが再開されます。

以下は、threading.Conditionを使った例です。

import threading
# 共有変数
shared_variable = 0
# 条件オブジェクトの作成
condition = threading.Condition()
def increment():
    global shared_variable
    with condition:
        shared_variable += 1
        condition.notify_all()
def wait_for_value(value):
    with condition:
        condition.wait_for(lambda: shared_variable >= value)
        print(f"共有変数が{value}に達しました")
# スレッドの作成
threads = []
for _ in range(10):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()
# 値を待つスレッドの作成
wait_thread = threading.Thread(target=wait_for_value, args=(10,))
wait_thread.start()
# スレッドの終了を待つ
for thread in threads:
    thread.join()
wait_thread.join()

この例では、increment関数が呼び出されるたびにshared_variableがインクリメントされ、条件が満たされるとwait_for_value関数が再開されます。

threading.Eventの使用

threading.Eventは、スレッド間でフラグを共有するための同期プリミティブです。

フラグがセットされると、待機中のスレッドが再開されます。

以下は、threading.Eventを使った例です。

import threading
# イベントオブジェクトの作成
event = threading.Event()
def wait_for_event():
    print("イベントを待っています...")
    event.wait()
    print("イベントがセットされました")
def set_event():
    print("イベントをセットします")
    event.set()
# スレッドの作成
wait_thread = threading.Thread(target=wait_for_event)
set_thread = threading.Thread(target=set_event)
wait_thread.start()
set_thread.start()
# スレッドの終了を待つ
wait_thread.join()
set_thread.join()

この例では、wait_for_event関数がイベントがセットされるまで待機し、set_event関数がイベントをセットします。

これにより、wait_for_event関数が再開されます。

以上が、共有変数の同期と排他制御に関する詳細な解説です。

これらの手法を適切に使用することで、スレッド間でのデータの整合性を保つことができます。

実践例

ここでは、スレッド間で変数を共有する具体的な方法をいくつかの例を通じて解説します。

それぞれの方法には利点と欠点があるため、適切な方法を選択することが重要です。

グローバル変数を使った例

グローバル変数を使ってスレッド間でデータを共有する方法は最もシンプルですが、注意が必要です。

以下の例では、複数のスレッドがグローバル変数にアクセスして値を更新します。

import threading
# グローバル変数
shared_variable = 0
def increment():
    global shared_variable
    for _ in range(100000):
        shared_variable += 1
# スレッドの作成
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
# スレッドの開始
thread1.start()
thread2.start()
# スレッドの終了を待つ
thread1.join()
thread2.join()
print(f"最終的な共有変数の値: {shared_variable}")

このコードを実行すると、期待した結果が得られないことがあります。

これは、複数のスレッドが同時にshared_variableを更新しようとするためです。

この問題を解決するためには、次に説明するthreading.Lockを使用します。

threading.Lockを使った例

threading.Lockを使用することで、スレッド間でのデータ競合を防ぐことができます。

以下の例では、ロックを使用して共有変数の更新を排他制御します。

import threading
# グローバル変数
shared_variable = 0
lock = threading.Lock()
def increment():
    global shared_variable
    for _ in range(100000):
        with lock:
            shared_variable += 1
# スレッドの作成
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
# スレッドの開始
thread1.start()
thread2.start()
# スレッドの終了を待つ
thread1.join()
thread2.join()
print(f"最終的な共有変数の値: {shared_variable}")

このコードでは、with lockブロック内でのみshared_variableが更新されるため、データ競合が発生しません。

queue.Queueを使った例

queue.Queueを使用することで、スレッド間で安全にデータを共有することができます。

以下の例では、キューを使ってスレッド間でデータをやり取りします。

import threading
import queue
# キューの作成
q = queue.Queue()
def producer():
    for i in range(5):
        q.put(i)
        print(f"生産者が {i} をキューに追加")
def consumer():
    while True:
        item = q.get()
        if item is None:
            break
        print(f"消費者が {item} をキューから取得")
        q.task_done()
# スレッドの作成
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
# スレッドの開始
producer_thread.start()
consumer_thread.start()
# 生産者スレッドの終了を待つ
producer_thread.join()
# キューに終了シグナルを追加
q.put(None)
# 消費者スレッドの終了を待つ
consumer_thread.join()

このコードでは、producerスレッドがキューにデータを追加し、consumerスレッドがキューからデータを取得します。

キューを使用することで、スレッド間でのデータのやり取りが安全に行えます。

concurrent.futuresを使った例

concurrent.futuresモジュールを使用することで、スレッドプールを簡単に管理できます。

以下の例では、ThreadPoolExecutorを使用してスレッド間でデータを共有します。

import concurrent.futures
# 共有変数
shared_variable = 0
lock = threading.Lock()
def increment():
    global shared_variable
    for _ in range(100000):
        with lock:
            shared_variable += 1
# スレッドプールの作成
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
    futures = [executor.submit(increment) for _ in range(2)]
# 全てのスレッドの終了を待つ
concurrent.futures.wait(futures)
print(f"最終的な共有変数の値: {shared_variable}")

このコードでは、ThreadPoolExecutorを使用して2つのスレッドを作成し、increment関数を実行します。

concurrent.futuresモジュールを使用することで、スレッドの管理が簡単になります。

以上の例を通じて、スレッド間で変数を共有する方法を理解できたでしょうか。

それぞれの方法には利点と欠点があるため、具体的な用途に応じて適切な方法を選択してください。

注意点とベストプラクティス

マルチスレッドプログラミングでは、スレッド間で変数を共有する際にいくつかの注意点があります。

これらの注意点を理解し、ベストプラクティスを守ることで、安定したパフォーマンスを発揮するプログラムを作成することができます。

デッドロックの回避

デッドロックとは、複数のスレッドが互いにロックを待ち続ける状態のことを指します。

これが発生すると、プログラムは停止してしまいます。

デッドロックを回避するための方法をいくつか紹介します。

ロックの順序を統一する

複数のロックを使用する場合、すべてのスレッドが同じ順序でロックを取得するようにします。

これにより、デッドロックの発生を防ぐことができます。

import threading
lock1 = threading.Lock()
lock2 = threading.Lock()
def thread1():
    with lock1:
        with lock2:
            print("Thread 1")
def thread2():
    with lock1:
        with lock2:
            print("Thread 2")
t1 = threading.Thread(target=thread1)
t2 = threading.Thread(target=thread2)
t1.start()
t2.start()
t1.join()
t2.join()

タイムアウトを設定する

ロックの取得にタイムアウトを設定することで、デッドロックを回避することができます。

タイムアウトが発生した場合、ロックの取得を諦めて他の処理を行うことができます。

import threading
lock = threading.Lock()
def thread_function():
    if lock.acquire(timeout=1):
        try:
            print("Lock acquired")
        finally:
            lock.release()
    else:
        print("Failed to acquire lock")
t1 = threading.Thread(target=thread_function)
t2 = threading.Thread(target=thread_function)
t1.start()
t2.start()
t1.join()
t2.join()

レースコンディションの回避

レースコンディションとは、複数のスレッドが同時に共有変数にアクセスし、予期しない結果を引き起こす状態のことを指します。

これを回避するためには、適切な排他制御を行うことが重要です。

ロックを使用する

ロックを使用して、共有変数へのアクセスを制御します。

これにより、同時アクセスによるデータの不整合を防ぐことができます。

import threading
counter = 0
lock = threading.Lock()
def increment():
    global counter
    with lock:
        counter += 1
threads = []
for _ in range(100):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()
for t in threads:
    t.join()
print(f"Counter: {counter}")

スレッドのパフォーマンス最適化

スレッドを使用することで、プログラムのパフォーマンスを向上させることができますが、適切な最適化を行わないと逆効果になることもあります。

以下に、スレッドのパフォーマンスを最適化するためのポイントを紹介します。

適切なスレッド数を設定する

スレッド数が多すぎると、スレッド間のコンテキストスイッチが頻繁に発生し、パフォーマンスが低下します。

一般的には、CPUコア数に応じたスレッド数を設定することが推奨されます。

import concurrent.futures
import os
def task():
    print("Task executed")
# CPUコア数に応じたスレッド数を設定
num_threads = os.cpu_count()
with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads) as executor:
    futures = [executor.submit(task) for _ in range(10)]
    concurrent.futures.wait(futures)

I/OバウンドとCPUバウンドのタスクを分ける

I/Oバウンドのタスク(ファイル操作やネットワーク通信など)とCPUバウンドのタスク(計算処理など)を分けてスレッドを管理することで、効率的なリソース利用が可能になります。

import threading
import time
def io_bound_task():
    time.sleep(2)
    print("I/O bound task completed")
def cpu_bound_task():
    result = sum(i * i for i in range(1000000))
    print("CPU bound task completed")
io_thread = threading.Thread(target=io_bound_task)
cpu_thread = threading.Thread(target=cpu_bound_task)
io_thread.start()
cpu_thread.start()
io_thread.join()
cpu_thread.join()

これらの注意点とベストプラクティスを守ることで、マルチスレッドプログラミングにおける問題を回避し、効率的なプログラムを作成することができます。

目次に戻る

当サイトはリンクフリーです。出典元を明記していただければ、ご自由に引用していただいて構いません。

スレッド

関連記事

目次から探す