Summary  
This chapter explains how to use locks to ensure exclusive access to shared data and queues to safely pass information between concurrent tasks, preventing race conditions.

General domain of usage  
Concurrent programming

In this video, we'll use the analogy of The Shared Recipe Book to explain synchronization and communication in Python threads and processes. Imagine two chefs (representing threads) working in a busy kitchen. They both need to update the 'Eggs Used' count in a shared recipe book. If both chefs try to write in the book at the same time, the numbers can get mixed up—this is called a race condition. For example, both chefs see the count as 5, each adds 1, and both write down 6—when it should be 7! This is data corruption caused by unsynchronized access.

To prevent this, we introduce a Lock, which acts like a physical key to the recipe book. Only the chef holding the key can open the book and update the count. Other chefs must wait their turn until the key is available. This ensures that only one chef updates the book at a time, keeping the numbers accurate—just like how a Python lock prevents threads from corrupting shared data.

Now, let's talk about Queues. Think of a Queue as a note box next to the recipe book. Instead of updating the book directly, each chef writes a note with their update and puts it in the box. The box is managed so that only one note is processed at a time, and updates are made safely in order. In Python, queues handle all the necessary locking internally, making it easy for threads or processes to communicate without worrying about race conditions.

Finally, Shared Memory is like a chalkboard on the kitchen wall, visible to all chefs. It's fast because anyone can write on it, but if two chefs write at the same time, their notes can overlap and become unreadable—like smudged chalk. To prevent this, the chefs still need to use the key (Lock) before writing on the chalkboard, ensuring only one writes at a time.

In summary, whether you're using a recipe book (shared data), a note box (queue), or a chalkboard (shared memory), synchronization tools like locks and queues are essential for keeping your data accurate and your kitchen (program) running smoothly. Python provides these tools to help you coordinate threads and processes safely and efficiently.

スレッドやプロセスを扱う際には、データの共有や動作の調整が必要になることが多い。適切な同期を行わないと、2つのスレッドが同時に同じ変数を更新しようとして、**競合状態（race conditions）**と呼ばれる予測不能な結果が発生する可能性がある。これを防ぐために、Python では **ロック（lock）**、**キュー（queue）**、**共有メモリ（shared memory）** などの同期プリミティブが提供されている。

**ロック**は、同時に1つのスレッドだけが特定のコードやデータにアクセスできるようにするシンプルな仕組み。1つのスレッドがロックを取得すると、他のスレッドはそのロックが解放されるまで待機する必要がある。これにより、複数のスレッドによる競合的な変更を防ぐことができる。

**キュー**は、スレッドやプロセス間で安全にデータをやり取りするための強力なツール。キューを使うことで、あるスレッドやプロセスがデータを安全に投入し、別のスレッドやプロセスがそれを取り出すことができる。`queue.Queue` クラス（スレッド用）や `multiprocessing.Queue`（プロセス用）は、内部で必要なロック処理をすべて行うため、競合状態を心配する必要がない。

**共有メモリ**を使うと、プロセス間で同じデータに直接アクセスできるが、競合を避けるためにロックやセマフォなどの同期プリミティブを利用する必要がある。多くの場合、プロセス間通信にはキューを使う方が簡単かつ安全である。

上記の動画では、ロックによって2つのスレッドが共有データを破壊するのを防ぐ方法や、キューを使って並行タスク間で安全にデータを受け渡す方法を示している。

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(10000):
        with lock:  #  Ensuring only one thread enters this block at a time
            counter += 1

threads = []
for _ in range(5):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print("Final counter value:", counter)
# Without the lock, the final value would likely be wrong due to race conditions.
# With the lock, the result is always correct: 50000.

Python で複数のスレッド間でデータを安全に共有するために使用する同期プリミティブはどれですか？

Pythonのモジュールとインポートによる効率的なコード管理の実践的スキルを習得します。より信頼性の高いアプリケーションのための高度なエラーハンドリング技術をマスターし、ファイル操作の自動化をファイルハンドリングで実現し、PytestとUnittestによる堅牢なテスト戦略を学ぶことで、コードの完全性を確保します。

Master Python's exception system for robust error handling and debugging.

Explore advanced techniques for file operations and resource management using context managers.

Compare and apply Python's multithreading and multiprocessing modules for concurrent programming.

Master asynchronous programming in Python using the asyncio library for scalable I/O-bound applications.

Explore how to write, organize, and run tests using Python's unittest and pytest frameworks.

同期と通信