Python並行処理：マルチプロセスで劇的効率化
はじめに：並行処理でプログラムを効率化する
現代のコンピュータはマルチコアCPUを搭載しており、複数の処理を同時に実行する「並行処理」を活用することで、プログラムの処理速度を飛躍的に向上させることができます。Webサーバーが多数のリクエストを同時に処理したり、画像処理ソフトが複数の画像を並行して加工したりするのは、並行処理の応用例です。
Pythonで並行処理が特に重要な理由は、マルチコアCPUの活用とGIL（Global Interpreter Lock）の制約という2点に集約されます。マルチコアCPUの性能を最大限に引き出すためには、処理を分割して複数のコアで同時に実行する必要があります。しかし、PythonにはGILという機構があり、これは一度に一つのスレッドしかPythonバイトコードを実行できないように制限します。そのため、マルチスレッドではCPUバウンドな処理を効率的に並列化できません。そこで、マルチプロセスの出番です。
Pythonにおける並行処理のアプローチには、主にマルチスレッドとマルチプロセスの2種類があります。
- マルチスレッド: 1つのプロセス内で複数のスレッドを生成し、並行に実行します。スレッド間のデータ共有は容易ですが、GILの影響を受けるため、CPUバウンドな処理には不向きです。I/O待ちが多い処理（ネットワーク通信など）に適しています。例えば、Webサーバーが複数のクライアントからのリクエストを処理する場合、各リクエストを別のスレッドで処理することで、効率的な並行処理が可能です。
- マルチプロセス: 複数のプロセスを生成し、並行に実行します。プロセス間のデータ共有は複雑になりますが、GILの影響を受けないため、CPUバウンドな処理に適しています。数値計算や画像処理など、CPUをフルに使う処理に適しています。例えば、大規模なデータセットに対する複雑な計算処理を行う場合、データを分割して複数のプロセスで並行して計算することで、処理時間を大幅に短縮できます。
どちらを選択するかは、プログラムの性質によって決まります。CPUをフル活用する処理にはマルチプロセス、I/O待ちが多い処理にはマルチスレッドが適しています。本記事では、GILの制約を回避し、CPUバウンドな処理を効率化するマルチプロセスに焦点を当て、その具体的な方法を解説します。
Pythonマルチプロセス入門：Processクラスで並行処理を始める
マルチプロセスは、プログラムのパフォーマンスを向上させるための重要な技術です。Pythonでは、multiprocessingモジュールを利用することで、簡単にマルチプロセスを実現できます。特に、Processクラスは、新しいプロセスを生成し、管理するための基本的なツールです。このセクションでは、Processクラスを使ってPythonでマルチプロセスを始める方法を、初心者にもわかりやすく解説します。
Processクラスとは？：並行処理の基本
Processクラスは、新しいプロセスを生成し、並行処理を行うための基本的な構成要素です。各プロセスは独立したメモリ空間を持つため、GIL（Global Interpreter Lock）の影響を受けずに、CPUをフルに活用した並列処理が可能です。
Processクラスの基本的な使い方：プロセスの生成、起動、完了
Processクラスを使った基本的な流れは以下の通りです。
- Processオブジェクトの作成:
Process()コンストラクタに、実行したい関数をtarget引数として渡します。必要に応じて、関数に渡す引数をargs引数にタプルとして指定します。 - プロセスの起動:
start()メソッドを呼び出して、新しいプロセスを開始します。これにより、targetで指定した関数が別のプロセスで実行されます。start()メソッドは非同期的な操作であるため、呼び出した後すぐに次の処理に進みます。 - プロセスの完了待ち:
join()メソッドを呼び出すと、呼び出し元のプロセスは、指定したプロセスが完了するまで待機します。これにより、メインプロセスが子プロセスの処理が終わる前に終了してしまうのを防ぎます。join()メソッドを呼び出さない場合、メインプロセスが先に終了し、子プロセスが強制終了される可能性があります。
以下に、3つのプロセスを生成し、それぞれがworker関数を実行する簡単な例を示します。
import multiprocessing
import time
def worker(num):
print(f'Worker {num}: starting')
time.sleep(2) # 2秒間スリープ
print(f'Worker {num}: finished')
if __name__ == '__main__':
processes = []
for i in range(3):
p = multiprocessing.Process(target=worker, args=(i,))
processes.append(p)
p.start()
for p in processes:
p.join()
print('All workers finished')
実行結果
Worker 0: starting
Worker 1: starting
Worker 2: starting
Worker 0: finished
Worker 1: finished
Worker 2: finished
All workers finished
この例では、worker関数は、開始メッセージを表示し、2秒間スリープした後、終了メッセージを表示します。join()メソッドによって、メインプロセスはすべてのワーカープロセスが完了するまで待機します。
プロセス間通信（IPC）の初歩：Queueを使ってデータを共有する
複数のプロセス間でデータをやり取りするには、IPC（Inter-Process Communication）の仕組みが必要です。multiprocessingモジュールは、Queue、Pipe、Value、Arrayなど、様々なIPCメカニズムを提供しています。
- Queue: プロセス間でデータを安全に送受信するためのFIFO（先入れ先出し）キューです。複数のプロセスが同時にアクセスしても、データが壊れる心配はありません。データの送受信には、
put()メソッドとget()メソッドを使用します。 - Pipe: 2つのプロセス間で双方向にデータを送受信するためのパイプです。シンプルな通信に適しています。
- ValueとArray: プロセス間で共有できる基本的なデータ型と配列です。
ctypesモジュールを使って、C言語のデータ型を共有します。
ここでは、Queueを使った簡単な例を示します。
import multiprocessing
def worker(q, num):
print(f'Worker {num}: putting {num * 2} into queue')
q.put(num * 2)
if __name__ == '__main__':
q = multiprocessing.Queue()
p = multiprocessing.Process(target=worker, args=(q, 1))
p.start()
p.join()
print(f'Main process: getting value from queue: {q.get()}')
実行結果
Worker 1: putting 2 into queue
Main process: getting value from queue: 2
この例では、メインプロセスがQueueオブジェクトを作成し、それをworkerプロセスに渡します。workerプロセスは、計算結果をキューに入れ、メインプロセスがそれを取り出します。
if __name__ == '__main__':の重要性：Windows環境での注意点
multiprocessingを使用するプログラムでは、if __name__ == '__main__':ブロックで囲むことが非常に重要です。これは、特にWindowsなどのプラットフォームで、プロセスをspawn方式で起動する場合に必要となります。spawn方式では、子プロセスが親プロセスのモジュールをインポートして実行するため、if __name__ == '__main__':がないと、子プロセスが無限にプロセスを生成してしまう可能性があります。このブロックは、プログラムが直接実行された場合にのみ、その中のコードが実行されるようにするためのものです。
まとめ：Processクラスで並行処理を始めよう
Processクラスは、Pythonでマルチプロセスを行うための強力なツールです。プロセスの生成、起動、終了、そしてプロセス間通信の基本的な方法を理解することで、CPUバウンドな処理を効率化し、プログラムのパフォーマンスを大幅に向上させることができます。次のセクションでは、Queueを使ったより高度なプロセス間通信について解説します。
Queueで安全なプロセス間通信を実現する
複数のプロセスが連携してタスクを実行する場合、プロセス間でのデータ共有は不可欠です。しかし、複数のプロセスが同時に同じデータにアクセスすると、データの不整合や競合状態が発生する可能性があります。そこで役立つのがQueueクラスです。Queueは、プロセス間でデータを安全に共有するための強力なツールを提供します。
データの共有方法：Queueを使った安全なデータ交換
multiprocessingモジュールのQueueクラスを使うことで、プロセス間で安全にデータを共有できます。基本的な使い方は以下の通りです。
Queueオブジェクトを作成します。- 作成した
Queueオブジェクトを、データを共有したい複数のプロセスに渡します。 - データを送信するプロセスは、
put()メソッドを使ってデータをキューに追加します。 - データを受信するプロセスは、
get()メソッドを使ってキューからデータを取り出します。get()メソッドは、キューが空の場合、データが追加されるまでブロックされます。
以下に、senderプロセスがメッセージをキューにput()し、receiverプロセスがキューからメッセージをget()する簡単なコード例を示します。
from multiprocessing import Process, Queue
def sender(queue, messages):
for message in messages:
print(f'Sender: Sending {message}')
queue.put(message)
def receiver(queue):
while True:
message = queue.get()
if message == 'END':
break
print(f'Receiver: Received {message}')
if __name__ == '__main__':
queue = Queue()
messages = ['Hello', 'World', 'Python', 'END']
sender_process = Process(target=sender, args=(queue, messages))
receiver_process = Process(target=receiver, args=(queue,))
sender_process.start()
receiver_process.start()
sender_process.join()
receiver_process.join()
print('Done!')
実行結果
Sender: Sending Hello
Sender: Sending World
Sender: Sending Python
Sender: Sending END
Receiver: Received Hello
Receiver: Received World
Receiver: Received Python
Receiver: Received END
Done!
この例では、senderプロセスがメッセージをキューにput()し、receiverプロセスがキューからメッセージをget()しています。'END'メッセージを受信すると、receiverプロセスは終了します。
ロックを用いた同期処理：共有リソースへの安全なアクセス
複数のプロセスが共有リソース（ファイル、データベースなど）に同時にアクセスする場合、データの整合性を保つために同期処理が必要です。multiprocessingモジュールには、Lockクラスが用意されており、これを使うことで排他制御を実現できます。
Lockオブジェクトを使う基本的な流れは以下の通りです。
Lockオブジェクトを作成します。- 共有リソースにアクセスする前に、
acquire()メソッドを呼び出してロックを取得します。acquire()メソッドは、ロックが解放されるまでブロックされます。 - 共有リソースへのアクセスが完了したら、
release()メソッドを呼び出してロックを解放します。 with lock:ステートメントを使うと、ロックの取得と解放を自動的に行うことができ、より安全です。withステートメントを抜けると、自動的にロックが解放されます。
以下に、ロックを使った同期処理の例を示します。
from multiprocessing import Process, Lock, Value
def increment(lock, shared_value):
for _ in range(100000):
with lock:
shared_value.value += 1
if __name__ == '__main__':
import multiprocessing
shared_value = Value('i', 0) # 共有メモリに整数を確保
lock = Lock()
processes = [Process(target=increment, args=(lock, shared_value)) for _ in range(2)]
for p in processes:
p.start()
for p in processes:
p.join()
print(f'Final shared value: {shared_value.value}')
実行結果
Final shared value: 200000
この例では、複数のプロセスが共有のカウンタ変数をインクリメントしています。Lockを使うことで、複数のプロセスが同時にカウンタ変数を更新するのを防ぎ、正しい結果を得ることができます。
デッドロックの回避策：複数のロックを使う際の注意点
複数のロックを使用する場合、デッドロックが発生する可能性があります。デッドロックとは、複数のプロセスが互いに相手が解放するのを待っている状態になり、プログラムが停止してしまうことです。デッドロックを回避するためには、以下の戦略が有効です。
- ロックの取得順序を一定にする: 常に同じ順序でロックを取得するようにします。例えば、2つのロック
lock_aとlock_bがある場合、常にlock_aを取得してからlock_bを取得するようにします。 - タイムアウトを使用する: ロックの取得を待つ時間を制限します。
acquire()メソッドにtimeout引数を指定することで、指定した時間内にロックを取得できなかった場合、Falseを返します。これにより、デッドロックが発生した場合でも、プログラムが停止するのを防ぐことができます。 - リソースの競合を最小限に抑える: できる限りロックの使用を避けるように、設計を見直します。例えば、共有リソースへのアクセスを減らすために、データのコピーを作成して各プロセスで処理し、最後に結果を統合するなどの方法があります。
multiprocessingモジュールには、multiprocessing.Conditionクラスも用意されています。これは、特定の条件が満たされるまでプロセスを待機させ、条件が満たされたときに通知を送るための仕組みを提供します。複雑な同期処理が必要な場合に役立ちます。
まとめ：QueueとLockで安全な並行処理を実現しよう
QueueとLockを適切に使うことで、安全かつ効率的な並行処理を実現できます。これらのツールを使いこなし、Pythonでの並行処理の可能性を広げましょう。次のセクションでは、Poolクラスを使って、さらに簡単に並列処理を行う方法を解説します。
Poolで簡単並列処理：複数のタスクを効率的に実行する
Poolクラスは、複数のプロセスを立ち上げ、それらにタスクを分散して並列実行するための便利なツールです。特にCPU負荷の高い処理を効率化したい場合に役立ちます。ここでは、Poolクラスの基本的な使い方から、タスクの分割、結果の収集、そしてエラーハンドリングまでを丁寧に解説します。
Poolクラスとは？：プロセスプールで並列処理を簡単に
multiprocessingモジュールに含まれるPoolクラスは、プロセスプールを簡単に作成できる高レベルなインターフェースを提供します。プロセスプールとは、あらかじめ指定された数のプロセスを起動しておき、タスクが発生するたびにそれらのプロセスにタスクを割り当てる仕組みです。これにより、プロセスの生成と破棄にかかるオーバーヘッドを削減し、効率的な並列処理を実現できます。
基本的な使い方：Poolオブジェクトの作成とタスクの実行
まずは、Poolオブジェクトを作成します。Pool()コンストラクタには、ワーカープロセスの数を指定できます。省略した場合は、CPUのコア数が自動的に設定されます。
from multiprocessing import Pool
# CPUのコア数に合わせてプロセスを生成
with Pool() as pool:
# ここに並列処理したいタスクを記述
pass
withステートメントを使うことで、処理終了後に自動的にプロセスプールがクローズされるため、リソース管理が容易になります。
タスクの分割と実行：map、apply、imapメソッドの使い方
Poolクラスには、タスクを並列実行するための主要なメソッドとして、map()、apply()、imap()などがあります。
map(func, iterable):iterableの各要素に対してfuncを適用し、結果をリストとして返します。map()メソッドは、処理が完了するまでブロックされます。apply(func, args):argsを引数としてfuncを一度だけ実行し、結果を返します。ブロッキング処理です。apply()メソッドは、プロセスプール内の1つのプロセスでタスクを実行する場合に適しています。imap(func, iterable):map()と同様ですが、イテレータを返します。結果を順次処理したい場合に便利です。imap()メソッドは、メモリ使用量を抑えながら、大規模なデータセットを処理する場合に適しています。
以下は、map()を使ってリストの各要素を2乗する例です。
from multiprocessing import Pool
def square(x):
return x * x
if __name__ == '__main__':
numbers = [1, 2, 3, 4, 5]
with Pool() as pool:
results = pool.map(square, numbers)
print(results) # Output: [1, 4, 9, 16, 25]
実行結果
[1, 4, 9, 16, 25]
結果の収集：並列処理の結果をまとめて取得する
map()やimap()などのメソッドは、タスクの結果を自動的に収集します。map()の場合はリストとして、imap()の場合はイテレータとして結果が返されます。
apply()の場合は、直接結果が返されます。
エラーハンドリング：ワーカープロセスで発生した例外を処理する
ワーカープロセスで例外が発生した場合、Poolは例外をキャッチし、呼び出し元のプロセスに伝播します。try...exceptブロックを使用することで、例外を適切に処理できます。
from multiprocessing import Pool
def divide(x, y):
try:
return x / y
except ZeroDivisionError:
return None
if __name__ == '__main__':
numbers = [(10, 2), (5, 0), (8, 4)]
with Pool() as pool:
results = pool.starmap(divide, numbers)
print(results)
実行結果
[5.0, None, 2.0]
上記の例では、starmap()メソッドを使用しています。これは、複数の引数を取る関数を並列実行する場合に便利です。starmap()は、イテラブルの各要素を引数として関数に渡します。
concurrent.futures.ProcessPoolExecutorの利用：より高レベルな並列処理
より高レベルな並列処理の抽象化として、concurrent.futuresモジュールのProcessPoolExecutorも利用できます。ProcessPoolExecutorは、submit()メソッドを使ってタスクを非同期的に実行し、Futureオブジェクトを返します。Futureオブジェクトのresult()メソッドを呼び出すことで、タスクの結果を取得できます。
from concurrent.futures import ProcessPoolExecutor
import time
def task(n):
print(f'Processing {n}')
time.sleep(1) # 1秒待機
return n * 2
if __name__ == '__main__':
numbers = [1, 2, 3]
with ProcessPoolExecutor(max_workers=2) as executor:
futures = [executor.submit(task, n) for n in numbers]
results = [future.result() for future in futures]
print(f'Results: {results}')
実行結果
Processing 1
Processing 2
Processing 3
Results: [2, 4, 6]
まとめ：Poolクラスで並列処理を始めよう
Poolクラスは、Pythonで並列処理を簡単に行うための強力なツールです。タスクの分割、結果の収集、エラーハンドリングなど、並列処理に必要な機能が揃っています。CPU負荷の高い処理を効率化したい場合は、ぜひPoolクラスを活用してみてください。次のセクションでは、マルチプロセスの具体的な活用例を見ていきましょう。
実践例：マルチプロセスで効率化を実感する
ここでは、マルチプロセスの具体的な活用例を見ていきましょう。画像処理、データ分析、Webスクレイピングといった分野で、マルチプロセスがいかに効率化に貢献するかを、具体的なコード例を交えながら解説します。
1. 画像処理の高速化：大量の画像を並列処理する
大量の画像に対して、リサイズやフィルタ処理を一括で行う場合、マルチプロセスが非常に有効です。例えば、画像を一括でグレースケール変換する処理を考えてみましょう。
import os
import glob
from PIL import Image
from multiprocessing import Pool
def to_grayscale(filepath):
try:
img = Image.open(filepath)
img_gray = img.convert('L')
new_filename = 'gray_' + os.path.basename(filepath)
img_gray.save(new_filename)
print(f'変換完了: {filepath} -> {new_filename}')
except Exception as e:
print(f'エラー: {filepath} - {e}')
if __name__ == '__main__':
# imagesディレクトリが存在しなければ作成
if not os.path.exists('images'):
os.makedirs('images')
print("imagesディレクトリを作成しました。サンプル画像(jpg)を入れてください。")
exit()
image_files = glob.glob('images/*.jpg') # imagesディレクトリのjpgファイルを対象
if not image_files:
print("imagesディレクトリにjpg画像が見つかりませんでした。")
exit()
with Pool(processes=4) as pool:
pool.map(to_grayscale, image_files)
print('すべての画像変換が完了しました。')
実行準備
Pillowライブラリをインストールします。pip install Pillowimagesディレクトリを作成し、その中に.jpg画像をいくつか入れてください。
この例では、Poolを使って画像をグレースケール変換するタスクを並列実行しています。processes=4で、4つのプロセスを生成し並列処理を行います。PIL (Pillow) ライブラリを使って画像処理を行っています。
2. データ分析の並列化：Pandasで大規模データを高速処理する
Pandasを使ったデータ分析でも、マルチプロセスは威力を発揮します。大規模なCSVファイルを読み込み、特定の列の平均値を計算する処理を並列化してみましょう。
import pandas as pd
import multiprocessing
import os
def calculate_average(chunk):
try:
return chunk['column_name'].mean() # 'column_name'は分析対象の列名
except KeyError:
print("指定された列名'column_name'は存在しません。")
return None
if __name__ == '__main__':
csv_file = 'large_data.csv'
if not os.path.exists(csv_file):
print(f"{csv_file} が存在しません。")
exit()
num_processes = multiprocessing.cpu_count()
chunk_size = 10000
try:
reader = pd.read_csv(csv_file, chunksize=chunk_size)
with multiprocessing.Pool(processes=num_processes) as pool:
results = pool.map(calculate_average, reader)
# Noneを除外
valid_results = [r for r in results if r is not None]
if valid_results:
final_average = sum(valid_results) / len(valid_results)
print(f'全体の平均値: {final_average}')
else:
print("有効なデータがありません。")
except Exception as e:
print(f"エラーが発生しました: {e}")
実行準備
Pandasライブラリをインストールします。pip install pandaslarge_data.csvファイルを作成し、column_nameという列を含むデータを入れてください。
このコードでは、pd.read_csvのchunksizeオプションでCSVファイルを分割し、各チャンクの平均値をPoolを使って並列に計算しています。 最後に、各チャンクの平均値を合計して、全体の平均値を算出しています。
3. Webスクレイピングの効率化：複数のWebサイトから情報を収集する
複数のWebサイトから情報を収集するWebスクレイピングも、マルチプロセスで効率化できます。各サイトからタイトルと本文を抽出する処理を並列化する例を見てみましょう。
import requests
from bs4 import BeautifulSoup
from multiprocessing import Pool
def scrape_website(url):
try:
response = requests.get(url, timeout=5) # タイムアウト設定
response.raise_for_status() # HTTPエラーをチェック
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.text if soup.title else "タイトルなし"
# 本文抽出処理（例：<article>タグ内のテキストを取得）
article = soup.find('article')
content = article.text if article else '本文なし'
return {'url': url, 'title': title, 'content': content}
except requests.exceptions.RequestException as e:
return {'url': url, 'error': str(e)}
except Exception as e:
return {'url': url, 'error': str(e)}
if __name__ == '__main__':
urls = [
'https://www.example.com',
'https://scrapeme.live/bookstore/',
'https://scrapeme.live/bookstore/'
]
with Pool(processes=4) as pool:
results = pool.map(scrape_website, urls)
for result in results:
if 'error' in result:
print(f'エラー: {result["url"]} - {result["error"]}')
else:
print(f'URL: {result["url"]}')
print(f'タイトル: {result["title"]}')
print(f'本文: {result["content"]}')
実行準備
requestsとbeautifulsoup4ライブラリをインストールします。pip install requests beautifulsoup4
この例では、requestsとBeautifulSoupライブラリを使ってWebページから情報を抽出しています。Poolを使って、複数のURLに対して並列にスクレイピング処理を実行しています。
まとめ：マルチプロセスで様々なタスクを効率化しよう
これらの例からわかるように、マルチプロセスは様々なタスクの効率化に役立ちます。CPUをフル活用し、処理時間を大幅に短縮できるため、ぜひ活用してみてください。次のセクションでは、マルチプロセスのメリット・デメリット、注意点についてまとめます。
まとめ：マルチプロセスのメリット・デメリットと注意点
マルチプロセスは、Pythonで並行処理を実現する強力な手段ですが、その活用にはメリット・デメリットがあります。ここでは、マルチプロセスの効果的な利用のための注意点と、さらなる学習に役立つ情報源をご紹介します。
マルチプロセスのメリット
- CPUバウンドな処理を高速化: GILの制約を受けないため、CPUをフル活用できます。
- 安定性の向上: プロセスが独立しているため、1つのプロセスのエラーが全体に影響しにくいです。ただし、プロセス間通信でエラーが発生した場合は、関連するプロセスに影響が及ぶ可能性があります。
- リソースの分離: 各プロセスが独立したメモリ空間を持つため、リソース競合を避けられます。これにより、複数のプロセスが同時に同じファイルに書き込むような場合でも、データの破損を防ぐことができます。
マルチプロセスのデメリット
- オーバーヘッド: プロセス生成やプロセス間通信にコストがかかります。プロセスの生成には、メモリの確保や初期化などの処理が必要であり、時間がかかる場合があります。また、プロセス間通信には、データのコピーやシリアライズなどの処理が必要であり、オーバーヘッドが発生します。
- メモリ消費: 各プロセスが独自のメモリを持つため、メモリ使用量が増加します。特に、大規模なデータを扱う場合には、メモリ使用量に注意する必要があります。
- 複雑性: マルチスレッドに比べ、実装やデバッグが難しい場合があります。プロセス間通信や同期処理など、マルチプロセス特有の課題に対処する必要があります。
活用時の注意点
- プロセス数の最適化: CPUコア数を超えるプロセスは、かえってパフォーマンスを低下させる可能性があります。プロセスを生成・管理するオーバーヘッドが、並列処理によるメリットを上回ってしまうためです。一般的には、CPUコア数と同じか、少し少ない程度のプロセス数で実行するのが効果的です。
- プロセス間通信の効率化:
QueueなどのIPCメカニズムを適切に選択し、データ転送量を最小限に抑えましょう。プロセス間通信は、プロセス間のデータコピーを伴うため、オーバーヘッドが大きくなりがちです。データのシリアライズ・デシリアライズのコストも考慮し、効率的なデータ転送方法を選択する必要があります。 - デッドロックの回避: ロックの使用順序を統一するなど、デッドロックが発生しないように注意が必要です。デッドロックは、複数のプロセスが互いに相手のロックを待っている状態であり、プログラムが停止してしまう原因となります。ロックの取得順序を固定化する、タイムアウトを設定するなどの対策を講じる必要があります。
if __name__ == '__main__':の徹底: multiprocessingを使用する際は、この記述がないとエラーが発生することがあるため、すべてのサンプルコードに記述されていることを確認する。
さらなる学習のために
- Python公式ドキュメント:
multiprocessingモジュールの詳細な解説が掲載されています。 concurrent.futuresモジュール: より高レベルな並行処理APIを提供します。- オンラインチュートリアルや書籍: 豊富なサンプルコードや実践的なノウハウが得られます。
今後の展望
Pythonの並行処理は進化を続けており、非同期処理との組み合わせや、クラウド環境での活用など、さらなる可能性を秘めています。マルチプロセスをマスターし、より効率的なPythonプログラミングを目指しましょう。
コメント