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

import threading
# 共有変数
shared_variable = 0
# ロックの作成
lock = threading.Lock()
def increment():
    global shared_variable
    with lock:  # ロックを取得
        shared_variable += 1  # 共有変数の更新
# スレッドの作成
threads = [threading.Thread(target=increment) for _ in range(10)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()
print(shared_variable)  # 出力: 10

import threading
import queue
# キューの作成
q = queue.Queue()
def producer():
    for i in range(5):
        q.put(i)  # キューにデータを追加
def consumer():
    while True:
        item = q.get()  # キューからデータを取得
        if item is None:
            break
        print(f'消費: {item}')
# スレッドの作成
prod_thread = threading.Thread(target=producer)
cons_thread = threading.Thread(target=consumer)
prod_thread.start()
cons_thread.start()
prod_thread.join()
q.put(None)  # 終了信号
cons_thread.join()

import threading
# 条件変数の作成
condition = threading.Condition()
shared_variable = 0
def wait_for_condition():
    with condition:
        condition.wait()  # 条件が満たされるまで待機
        print(f'条件が満たされました: {shared_variable}')
def signal_condition():
    global shared_variable
    with condition:
        shared_variable = 10
        condition.notify()  # 条件を満たす
# スレッドの作成
wait_thread = threading.Thread(target=wait_for_condition)
signal_thread = threading.Thread(target=signal_condition)
wait_thread.start()
signal_thread.start()
wait_thread.join()
signal_thread.join()

import threading
# 共有変数
counter = 0
# ロックの作成
lock = threading.Lock()
def increment():
    global counter
    for _ in range(1000):
        with lock:  # ロックを取得
            counter += 1  # 共有変数の更新
# スレッドの作成
threads = [threading.Thread(target=increment) for _ in range(10)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()
print(counter)  # 出力: 10000

import threading
import queue
import time
# キューの作成
q = queue.Queue()
def producer():
    for i in range(5):
        time.sleep(1)  # データ生成の遅延
        q.put(i)  # キューにデータを追加
        print(f'生産: {i}')
def consumer():
    while True:
        item = q.get()  # キューからデータを取得
        if item is None:
            break
        print(f'消費: {item}')
        time.sleep(2)  # データ消費の遅延
# スレッドの作成
prod_thread = threading.Thread(target=producer)
cons_thread = threading.Thread(target=consumer)
prod_thread.start()
cons_thread.start()
prod_thread.join()
q.put(None)  # 終了信号
cons_thread.join()

import threading
import time
# 条件変数の作成
condition = threading.Condition()
shared_variable = 0
def wait_for_condition():
    global shared_variable
    with condition:
        print('条件を待機中...')
        condition.wait()  # 条件が満たされるまで待機
        print(f'条件が満たされました: {shared_variable}')
def signal_condition():
    global shared_variable
    time.sleep(2)  # 条件を満たすまでの遅延
    with condition:
        shared_variable = 10
        print('条件を満たしました。通知します。')
        condition.notify()  # 条件を満たす
# スレッドの作成
wait_thread = threading.Thread(target=wait_for_condition)
signal_thread = threading.Thread(target=signal_condition)
wait_thread.start()
signal_thread.start()
wait_thread.join()
signal_thread.join()

import threading
import time
# 条件変数の作成
condition = threading.Condition()
data_ready = False
data = None
def producer():
    global data, data_ready
    time.sleep(2)  # データ生成の遅延
    with condition:
        data = "生成されたデータ"
        data_ready = True
        print('データを生成しました。')
        condition.notify()  # データが準備できたことを通知
def consumer():
    global data, data_ready
    with condition:
        while not data_ready:
            print('データを待機中...')
            condition.wait()  # データが準備できるまで待機
        print(f'データを処理します: {data}')
# スレッドの作成
prod_thread = threading.Thread(target=producer)
cons_thread = threading.Thread(target=consumer)
prod_thread.start()
cons_thread.start()
prod_thread.join()
cons_thread.join()

import threading
import queue
import time
# タスクキューの作成
task_queue = queue.Queue()
def worker():
    while True:
        task = task_queue.get()
        if task is None:
            break
        print(f'タスク {task} を処理中...')
        time.sleep(1)  # タスク処理の遅延
        print(f'タスク {task} の処理が完了しました。')
        task_queue.task_done()
# スレッドの作成
threads = [threading.Thread(target=worker) for _ in range(3)]
for thread in threads:
    thread.start()
# タスクの追加
for i in range(5):
    task_queue.put(i)
# タスクの終了を待機
task_queue.join()
# スレッドの終了
for _ in threads:
    task_queue.put(None)  # 終了信号
for thread in threads:
    thread.join()

import threading
# 共有リソース
shared_resource = 0
lock = threading.Lock()
def access_resource():
    global shared_resource
    with lock:  # ロックを取得
        print(f'リソースにアクセス中: {shared_resource}')
        shared_resource += 1  # リソースの更新
        print(f'リソースを更新しました: {shared_resource}')
# スレッドの作成
threads = [threading.Thread(target=access_resource) for _ in range(5)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()