Pythonで学ぶ！並行処理と並列処理徹底比較

Pythonで学ぶ！並行処理と並列処理徹底比較
1. はじめに：処理速度の壁を越える
並行処理と並列処理：基本を理解する
Pythonにおける並行処理の実装：asyncioで非同期処理
Pythonにおける並列処理の実装：multiprocessingでCPUをフル活用
並行処理と並列処理の使い分け：ケーススタディで理解を深める
パフォーマンス計測と最適化：ボトルネックを見つけて改善
まとめ：並行処理と並列処理を使いこなしてPythonを極める

Pythonで学ぶ！並行処理と並列処理徹底比較

はじめに：処理速度の壁を越える

「Pythonのコード、もっと速くならないかな…」そう思ったことはありませんか？特にデータ分析やWebアプリケーション開発では、処理速度がボトルネックになることがあります。そんな時に役立つのが、並行処理と並列処理です。この2つの技術を使いこなせば、Pythonプログラムのパフォーマンスを劇的に向上させることができます。

この記事では、並行処理と並列処理の基本から、Pythonでの実装方法、そして最適な使い分けまで、初心者にもわかりやすく解説します。サンプルコードを豊富に用意しているので、実際に手を動かしながら学べます。さあ、Pythonの処理速度の限界を突破しましょう！

並行処理と並列処理：基本を理解する

並行処理（Concurrency）：見かけ上の同時実行

並行処理とは、複数のタスクが「同時進行しているように見える」処理方式です。シングルコアのCPUでも、タスクを細かく分割し、順番に処理を切り替えることで、あたかも複数のタスクが同時に実行されているかのように見せることができます。

例：

Webブラウザ: 複数のタブを開いて、それぞれ別のWebサイトを表示させている状態。ブラウザは、複数のWebサイトからのデータを少しずつ順番に処理し、表示しています。
ダウンロード: ファイルをダウンロードしながら、別の作業をする。実際には、ダウンロード処理と他の作業が交互に実行されています。

並列処理（Parallelism）：物理的な同時実行

並列処理とは、複数のタスクが「物理的に同時に実行される」処理方式です。並列処理を実現するためには、マルチコアCPUのように、複数の処理ユニットが必要になります。

例：

画像処理: 複数のCPUコアを使って、1枚の画像を分割して処理する。各コアが担当する領域を同時に処理するため、全体としての処理時間が短縮されます。
科学技術計算: 大規模なシミュレーションを複数のCPUコアで同時に実行する。計算を分割することで、より短時間で結果を得ることができます。

並行処理と並列処理：違いを明確に

項目	並行処理 (Concurrency)	並列処理 (Parallelism)	補足
実行方式	複数のタスクが順番に切り替わりながら実行される	複数のタスクが物理的に同時に実行される
必要なハードウェア	シングルコアCPUでも可能	マルチコアCPUなど、複数の処理ユニットが必要
目的	I/O待ち時間の有効活用、見かけ上の同時実行	処理速度の向上
処理の種類	I/Oバウンドなタスク (ネットワーク、ファイルアクセス等)	CPUバウンドなタスク (数値計算、画像処理等)
Pythonの制約	GILの影響を受ける場合がある (マルチスレッド)	GILの影響を受けにくい (マルチプロセス)	GIL (Global Interpreter Lock) は、PythonのCPython実装におけるグローバルロックで、一度に一つのスレッドしかPythonバイトコードを実行できないようにします。これにより、マルチスレッド環境でのCPUバウンドな処理の並列性が制限される場合があります。
実装ライブラリ例	`asyncio`, `threading`	`multiprocessing`
イメージ	一人の人が複数のタスクを少しずつこなす	複数の人がそれぞれのタスクを同時にこなす

重要なポイント:

並列処理は、並行処理の一つの形態と捉えることができます。つまり、並列処理は必ず並行処理でもありますが、並行処理が必ずしも並列処理であるとは限りません。
Pythonのマルチスレッドは、GIL（Global Interpreter Lock）という制約があるため、CPUバウンドな処理においては、必ずしも並列処理として動作するとは限りません。この点については、後のセクションで詳しく解説します。

どちらを使うべきか？タスクの種類を見極める

一般的に、I/Oバウンドなタスク（ネットワーク通信、ファイルアクセスなど）には並行処理が、CPUバウンドなタスク（数値計算、画像処理など）には並列処理が適しています。しかし、PythonのGILの存在や、タスクの特性によって最適な選択は異なります。具体的なケーススタディについては、後のセクションで詳しく解説します。

次のセクションからは、Pythonでこれらの処理を実装するための具体的な方法について学んでいきましょう。

Pythonにおける並行処理の実装：asyncioで非同期処理

asyncioライブラリとは？非同期処理の強力な味方

asyncioは、Pythonで非同期処理を実装するための標準ライブラリです。非同期処理とは、複数のタスクをあたかも同時に実行しているかのように見せる技術です。特に、I/O待ちが発生しやすい処理（ネットワーク通信、ファイルアクセスなど）において、その待ち時間を有効活用することで、プログラム全体の処理効率を向上させることができます。

asyncioライブラリは、シングルスレッドで非同期タスクの実行を制御します。これは、複数のスレッドを生成するよりもオーバーヘッドが少なく、効率的な並行処理を実現できるという利点があります。

非同期処理の基本：async/await構文

非同期処理を理解する上で重要なキーワードは、asyncとawaitです。

async: asyncキーワードは、関数を「コルーチン」として定義するために使用されます。コルーチンとは、中断と再開が可能な関数のことです。通常の関数とは異なり、コルーチンは実行中に一時停止し、他の処理に制御を譲ることができます。
await: awaitキーワードは、コルーチンの中で別のコルーチンやI/O処理の完了を待つために使用されます。awaitを使うと、プログラムは指定された処理が完了するまで一時停止し、その間に他のタスクを実行することができます。これにより、I/O待ち時間を有効活用し、プログラムの応答性を高めることができます。

イベントループ：タスク管理の中枢

イベントループは、非同期タスクの実行を管理する中心的な存在です。タスクのスケジューリング、実行、完了処理などを担当します。asyncio.get_event_loop()関数を使って、現在のイベントループを取得できます。

イベントループは、タスクを順番に実行し、awaitによって一時停止したタスクがあれば、他の実行可能なタスクに処理を切り替えます。このようにして、複数のタスクが効率的に並行処理されるのです。

実践的なコード例：asyncioでWebリクエスト

asyncioとaiohttpライブラリを使って、複数のWebサイトから非同期にデータを取得する例を見てみましょう。

“`python
import asyncio
import aiohttp

async def fetch_url(session, url):
print(f”Fetching {url}”)
async with session.get(url) as response:
return await response.text()

async def main():
urls = [
“https://www.example.com”,
“https://www.google.com”,
“https://www.yahoo.co.jp”,
]
async with aiohttp.ClientSession() as session:
tasks = [fetch_url(session, url) for url in urls]
results = await asyncio.gather(*tasks)
for url, html in zip(urls, results):
print(f”Downloaded {url}: {len(html)} bytes”)

if __name__ == “__main__”:
asyncio.run(main())
“`

このコードのポイント:

aiohttp.ClientSession()で非同期HTTPセッションを作成します。
asyncio.gather(*tasks)で複数のfetch_urlコルーチンを並行して実行し、結果をまとめて取得します。

実行結果例:

“`
Fetching https://www.example.com
Fetching https://www.google.com
Fetching https://www.yahoo.co.jp
Downloaded https://www.example.com: 1256 bytes
Downloaded https://www.google.com: 65432 bytes
Downloaded https://www.yahoo.co.jp: 34567 bytes
“`

asyncioのメリット・デメリット

メリット:

効率的なI/O処理: I/O待ち時間を有効活用し、プログラムの応答性を高めることができます。
軽量な並行処理: 複数のスレッドを生成するよりもオーバーヘッドが少なく、効率的な並行処理を実現できます。
高いスケーラビリティ: 多数の同時接続を処理するのに適しています。

デメリット:

学習コスト: asyncやawaitといった新しい構文を理解する必要があります。
CPUバウンドな処理には不向き: CPUをintensiveに利用する処理の場合、シングルスレッドで実行されるasyncioは、マルチプロセッシングに比べてパフォーマンスが劣る場合があります。
ライブラリの対応: 非同期処理に対応したライブラリを使う必要があります。

まとめ：asyncioでI/Oバウンドな処理を効率化

asyncioは、Pythonで効率的な並行処理を実現するための強力なツールです。I/Oバウンドなタスクを扱う際には、ぜひasyncioの活用を検討してみてください。非同期処理の概念を理解し、asyncやawaitといったキーワードを使いこなすことで、より高度な並行処理を実装できるようになるでしょう。

Pythonにおける並列処理の実装：multiprocessingでCPUをフル活用

multiprocessingライブラリとは？GILの壁を打ち破る

multiprocessingライブラリは、Pythonで並列処理を実現するための強力なツールです。Pythonの弱点であるGIL（Global Interpreter Lock）の制約を回避し、複数のCPUコアをフルに活用できます。これにより、CPUバウンドなタスク、例えば大規模な数値計算やデータ分析などを効率的に処理できます。

プロセスの生成と実行：並列処理の基本

並列処理の基本は、複数のプロセスを生成し、それぞれにタスクを割り当てることです。multiprocessing.Processクラスを使ってプロセスを生成し、start()メソッドでプロセスを開始、join()メソッドでプロセスの終了を待ちます。

コード例：基本的なプロセスの生成と実行

“`python
import multiprocessing
import time

def worker_function(process_id):
print(f”Process {process_id}: 新しいプロセスが実行されました”)
time.sleep(2) # 2秒間処理を待機
print(f”Process {process_id}: プロセスが終了しました”)

if __name__ == “__main__”:
processes = []
for i in range(2):
process = multiprocessing.Process(target=worker_function, args=(i,))
processes.append(process)
process.start()

for process in processes:
process.join()

print(“すべてのプロセスが終了しました”)
“`

このコードのポイント:

multiprocessing.Processで新しいプロセスを生成します。
target引数に実行する関数、args引数に関数に渡す引数を指定します。
process.start()でプロセスを開始し、process.join()でプロセスの終了を待ちます。

実行結果例:

“`
Process 0: 新しいプロセスが実行されました
Process 1: 新しいプロセスが実行されました
Process 0: プロセスが終了しました
Process 1: プロセスが終了しました
すべてのプロセスが終了しました
“`

プロセス間通信：データの共有と受け渡し

複数のプロセス間でデータを共有したり、結果を受け渡したりするには、プロセス間通信（IPC）の仕組みが必要です。multiprocessingライブラリでは、Value、Array、Queueなどのクラスが提供されています。

Value, Array: プロセス間で共有可能な変数や配列を作成します。ただし、排他制御が必要になる場合があります。
Queue: プロセス間で安全にデータを送受信するためのキューを提供します。特に、複数のプロセスが非同期的にデータを生成・消費するような場合に便利です。

コード例：Queueを使ったプロセス間通信

“`python
import multiprocessing

def producer(queue):
for i in range(5):
queue.put(i)
print(f”Producer: {i}をキューに追加”)
queue.put(None) # Consumerに終了信号を送る

def consumer(queue):
while True:
item = queue.get()
if item is None:
break
print(f”Consumer: {item}をキューから取得”)

if __name__ == “__main__”:
queue = multiprocessing.Queue()
p1 = multiprocessing.Process(target=producer, args=(queue,))
p2 = multiprocessing.Process(target=consumer, args=(queue,))

p1.start()
p2.start()

p1.join()
p2.join()
“`

このコードのポイント:

multiprocessing.Queue()でプロセス間で共有するキューを作成します。
producerプロセスがキューにデータを追加し、consumerプロセスがキューからデータを取り出します。
queue.put(None)でconsumerプロセスに終了信号を送ることで、無限ループを回避しています。

実行結果例:

“`
Producer: 0をキューに追加
Producer: 1をキューに追加
Producer: 2をキューに追加
Producer: 3をキューに追加
Producer: 4をキューに追加
Consumer: 0をキューから取得
Consumer: 1をキューから取得
Consumer: 2をキューから取得
Consumer: 3をキューから取得
Consumer: 4をキューから取得
“`

ProcessPoolExecutor：より高度な並列処理

ProcessPoolExecutorは、複数のプロセスをプールとして管理し、並列処理をより簡単に行うための機能です。concurrent.futuresモジュールに含まれており、タスクを非同期的に実行し、結果を収集するのに便利です。

コード例：ProcessPoolExecutorを使った並列処理

“`python
import multiprocessing
from concurrent.futures import ProcessPoolExecutor
import time

def square(x):
time.sleep(1) # 処理時間を作るため
return x * x

if __name__ == “__main__”:
numbers = [1, 2, 3, 4, 5]

with ProcessPoolExecutor(max_workers=multiprocessing.cpu_count()) as executor:
results = executor.map(square, numbers)

for result in results:
print(result)
“`

このコードのポイント:

ProcessPoolExecutor(max_workers=multiprocessing.cpu_count())でプロセスプールを作成します。
executor.map(square, numbers)でsquare関数をnumbersの各要素に対して並列に実行します。
max_workers引数には、利用可能なCPUの数を指定することで、最適な並列度を実現できます。

実行結果例:

“`
1
4
9
16
25
“`

まとめ：multiprocessingでCPUバウンドな処理を高速化

multiprocessingライブラリは、Pythonで真の並列処理を実現するための強力なツールです。プロセスの生成、プロセス間通信、ProcessPoolExecutorの活用など、様々な方法でCPUバウンドなタスクを効率的に処理できます。タスクの種類や要件に応じて、最適な手法を選択し、処理速度を劇的に向上させましょう。

並行処理と並列処理の使い分け：ケーススタディで理解を深める

I/Oバウンド vs CPUバウンド：タスクの特性を見抜く

まず、タスクがI/OバウンドなのかCPUバウンドなのかを見極める必要があります。

I/Oバウンド: 処理時間が主にI/O（Input/Output）の速度に依存するタスクです。例：Webサイトからのデータ取得、ファイルの読み書き、データベースへのアクセスなど。
CPUバウンド: 処理時間が主にCPUの計算能力に依存するタスクです。例：複雑な数値計算、画像処理、動画エンコードなど。

使い分けの指針：最適なツールを選ぶ

I/Oバウンドなタスク: 並行処理（asyncio、threading）が適しています。I/O待ち時間中に他のタスクを実行できるため、効率が向上します。
CPUバウンドなタスク: 並列処理（multiprocessing）が適しています。複数のCPUコアをフル活用し、処理を高速化できます。

ケーススタディ：実践で学ぶ

具体的な例を見ていきましょう。

Webスクレイピング: 複数のWebページから情報を収集するタスク。
- I/Oバウンドなタスクです。Webサーバーからの応答待ち時間が発生するため、並行処理が有効です。
- asyncioを使って非同期にリクエストを送信することで、全体的な処理時間を短縮できます。
画像処理: 大量の画像ファイルのリサイズやフィルタ処理を行うタスク。
- CPUバウンドなタスクです。画像処理の計算にCPUパワーを必要とするため、並列処理が有効です。
- multiprocessingを使って複数のプロセスで画像を並行して処理することで、処理時間を大幅に短縮できます。
データ分析: 大規模なデータセットに対して複雑な統計計算を行うタスク。
- CPUバウンドなタスクです。計算処理に時間がかかるため、並列処理が有効です。
- multiprocessingを使って複数のプロセスでデータを分割し、並行して計算することで、処理時間を短縮できます。
チャットボット: ユーザーからのメッセージをリアルタイムで処理し、応答を返すタスク。
- I/OバウンドとCPUバウンドの混合タスクです。メッセージの受信はI/Oバウンド、自然言語処理はCPUバウンドです。
- asyncioで非同期にメッセージを受信し、multiprocessingで自然言語処理を行うなど、タスクの特性に応じて使い分けることが重要です。

まとめ：タスクに合わせて最適な手法を

これらのケーススタディからわかるように、タスクの特性を見極め、適切な手法を選択することが重要です。I/Oバウンドなタスクには並行処理、CPUバウンドなタスクには並列処理を適用することで、Pythonプログラムのパフォーマンスを最大限に引き出すことができます。

パフォーマンス計測と最適化：ボトルネックを見つけて改善

パフォーマンス計測：現状を把握する

並行処理と並列処理を効果的に活用するには、パフォーマンスの計測と最適化が不可欠です。闇雲に実装するのではなく、ボトルネックを特定し、適切な対策を講じることで、処理速度を劇的に向上させることができます。

まずは、現状のパフォーマンスを把握しましょう。Pythonには標準でcProfileというプロファイリングツールが用意されています。これを使うと、どの関数にどれだけの時間がかかっているかを詳細に分析できます。

コード例：cProfileを使ったプロファイリング

“`python
import cProfile
import pstats

def my_function():
# 時間のかかる処理
result = sum(i*i for i in range(100000))
return result

filename = “profile_output.txt”

# プロファイリング実行
cProfile.run(‘my_function()’, filename)

# 結果の表示
p = pstats.Stats(filename)
p.sort_stats(‘cumulative’).print_stats(10)
“`

このコードのポイント:

cProfile.run()でプロファイリングを実行し、結果をファイルに保存します。
pstats.Stats()でプロファイリング結果を読み込み、sort_stats('cumulative')で累積時間でソートし、print_stats(10)で上位10件を表示します。

また、特定の処理の実行時間を計測するには、timeitモジュールが便利です。簡単なコードで、繰り返し実行した際の平均時間を測定できます。

コード例：timeitを使った時間計測

“`python
import timeit

# 計測するコード
my_code = “””
result = sum(i*i for i in range(10000))
“””

# 実行時間計測
time = timeit.timeit(stmt=my_code, number=100)

print(f”実行時間: {time:.4f}秒”)
“`

ボトルネックの特定：どこに時間がかかっている？

計測結果を基に、ボトルネックとなっている箇所を特定します。CPU使用率、メモリ使用量、ディスクI/Oなどを監視し、どこに負荷が集中しているかを把握しましょう。例えば、CPU使用率が常に100%であれば、CPUバウンドな処理がボトルネックになっている可能性が高いです。

最適化：ボトルネックを解消する

ボトルネックが特定できたら、いよいよ最適化です。以下に、いくつかの代表的なテクニックを紹介します。

タスク粒度の調整: 並行処理や並列処理におけるタスクの分割粒度を調整します。細かすぎるとオーバーヘッドが大きくなり、粗すぎると並行性のメリットを十分に活かせません。適切な粒度を見つけることが重要です。
アルゴリズムの改善: より効率的なアルゴリズムを選択することで、計算量を削減し、処理時間を短縮できます。例えば、ソート処理であれば、クイックソートやマージソートなど、より高速なアルゴリズムを検討します。
データ構造の最適化: 適切なデータ構造を選択することで、データの検索や操作を高速化できます。例えば、検索処理が多い場合は、ハッシュテーブルや平衡木などを検討します。
ライブラリの活用: NumPyやPandasなど、高度に最適化されたライブラリを活用することで、数値計算やデータ分析を高速化できます。
キャッシュの利用: 頻繁にアクセスするデータをキャッシュに保存することで、ディスクI/Oを削減し、処理時間を短縮できます。

その他のテクニック

スレッドプール: concurrent.futuresモジュールのThreadPoolExecutorを使ってスレッドプールを作成し、スレッドの再利用性を向上させます。
キュー: キューを使って複数のスレッド間の作業を調整し、プロデューサー-コンシューマーモデルを実装します。
GILの制限を回避: CPU集中型のタスクには、マルチプロセッシングやasyncioなどの他の並列モデルを検討します。