[Python] スレッド終了時に戻り値を取得する方法

from concurrent.futures import ThreadPoolExecutor
def task(n):
    return n * n
# スレッドプールを作成
with ThreadPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(task, i) for i in range(5)]

from concurrent.futures import ThreadPoolExecutor
def task(n):
    return n * n
with ThreadPoolExecutor(max_workers=5) as executor:
    future = executor.submit(task, 10)
    print(future)  # Futureオブジェクトが返される

<Future at 0x7f8c1c0e3d90 state=finished returned int>

from concurrent.futures import ThreadPoolExecutor
def task(n):
    return n * n
with ThreadPoolExecutor(max_workers=5) as executor:
    future = executor.submit(task, 10)
    result = future.result()  # 戻り値を取得
    print(result)

100

from concurrent.futures import ThreadPoolExecutor, TimeoutError
import time
def long_task():
    time.sleep(5)
    return "完了"
with ThreadPoolExecutor(max_workers=1) as executor:
    future = executor.submit(long_task)
    try:
        result = future.result(timeout=3)  # タイムアウトを3秒に設定
    except TimeoutError:
        print("タイムアウトしました")

タイムアウトしました

from concurrent.futures import ThreadPoolExecutor, as_completed
def task(n):
    return n * n
with ThreadPoolExecutor(max_workers=5) as executor:
    futures = {executor.submit(task, i): i for i in range(5)}
    for future in as_completed(futures):
        result = future.result()
        print(f"タスク {futures[future]} の結果: {result}")

タスク 0 の結果: 0
タスク 1 の結果: 1
タスク 2 の結果: 4
タスク 3 の結果: 9
タスク 4 の結果: 16

import threading
def task(n):
    print(f"タスク {n} を実行中")
# スレッドを作成
thread = threading.Thread(target=task, args=(1,))
thread.start()  # スレッドを開始
thread.join()   # スレッドの終了を待機

タスク 1 を実行中

import threading
result = None
def task(n):
    global result
    result = n * n
# スレッドを作成
thread = threading.Thread(target=task, args=(10,))
thread.start()
thread.join()  # スレッドの終了を待機
print(f"戻り値: {result}")

戻り値: 100

import threading
import queue
def task(n, q):
    q.put(n * n)  # 結果をキューに追加
result_queue = queue.Queue()
# スレッドを作成
thread = threading.Thread(target=task, args=(10, result_queue))
thread.start()
thread.join()  # スレッドの終了を待機
result = result_queue.get()  # キューから結果を取得
print(f"戻り値: {result}")

戻り値: 100

import threading
result = None
event = threading.Event()
def task(n):
    global result
    result = n * n
    event.set()  # スレッドの完了を通知
# スレッドを作成
thread = threading.Thread(target=task, args=(10,))
thread.start()
event.wait()  # スレッドの完了を待機
print(f"戻り値: {result}")

戻り値: 100

import threading
def task(n):
    return n * n
# スレッドを作成
thread = threading.Thread(target=task, args=(10,))
thread.start()
thread.join()  # スレッドの終了を待機
# 戻り値は取得できないが、スレッドの終了を待つことができる
print("スレッドが終了しました")

スレッドが終了しました

import threading
lock = threading.Lock()
shared_data = 0
def increment():
    global shared_data
    for _ in range(100000):
        with lock:  # ロックを取得
            shared_data += 1
threads = [threading.Thread(target=increment) for _ in range(2)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()
print(f"最終的な値: {shared_data}")

最終的な値: 200000

import threading
lock = threading.Lock()
global_var = 0
def update_global():
    global global_var
    with lock:
        global_var += 1
threads = [threading.Thread(target=update_global) for _ in range(100)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()
print(f"グローバル変数の値: {global_var}")

グローバル変数の値: 100

import threading
def task(n):
    try:
        return 10 / n  # 0で割ると例外が発生
    except ZeroDivisionError:
        return "ゼロで割ることはできません"
thread = threading.Thread(target=task, args=(0,))
thread.start()
thread.join()  # スレッドの終了を待機
print("スレッドが終了しました")

スレッドが終了しました

import threading
def task():
    print("タスクを実行中")
thread = threading.Thread(target=task)
thread.start()
thread.join()  # スレッドの終了を待機
print("タスクが完了しました")

タスクを実行中
タスクが完了しました

import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
urls = [
    "https://api.example.com/data1",
    "https://api.example.com/data2",
    "https://api.example.com/data3"
]
def fetch_data(url):
    response = requests.get(url)
    return response.json()  # JSON形式で結果を返す
results = []
with ThreadPoolExecutor(max_workers=3) as executor:
    futures = {executor.submit(fetch_data, url): url for url in urls}
    for future in as_completed(futures):
        result = future.result()
        results.append(result)
print("取得したデータ:", results)

import threading
data = list(range(1000000))  # 大量のデータ
results = []
lock = threading.Lock()
def process_data(chunk):
    local_result = sum(chunk)  # チャンクの合計を計算
    with lock:
        results.append(local_result)
# データを分割してスレッドで処理
threads = []
chunk_size = 100000
for i in range(0, len(data), chunk_size):
    thread = threading.Thread(target=process_data, args=(data[i:i + chunk_size],))
    threads.append(thread)
    thread.start()
for thread in threads:
    thread.join()
total_sum = sum(results)
print(f"データの合計: {total_sum}")

import threading
def read_file(file_name):
    with open(file_name, 'r') as file:
        return file.read()
file_names = ['file1.txt', 'file2.txt', 'file3.txt']
results = []
threads = []
for file_name in file_names:
    thread = threading.Thread(target=lambda fn=file_name: results.append(read_file(fn)))
    threads.append(thread)
    thread.start()
for thread in threads:
    thread.join()
print("読み込んだファイルの内容:")
for content in results:
    print(content)

import random
import time
import threading
data_collection = []
lock = threading.Lock()
def collect_data():
    while len(data_collection) < 10:  # 10件のデータを収集
        data = random.randint(1, 100)
        with lock:
            data_collection.append(data)
        time.sleep(1)  # データ収集の間隔
# データ収集スレッドを開始
thread = threading.Thread(target=collect_data)
thread.start()
thread.join()  # スレッドの終了を待機
print("収集したデータ:", data_collection)