Bỏ qua đến nội dung chính
Mục lục

Lock trong Python: đồng bộ luồng, tránh race condition

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 4/9 · Chương 21

Đa luồng, đa tiến trình và asyncio

  • 8 phút
  • Trung cấp
  • Python 3.14
  • Cập nhật

Tranh chấp dữ liệu (race condition) trong Python xảy ra khi hai luồng cùng sửa một biến và kết quả phụ thuộc vào luồng nào chạy trước. Lock là cái khóa cho mỗi lúc chỉ một luồng vào đoạn code sửa biến đó, và bạn cần nó khi nhiều luồng cùng ghi vào một bộ đếm đơn hàng hay một list kết quả chung.

Cần biết trước: đa luồng với threading, context manager và toán tử gán.

Hai luồng cùng ghi một biến

Một lần cộng đơn gồm ba việc: đọc số đơn hiện có, cộng thêm, ghi lại. Nếu luồng thứ hai đọc trong lúc luồng thứ nhất chưa ghi, cả hai cùng đọc một số cũ và một lượt ghi bị đè mất. Giống hai thu ngân cùng nhìn sổ thấy 10 đơn, mỗi người ghi 11, sổ mất một đơn.

Các khối có luồng thật trong bài không có nút Chạy, vì trình duyệt không khởi động được luồng. Kết quả của chúng là của một lần chạy bằng Python 3.14 trên máy tính. Ở đây time.sleep(0.01) kéo dài khoảng giữa đọc và ghi, để lỗi hiện ra ở mọi lần chạy:

python
import threading
import time

dem = {"don": 0}
def nhan_don():
    cu = dem["don"]
    time.sleep(0.01)
    dem["don"] = cu + 1

cac_luong = [threading.Thread(target=nhan_don) for _ in range(5)]
for luong in cac_luong:
    luong.start()
for luong in cac_luong:
    luong.join()
print("Số đơn đã ghi:", dem["don"])

KẾT QUẢ

Số đơn đã ghi: 1

Chạy trên máy của bạn · Đoạn này cần Python cài trên máy, trang không chạy được.

Năm luồng cùng đọc 0 trước khi luồng nào kịp ghi, nên cả năm cùng ghi 1. Bỏ time.sleep() đi và viết dem["don"] += 1 thì lỗi vẫn có thể xảy ra, chỉ là hiếm và không lặp lại được: nó tùy máy, tùy bản Python và tùy lúc hệ điều hành chuyển luồng. Chính điều đó làm race condition khó tìm.

Khóa đoạn đọc và ghi bằng Lock

threading.Lock() tạo một khóa. acquire() lấy khóa, release() nhả khóa, và locked() cho biết khóa đang bị giữ không. Dùng khóa trong câu lệnh with thì khóa tự nhả khi ra khỏi thân, kể cả khi thân ném lỗi. Phần này không cần luồng thật nên chạy được ngay trên trang:

python
import threading

khoa = threading.Lock()
print("Lúc đầu:", khoa.locked())
khoa.acquire()
print("Sau acquire():", khoa.locked())
khoa.release()
with khoa:
    print("Trong with:", khoa.locked())
print("Sau with:", khoa.locked())

KẾT QUẢ

Lúc đầu: False
Sau acquire(): True
Trong with: True
Sau with: False

Đặt cả việc đọc lẫn việc ghi vào thân with khoa: thì luồng khác phải chờ ở dòng with cho tới khi luồng đang giữ khóa ghi xong:

python
import threading
import time
dem = {"don": 0}
khoa = threading.Lock()
def nhan_don():
    with khoa:
        cu = dem["don"]
        time.sleep(0.01)
        dem["don"] = cu + 1
cac_luong = [threading.Thread(target=nhan_don) for _ in range(5)]
for luong in cac_luong:
    luong.start()
for luong in cac_luong:
    luong.join()
print("Số đơn đã ghi:", dem["don"])

KẾT QUẢ

Số đơn đã ghi: 5

Chạy trên máy của bạn · Đoạn này cần Python cài trên máy, trang không chạy được.

Năm luồng giờ vào thân with lần lượt, nên chương trình chạy chậm hơn một chút nhưng không mất đơn nào. Giữ thân with ngắn: chỉ những dòng đọc và ghi biến chung, không đặt việc tải trang vào trong.

Lấy lại khóa trong cùng một luồng: RLock

Một Lock không nhớ ai đang giữ nó. Luồng đang giữ khóa mà gọi một hàm khác cũng cần khóa đó thì nó phải chờ chính nó nhả khóa, và chương trình treo.

RLock (khóa lặp lại được) nhớ luồng nào đang giữ nó và đếm số lần lấy. Cùng luồng đó lấy thêm thì được ngay, và khóa chỉ mở cho luồng khác khi số lần nhả bằng số lần lấy:

python
import threading

khoa = threading.RLock()
def ghi_don(ma_don):
    with khoa:
        return "đã ghi " + ma_don
def nhan_don(ma_don):
    with khoa:
        return ghi_don(ma_don)
print(nhan_don("DH1024"))

KẾT QUẢ

đã ghi DH1024

Hai luồng khóa lẫn nhau, mỗi luồng giữ một khóa mà luồng kia cần, là một lỗi khác tên là deadlock, bài GIL và deadlock bàn riêng.

Giới hạn số luồng cùng làm bằng Semaphore

Có lúc bạn không cần chỉ một luồng, mà cần không quá vài luồng cùng làm, như không mở quá hai kết nối tới một máy chủ. threading.Semaphore(2) là một khóa có hai chỗ: mỗi acquire() lấy một chỗ, mỗi release() trả một chỗ. Với blocking=False, acquire() không chờ mà trả False khi hết chỗ:

python
import threading

cho_trong = threading.Semaphore(2)
print(cho_trong.acquire(blocking=False))
print(cho_trong.acquire(blocking=False))
print(cho_trong.acquire(blocking=False))
cho_trong.release()
print(cho_trong.acquire(blocking=False))

KẾT QUẢ

True
True
False
True

Với luồng thật, mỗi luồng tải trang vào with cho_trong: và luồng thứ ba chờ tới khi có chỗ trống:

python
import threading
import time

cho_trong = threading.Semaphore(2)
def tai(trang):
    with cho_trong:
        time.sleep(0.2)
bat_dau = time.monotonic()
cac_luong = [threading.Thread(target=tai, args=(t,))
    for t in ["bang-gia", "lich-hoc", "tin-tuc", "su-kien"]]
for luong in cac_luong:
    luong.start()
for luong in cac_luong:
    luong.join()
print(f"Bốn trang, hai chỗ: {time.monotonic() - bat_dau:.1f} giây")

KẾT QUẢ

Bốn trang, hai chỗ: 0.4 giây

Chạy trên máy của bạn · Đoạn này cần Python cài trên máy, trang không chạy được.

Bốn trang đi thành hai lượt, mỗi lượt hai trang chờ cùng lúc. Chép đoạn code về máy. Đổi Semaphore(2) thành Semaphore(4) rồi chạy lại: dòng cuối in 0.2 giây.

Kiểm tra nhanh

  1. Trong ví dụ năm luồng không có khóa, vì sao dòng cuối in Số đơn đã ghi: 1?

    • Chỉ một trong năm luồng được chạy hàm nhan_don
    • Cả năm luồng đọc dem["don"] là 0 trước khi luồng nào kịp ghi, rồi cùng ghi 1
    • time.sleep() làm bốn luồng còn lại dừng hẳn
  2. Biến khoa được tạo một lần ở cấp cao nhất bằng threading.Lock(). Những cách viết nào trong hàm của luồng giữ cho cu = dem["don"] và dem["don"] = cu + 1 không bị luồng khác chen vào?

    • Đặt hai dòng trong thân with khoa:
    • Đặt hai dòng trong thân with threading.Lock():
    • Gọi khoa.acquire(), viết hai dòng trong try, rồi khoa.release() trong finally
    • Đặt cu = dem["don"] trong thân with khoa:, còn dòng ghi ở ngay sau thân đó
  3. Sau import threading, khoa = threading.RLock() và khoa.acquire(), lệnh print(khoa.acquire(timeout=0.5)) in ra gì?

    • True
    • False
    • Báo lỗi RuntimeError
  4. Sau import threading, cho = threading.Semaphore(2) và cho.acquire(), lệnh print(cho.acquire(blocking=False), cho.acquire(blocking=False)) in ra gì?

    • True True
    • False False
    • True False
Đúng hết lần đầu +15 XP

Bài tập

Đếm đơn hàng an toàn bằng Lock

Nhiều luồng nhận đơn cùng ghi vào một bộ đếm. Viết thân hai phương thức của class SoDon:

  • __init__: gán self.so_don = 0 và self.khoa là một threading.Lock().

  • them(n): trong thân with self.khoa:, cộng n vào self.so_don và trả về số đơn mới. Đọc số trả về ngay trong lúc còn giữ khóa, vì vừa nhả khóa là luồng khác có thể ghi tiếp.

Trình chấm gọi them() trong luồng chính, và có lúc thay self.khoa bằng một khóa giả để xem khóa có được giữ đúng lúc ghi không.

Trả về (của them): số đơn sau khi cộng, một int.

python
import threading

# Viết thân các phương thức thay cho các dòng pass
class SoDon:
    def __init__(self):
        pass

    def them(self, n):
        pass

Tóm tắt

  • Race condition: hai luồng cùng đọc rồi ghi một biến, một lượt ghi bị đè và kết quả đổi theo lần chạy.

  • with khoa: với một threading.Lock() dùng chung cho mỗi lúc một luồng vào thân; khóa tự nhả khi ra khỏi thân.

  • Khóa tạo mới trong hàm của luồng không bảo vệ gì vì mỗi lần gọi có khóa riêng.

  • Lock lấy lần hai trong cùng luồng thì treo; RLock cho luồng đang giữ lấy thêm.

  • Semaphore(n) cho tối đa n luồng cùng vào; acquire(blocking=False) trả False khi hết chỗ.

Câu hỏi thường gặp

Viết += trên biến chung thì có còn race condition không?

Có thể. += trên một biến chung vẫn là đọc, cộng rồi ghi, và luồng khác có thể chen vào giữa. Lỗi hiếm và không lặp lại được, nên đừng dựa vào việc thử vài lần thấy đúng: khóa mọi chỗ ghi biến chung. Bài toán tử gán nói về +=.

Dùng lock trong threading có làm chương trình chậm đi không?

Có, ở đúng đoạn bị khóa: các luồng phải xếp hàng qua thân with. Giữ thân thật ngắn, chỉ dòng đọc và ghi biến chung, còn việc chờ như tải trang đặt ngoài khóa. Bài đa luồng cho thấy vì sao việc chờ cần chạy song song.

Khi nào nên dùng Semaphore thay cho Lock?

Dùng Lock khi chỉ một luồng được sửa dữ liệu chung. Dùng Semaphore(n) khi tối đa n luồng được làm cùng lúc, như giới hạn số kết nối. Nếu chỉ cần chia việc cho một số luồng cố định, ThreadPoolExecutor đã giới hạn số luồng sẵn.

Chủ đề

lock python

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE

  • Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
  • Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
  • Xây hệ thống AI cho doanh nghiệp tại VietPlatform.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập