⭐ Vision Engineer · Chặng 2Bài 7/8Bài học~75 phút

Luồng và hàng đợi: tách chụp ảnh khỏi xử lý, không mất khung

Pipeline producer–consumer bằng threading và queue: đo khung mất, độ trễ, GIL với OpenCV, hàng đợi đầy thì chờ hay bỏ, lỗi trong luồng và thứ tự kết quả.

Luồng và hàng đợi: tách chụp ảnh khỏi xử lý, không mất khung

Học xong bài này, bạn sẽ

  • Đếm khung mất và đo độ trễ của vòng lặp tuần tự
  • Dựng pipeline producer–consumer bằng threading, queue
  • Chọn chính sách khi hàng đợi đầy; bắt lỗi trong luồng

Nên học trước: Kiểm thử hàm xử lý ảnh với pytest

Nội dung bài viết
  1. 1. Camera giả chạy tự do và thời gian từng bước
  2. 2. Vòng lặp tuần tự: mất khung mà không ai biết
  3. 3. Pipeline: ba luồng, hai hàng đợi
  4. 4. GIL: khi nào luồng Python chạy song song thật?
  5. 5. Khi hàng đợi đầy: chờ hay bỏ?
  6. 6. Lỗi trong luồng: luồng chết lặng lẽ
  7. 7. Nhiều luồng xử lý: giữ đúng thứ tự kết quả
  8. 8. Lỗi thường gặp
  9. Tóm tắt
  10. Bài tập

Một trạm kiểm tra làm ba việc cho mỗi sản phẩm: lấy ảnh từ camera, xử lý để ra OK/NG, và lưu ảnh, kết quả cho truy xuất. Viết ba việc nối tiếp trong một vòng lặp là cách tự nhiên nhất, và cũng là nguyên nhân của một lỗi kinh điển: khi bước chậm nhất (thường là ghi ảnh xuống đĩa) cộng với các bước khác dài hơn chu kỳ camera, chương trình mất khung mà không báo gì, và kết quả tới PLC bị trễ theo bước chậm nhất. Bài này tách ba việc thành ba luồng (thread) nối với nhau bằng hàng đợi (queue), mô hình producer–consumer mà mọi phần mềm camera công nghiệp đều dùng. Bạn sẽ đo được số khung mất, độ trễ kết quả, và biết khi nào luồng Python thực sự chạy song song.

Cần: Python 3.8+ (bài dùng toán tử :=), NumPy, OpenCV. Không cần camera thật: một "camera giả" chạy trong luồng riêng mô phỏng camera chạy tự do. Nên học trước: class và dataclass, tổ chức pipeline xử lý. Các khối code nối tiếp nhau trong cùng một file; mọi con số thời gian là của máy thử (CPU 8 luồng) và sẽ khác trên máy bạn.

1. Camera giả chạy tự do và thời gian từng bước

Camera công nghiệp ở chế độ chạy tự do (free-run) chụp đều đặn theo tốc độ khung hình, không chờ chương trình. Ảnh nằm trong bộ đệm có hạn; chương trình lấy không kịp thì ảnh cũ bị ghi đè và mất. Lớp CameraTuDo dưới đây mô phỏng đúng hành vi đó với bộ đệm một khung: một luồng nền chụp mỗi 40 ms (25 khung/giây), mỗi khung có số thứ tự và thời điểm chụp, nhờ đó ta đếm được khung mất (số thứ tự bị nhảy) và đo độ trễ. Khung mẫu số 0 thiếu một vật để có ảnh NG.

threading.Condition cho phép luồng lấy ảnh "ngủ" cho tới khi có khung mới thay vì hỏi liên tục; wait_for chờ đến khi điều kiện đúng hoặc hết thời gian.

import threading
import time
from pathlib import Path

import cv2
import numpy as np


class CameraTuDo:
    """Camera giả chạy tự do (free-run) ở tốc độ cố định trong luồng riêng.
    Chỉ giữ khung mới nhất: nếu chương trình lấy không kịp, khung cũ bị ghi đè và mất,
    giống camera thật khi bộ đệm đầy."""

    def __init__(self, fps=20, cao=1536, rong=2048, so_mau=6):
        self.chu_ky = 1.0 / fps
        rng = np.random.default_rng(0)
        yy, xx = np.mgrid[0:cao, 0:rong]
        nen = 150 + 30 * np.sin(xx / 300.0) + 20 * np.cos(yy / 200.0)
        self.mau = []                                   # tạo trước vài khung rồi quay vòng cho nhẹ máy
        for i in range(so_mau):
            a = nen.copy()
            for k in range(6 if i else 5):              # khung mẫu 0 thiếu một vật: sẽ là NG
                cv2.circle(a, (300 + 280 * k, 700), 90, 40, -1)
            self.mau.append(np.clip(a + rng.normal(0, 4, a.shape), 0, 255).astype(np.uint8))
        self._dk = threading.Condition()
        self._khung = None                              # (số khung, thời điểm chụp, ảnh)
        self._chay = threading.Event()

    def bat_dau(self):
        self._chay.set()
        threading.Thread(target=self._vong_chup, daemon=True, name="camera").start()
        return self

    def _vong_chup(self):
        so, t_ke = 0, time.perf_counter()
        while self._chay.is_set():
            t_ke += self.chu_ky
            time.sleep(max(0.0, t_ke - time.perf_counter()))
            so += 1
            with self._dk:
                self._khung = (so, time.perf_counter(), self.mau[so % len(self.mau)])
                self._dk.notify_all()

    def lay_khung(self, sau_so=0, timeout=1.0):
        """Chờ một khung có số thứ tự lớn hơn sau_so; trả về None nếu quá thời gian."""
        with self._dk:
            if self._dk.wait_for(lambda: self._khung and self._khung[0] > sau_so, timeout):
                return self._khung
        return None

    def dung(self):
        self._chay.clear()


def xu_ly(anh):
    """Đếm vật tối (diện tích ≥ 1000 px): đủ 6 vật là OK."""
    m = cv2.GaussianBlur(anh, (0, 0), 3)
    _, bw = cv2.threshold(m, 90, 255, cv2.THRESH_BINARY_INV)        # nền tối nhất ~100, vật ~40
    _, _, stats, _ = cv2.connectedComponentsWithStats(bw)
    so_vat = int((stats[1:, cv2.CC_STAT_AREA] >= 1000).sum())
    return "OK" if so_vat == 6 else "NG", so_vat


THU_MUC = Path("anh_luu")
THU_MUC.mkdir(exist_ok=True)


def luu(so, anh, ket_qua):
    cv2.imwrite(str(THU_MUC / f"{so:06d}_{ket_qua}.png"), anh)     # PNG: không mất dữ liệu nhưng chậm


cam = CameraTuDo(fps=25).bat_dau()
_, _, anh = cam.lay_khung()
print("kết quả các khung mẫu:", [xu_ly(a) for a in cam.mau])
for ten, ham in (("xử lý", lambda: xu_ly(anh)), ("lưu PNG", lambda: luu(0, anh, "OK"))):
    t = time.perf_counter()
    for _ in range(5):
        ham()
    print(f"{ten}: {1000 * (time.perf_counter() - t) / 5:.0f} ms/khung")
cam.dung()
kết quả các khung mẫu: [('NG', 5), ('OK', 6), ('OK', 6), ('OK', 6), ('OK', 6), ('OK', 6)]
xử lý: 10 ms/khung
lưu PNG: 43 ms/khung

Xử lý mất khoảng 10 ms, nhưng ghi một ảnh PNG 3 megapixel mất khoảng 40 ms: PNG nén không mất dữ liệu nên chậm. Tổng hai bước đã hơn 50 ms, trong khi camera cho một khung mỗi 40 ms.

2. Vòng lặp tuần tự: mất khung mà không ai biết

def chay_tuan_tu(giay=4.0, fps=25):
    cam = CameraTuDo(fps=fps).bat_dau()
    da_lay, truoc, tre = 0, 0, []
    t_dung = time.perf_counter() + giay
    while time.perf_counter() < t_dung:
        khung = cam.lay_khung(sau_so=truoc)
        if khung is None:
            break
        so, t_chup, anh = khung
        kq, _ = xu_ly(anh)
        luu(so, anh, kq)
        tre.append(time.perf_counter() - t_chup)
        da_lay += 1
        truoc = so
    cam.dung()
    return truoc, da_lay, tre


tong, da_lay, tre = chay_tuan_tu()
print(f"tuần tự: camera chụp {tong} khung, chương trình lấy được {da_lay}, mất {tong - da_lay} "
      f"({100 * (tong - da_lay) / tong:.0f}%); độ trễ trung vị {1000 * np.median(tre):.0f} ms")
tuần tự: camera chụp 98 khung, chương trình lấy được 76, mất 22 (22%); độ trễ trung vị 69 ms

Gần một phần tư số khung bị mất, và chương trình không hề báo lỗi: nếu không đánh số khung, bạn sẽ không bao giờ biết. Với camera chụp theo trigger từ cảm biến sản phẩm, mất khung nghĩa là có sản phẩm không được kiểm tra, và nếu trạm cho sản phẩm không có kết quả đi qua thì đó là escape (xem trigger, encoder và cycle time). Độ trễ trung vị từ lúc chụp tới lúc có kết quả cũng lên khoảng 70 ms, vì kết quả chỉ có sau khi ảnh trước đã lưu xong.

3. Pipeline: ba luồng, hai hàng đợi

Ý tưởng: mỗi việc một luồng, chuyển dữ liệu bằng queue.Queue. Hàng đợi của thư viện chuẩn đã an toàn khi nhiều luồng cùng dùng (thread-safe): put thêm vào, get lấy ra và tự chờ khi rỗng, nên các luồng không cần chia sẻ biến nào khác.

  • Luồng lấy chỉ lấy khung từ camera và đẩy vào hàng đợi xử lý. Nó phải nhẹ nhất, để không bao giờ lỡ khung.
  • Luồng xử lý ra OK/NG. Ngay lúc này kết quả đã có thể gửi PLC; ảnh được đẩy sang hàng đợi lưu để việc chậm không chặn kết quả.
  • Luồng lưu ghi ảnh. Vì đây là bước chậm nhất, ta cho phép chạy 1 hoặc 2 luồng lưu song song.
  • Dừng sạch: một threading.Event báo luồng lấy dừng; luồng lấy gửi giá trị đặc biệt HET (sentinel, hay gọi là "viên thuốc độc") xuống hàng đợi, mỗi luồng nhận HET thì chuyển tiếp cho luồng sau rồi thoát. Nhờ vậy mọi ảnh đã chụp đều được xử lý và lưu xong trước khi chương trình kết thúc.
import queue

HET = None                                  # "viên thuốc độc" (sentinel): báo luồng sau là đã hết việc


def chay_pipeline(giay=4.0, fps=25, so_luong_luu=1, toi_da_hang_doi=50, chinh_sach="cho"):
    cam = CameraTuDo(fps=fps).bat_dau()
    q_xu_ly = queue.Queue(maxsize=toi_da_hang_doi)
    q_luu = queue.Queue(maxsize=toi_da_hang_doi)
    dung = threading.Event()
    thong_ke = {"da_lay": 0, "cuoi": 0, "tre_kq": [], "da_luu": 0, "max_q_luu": 0, "bo_luu": 0}
    khoa = threading.Lock()                  # bảo vệ thong_ke khi nhiều luồng lưu cùng cộng

    def luong_lay():                         # 1. chỉ lấy khung, không làm gì khác: càng nhanh càng tốt
        truoc = 0
        while not dung.is_set():
            khung = cam.lay_khung(sau_so=truoc, timeout=0.5)
            if khung is None:
                continue
            q_xu_ly.put(khung)
            thong_ke["da_lay"] += 1
            truoc = khung[0]
        thong_ke["cuoi"] = truoc
        q_xu_ly.put(HET)

    def luong_xu_ly():                       # 2. xử lý, trả kết quả ngay (gửi PLC), đẩy việc lưu đi chỗ khác
        while (khung := q_xu_ly.get()) is not HET:
            so, t_chup, anh = khung
            kq, _ = xu_ly(anh)
            thong_ke["tre_kq"].append(time.perf_counter() - t_chup)     # lúc này kết quả đã có thể gửi PLC
            if chinh_sach == "cho":
                q_luu.put((so, anh, kq))                 # hàng đợi đầy thì đứng chờ
            else:
                try:
                    q_luu.put_nowait((so, anh, kq))      # đầy thì bỏ ảnh này, đếm lại để báo động
                except queue.Full:
                    thong_ke["bo_luu"] += 1
            thong_ke["max_q_luu"] = max(thong_ke["max_q_luu"], q_luu.qsize())
        for _ in range(so_luong_luu):
            q_luu.put(HET)

    def luong_luu():                         # 3. lưu ảnh: chậm nhất, có thể chạy nhiều luồng
        while (viec := q_luu.get()) is not HET:
            luu(*viec)
            with khoa:
                thong_ke["da_luu"] += 1

    luong = [threading.Thread(target=luong_lay, name="lay"), threading.Thread(target=luong_xu_ly, name="xu_ly")]
    luong += [threading.Thread(target=luong_luu, name=f"luu_{i}") for i in range(so_luong_luu)]
    for t in luong:
        t.start()
    time.sleep(giay)
    dung.set()                               # yêu cầu dừng: luồng lấy thoát vòng, gửi HET xuống dây chuyền
    t_bat_dau_dung = time.perf_counter()
    for t in luong:
        t.join(timeout=10)
    cam.dung()
    thong_ke["thoi_gian_dung"] = time.perf_counter() - t_bat_dau_dung
    return thong_ke


for so_luong_luu in (1, 2):
    tk = chay_pipeline(so_luong_luu=so_luong_luu)
    mat = tk["cuoi"] - tk["da_lay"]
    print(f"pipeline, {so_luong_luu} luồng lưu: chụp {tk['cuoi']}, mất {mat}, đã lưu {tk['da_luu']}; "
          f"trễ kết quả trung vị {1000 * np.median(tk['tre_kq']):.0f} ms, p95 {1000 * np.percentile(tk['tre_kq'], 95):.0f} ms; "
          f"hàng đợi lưu dài nhất {tk['max_q_luu']}; dừng hết sau {tk['thoi_gian_dung']:.1f} s")
pipeline, 1 luồng lưu: chụp 101, mất 0, đã lưu 101; trễ kết quả trung vị 10 ms, p95 11 ms; hàng đợi lưu dài nhất 10; dừng hết sau 0.5 s
pipeline, 2 luồng lưu: chụp 100, mất 0, đã lưu 100; trễ kết quả trung vị 10 ms, p95 15 ms; hàng đợi lưu dài nhất 1; dừng hết sau 0.0 s

Đọc kết quả:

  • Không mất khung nào trong cả hai cấu hình, và độ trễ từ lúc chụp tới lúc có kết quả giảm từ khoảng 70 ms xuống khoảng 10 ms: đúng bằng thời gian xử lý, vì kết quả không còn phải chờ việc lưu.
  • Một luồng lưu không theo kịp: lưu mất khoảng 40 ms mỗi ảnh, gần bằng hoặc hơn chu kỳ camera, nên hàng đợi lưu dài dần (10 ảnh sau 4 giây) và chương trình phải chờ lưu nốt khi dừng. Chạy cả ca, hàng đợi này sẽ đầy (mục 5). Với hai luồng lưu, hàng đợi gần như không ứ.
  • Quy tắc chung của mọi dây chuyền sản xuất, kể cả dây chuyền phần mềm: tốc độ cả hệ = tốc độ của khâu chậm nhất. Hàng đợi chỉ hấp thụ các đợt chậm ngắn; nó không sửa được một khâu chậm hơn chu kỳ. Muốn theo kịp, khâu chậm phải nhanh lên (JPEG thay PNG, chỉ lưu ảnh NG) hoặc chạy song song.
Vì sao dùng biến đếm thường được, mà vẫn có khoa?Trong bài, mỗi khóa của thong_ke chỉ do một luồng ghi (luồng lấy ghi da_lay, luồng xử lý ghi tre_kq), riêng da_luu do nhiều luồng lưu cùng cộng. Phép x += 1 gồm ba bước (đọc, cộng, ghi) và hai luồng có thể xen nhau ở giữa, làm mất một lần cộng. threading.Lock dùng với with khoa: đảm bảo mỗi lúc chỉ một luồng chạy đoạn đó. Nguyên tắc an toàn nhất: các luồng trao đổi dữ liệu qua hàng đợi, hạn chế tối đa biến dùng chung.

4. GIL: khi nào luồng Python chạy song song thật?

CPython có GIL (Global Interpreter Lock): tại mỗi thời điểm chỉ một luồng được chạy mã Python. Vậy vì sao pipeline ở trên nhanh hơn? Vì phần lớn thời gian nằm trong hàm của OpenCV và NumPy viết bằng C/C++, và các hàm này nhả GIL trong lúc tính, cho luồng khác chạy. Ghi file, chờ mạng, chờ camera cũng nhả GIL. Thí nghiệm sau chia cùng một lượng việc cho 1 và 4 luồng:

def do_song_song(ham, so_luong, tong_viec=12):
    """Chia tong_viec lần gọi ham cho so_luong luồng, trả về thời gian chạy (giây)."""
    def lam():
        for _ in range(tong_viec // so_luong):
            ham()
    ds = [threading.Thread(target=lam) for _ in range(so_luong)]
    t = time.perf_counter()
    for x in ds:
        x.start()
    for x in ds:
        x.join()
    return time.perf_counter() - t


anh_thu = CameraTuDo().mau[1]


def opencv_nang():
    cv2.GaussianBlur(anh_thu, (0, 0), 5)


def python_thuan():
    tong = 0
    for v in range(300_000):
        tong += v * v


cv2.setNumThreads(1)              # tắt luồng nội bộ của OpenCV để chỉ đo tác dụng của luồng Python
for ten, ham in (("OpenCV GaussianBlur", opencv_nang), ("vòng lặp Python thuần", python_thuan)):
    t1, t4 = do_song_song(ham, 1), do_song_song(ham, 4)
    print(f"{ten:22s}: 1 luồng {t1:.2f} s, 4 luồng {t4:.2f} s → nhanh gấp {t1 / t4:.1f} lần")
cv2.setNumThreads(-1)             # trả lại mặc định
OpenCV GaussianBlur   : 1 luồng 0.16 s, 4 luồng 0.05 s → nhanh gấp 3.6 lần
vòng lặp Python thuần : 1 luồng 0.24 s, 4 luồng 0.24 s → nhanh gấp 1.0 lần

Với OpenCV, 4 luồng nhanh hơn khoảng 3,5 lần (máy thử có 8 luồng CPU); với vòng lặp Python thuần, không nhanh hơn chút nào. Hệ quả thực tế:

Loại việcLuồng (threading)Cách nên dùng
Chờ I/O: camera, PLC, mạng, ghi đĩaRất hợpLuồng như bài này
Tính toán trong OpenCV, NumPy, ONNX Runtime, PyTorchChạy song song thật (thư viện nhả GIL)Luồng; chú ý thư viện cũng tự dùng nhiều luồng bên trong
Tính toán bằng vòng lặp Python thuầnKhông nhanh hơnVector hóa bằng NumPy (bài NumPy cơ bản), hoặc multiprocessing

Lệnh cv2.setNumThreads(1) trong thí nghiệm tắt các luồng nội bộ của OpenCV để thấy rõ tác dụng của luồng Python. Bình thường OpenCV tự chia một phép tính lớn ra nhiều lõi; khi bạn đã chạy nhiều luồng Python cùng gọi OpenCV, hai cơ chế này tranh lõi CPU với nhau. Trên trạm thật, hãy đo cả hai cách (mặc định, và setNumThreads nhỏ kèm nhiều luồng) rồi chọn cách cho p95 tốt hơn.

Từ Python 3.13 có bản build thử nghiệm "free-threaded" (bỏ GIL). Tới nay đa số thư viện và trạm sản xuất vẫn dùng bản CPython thông thường có GIL, nên các kết luận trên vẫn đúng cho môi trường bạn sẽ gặp.

5. Khi hàng đợi đầy: chờ hay bỏ?

Hàng đợi không có giới hạn (maxsize=0) sẽ "nuốt" ảnh tới khi hết RAM: 3 MB mỗi ảnh, ứ 2000 ảnh là 6 GB. Luôn đặt maxsize, và quyết định trước điều gì xảy ra khi đầy. Thí nghiệm dưới chạy 8 giây với một luồng lưu (không theo kịp) và hàng đợi chỉ 10 chỗ, so hai chính sách: chờ (put đứng chờ có chỗ) và bỏ và đếm (put_nowait, đầy thì bỏ ảnh đó và tăng bộ đếm).

for chinh_sach in ("cho", "bo"):
    tk = chay_pipeline(giay=8.0, so_luong_luu=1, toi_da_hang_doi=10, chinh_sach=chinh_sach)
    print(f"chính sách '{chinh_sach}': chụp {tk['cuoi']}, mất khung {tk['cuoi'] - tk['da_lay']}, "
          f"không lưu được {tk['bo_luu']}; trễ kết quả p95 {1000 * np.percentile(tk['tre_kq'], 95):.0f} ms, "
          f"max {1000 * max(tk['tre_kq']):.0f} ms")
chính sách 'cho': chụp 200, mất khung 0, không lưu được 0; trễ kết quả p95 282 ms, max 306 ms
chính sách 'bo': chụp 201, mất khung 0, không lưu được 16; trễ kết quả p95 11 ms, max 15 ms
  • "Chờ" làm sự chậm của ổ đĩa lan ngược lên trên (backpressure): luồng xử lý đứng chờ chỗ trong hàng đợi lưu, kết quả tới PLC trễ gần 300 ms (p95), gấp hơn 7 lần chu kỳ camera. Nếu ổ đĩa chậm hơn nữa, hàng đợi xử lý cũng đầy dần và luồng lấy bắt đầu mất khung. Lỗi ở khâu phụ (lưu ảnh) đã làm hỏng khâu chính (kết quả kiểm tra).
  • "Bỏ và đếm" giữ kết quả đúng hạn, không mất khung; cái giá là một số ảnh không được lưu, nhưng được đếm. Bộ đếm này phải được ghi log và báo động (ví dụ quá 1% ảnh không lưu được trong 10 phút), vì đó là dấu hiệu ổ đĩa chậm hoặc sắp đầy.

Chọn chính sách theo vai trò của dữ liệu, không có lựa chọn đúng cho mọi chỗ:

Hàng đợiKhi đầyLý do
Ảnh chờ xử lý (trạm theo trigger)Không được bỏ âm thầm: báo lỗi, trả "LOI" cho sản phẩm đó, PLC loại hoặc dừng dây chuyềnMỗi ảnh là một sản phẩm phải có kết quả
Ảnh chờ lưuBỏ và đếm, báo động khi tỉ lệ bỏ vượt ngưỡng (ưu tiên giữ ảnh NG, bỏ ảnh OK trước)Kết quả kiểm tra quan trọng hơn ảnh lưu trữ
Ảnh hiển thị cho người vận hànhBỏ ảnh cũ, giữ ảnh mới nhấtMàn hình chỉ cần ảnh hiện tại

6. Lỗi trong luồng: luồng chết lặng lẽ

Ngoại lệ trong một luồng phụ không làm dừng chương trình chính: luồng đó in traceback ra stderr (thứ không ai đọc trên máy trạm) rồi chết, các luồng khác vẫn chạy và hàng đợi của nó cứ dày lên. Thí nghiệm dưới đưa một "khung hỏng" (ví dụ camera trả về dữ liệu lỗi) vào luồng xử lý viết ngây thơ, dùng threading.excepthook để bắt thông tin lỗi thay vì để nó in ra.

def luong_ngay_tho(q):
    while (anh := q.get()) is not HET:
        xu_ly(anh)                               # anh = None (khung hỏng) → cv2.error, luồng chết


q = queue.Queue()
t = threading.Thread(target=luong_ngay_tho, args=(q,), name="xu_ly_ngay_tho")
loi_bat_duoc = []
threading.excepthook = lambda tham_so: loi_bat_duoc.append((tham_so.thread.name, tham_so.exc_type.__name__))
t.start()
for anh in [anh_thu, "khung_hong", anh_thu, anh_thu]:
    q.put(anh)
time.sleep(0.5)
print("luồng còn sống?", t.is_alive(), "| việc còn trong hàng đợi:", q.qsize(), "| lỗi:", loi_bat_duoc)
threading.excepthook = threading.__excepthook__     # trả lại mặc định


def luong_an_toan(q, ket_qua):
    """Mỗi việc một try/except: một khung hỏng chỉ làm hỏng kết quả của chính nó."""
    while (viec := q.get()) is not HET:
        so, anh = viec
        try:
            kq, _ = xu_ly(anh)
        except Exception as loi:                  # bắt rộng ở đây là có chủ đích: luồng không được chết
            kq = f"LOI ({type(loi).__name__})"    # trả "lỗi hệ thống" cho PLC, ghi log, đếm
        ket_qua.append((so, kq))


q, ket_qua = queue.Queue(), []
t = threading.Thread(target=luong_an_toan, args=(q, ket_qua))
t.start()
for i, anh in enumerate([anh_thu, "khung_hong", anh_thu, anh_thu]):
    q.put((i, anh))
q.put(HET)
t.join()
print(ket_qua)
luồng còn sống? False | việc còn trong hàng đợi: 2 | lỗi: [('xu_ly_ngay_tho', 'error')]
[(0, 'OK'), (1, 'LOI (error)'), (2, 'OK'), (3, 'OK')]

Luồng ngây thơ chết ở khung thứ hai, bỏ lại 2 việc trong hàng đợi không ai xử lý. Luồng an toàn bắt lỗi cho từng việc: khung hỏng nhận kết quả "LOI" (gửi PLC là lỗi hệ thống, không phải NG), các khung sau vẫn được xử lý. Đây là một trong số ít chỗ except Exception là đúng, khác với lời khuyên ở bài xử lý lỗi, vì mục tiêu là "luồng không được chết", và lỗi vẫn được ghi lại chứ không bị nuốt. Ngoài ra, luồng chính nên kiểm tra định kỳ t.is_alive() của mọi luồng và dừng trạm có kiểm soát nếu một luồng chết; ở chặng Deployment bạn sẽ gặp lại ý này dưới dạng heartbeat và supervisor.

7. Nhiều luồng xử lý: giữ đúng thứ tự kết quả

Khi một luồng xử lý không đủ, có thể dùng nhiều luồng qua concurrent.futures.ThreadPoolExecutor. Nhưng khung "khó" xử lý lâu hơn, nên kết quả xong không theo thứ tự chụp. Với PLC theo dõi sản phẩm theo thứ tự trên băng tải (FIFO theo encoder), gửi kết quả sai thứ tự nghĩa là thổi nhầm sản phẩm.

from concurrent.futures import ThreadPoolExecutor, as_completed


def xu_ly_mo_phong(so):
    """Khung số 1 và 4 'khó', mất 3 lần thời gian."""
    time.sleep(0.06 if so in (1, 4) else 0.02)
    return so


with ThreadPoolExecutor(max_workers=3) as pool:
    tuong_lai = [pool.submit(xu_ly_mo_phong, so) for so in range(6)]
    print("as_completed (xong trước trả trước):", [f.result() for f in as_completed(tuong_lai)])
    print("map (giữ đúng thứ tự gửi vào):      ", list(pool.map(xu_ly_mo_phong, range(6))))
as_completed (xong trước trả trước): [0, 2, 3, 1, 5, 4]
map (giữ đúng thứ tự gửi vào):       [0, 1, 2, 3, 4, 5]

as_completed trả kết quả theo thứ tự xong: khung 1 và 4 bị đẩy ra sau. pool.map vẫn chạy song song nhưng trả kết quả đúng thứ tự gửi vào (nó chờ khung 1 xong mới trả khung 2, dù khung 2 xong trước). Với pipeline thủ công dùng nhiều luồng xử lý, gắn số thứ tự khung vào mỗi kết quả và để một bước sau sắp xếp lại trước khi gửi; tốt hơn nữa là gửi kèm mã sản phẩm hoặc số chu kỳ để PLC đối chiếu (bài handshake với PLC).

8. Lỗi thường gặp

  • Không đánh số khung: mất khung mà không biết. Luôn đánh số (hoặc đọc frame ID/timestamp từ camera) và đếm khung nhảy.
  • Hàng đợi không giới hạn: RAM tăng dần cả ca rồi máy treo vào ca đêm.
  • Làm việc chậm trong luồng lấy ảnh (lưu, hiển thị, ghi log dài): luồng lấy phải nhẹ nhất.
  • daemon=True cho luồng lưu: chương trình thoát là luồng daemon bị cắt ngang, ảnh đang ghi dở bị hỏng. Chỉ dùng daemon cho luồng không giữ dữ liệu quan trọng (như camera giả ở đây); các luồng khác dừng bằng sentinel và join.
  • Không bắt lỗi trong vòng lặp của luồng: luồng chết lặng lẽ (mục 6).
  • Dùng luồng cho vòng lặp Python thuần rồi thắc mắc vì sao không nhanh hơn (mục 4).

Tóm tắt

  • Vòng lặp tuần tự lấy – xử lý – lưu mất khung khi tổng thời gian vượt chu kỳ camera, và kết quả bị trễ theo bước chậm nhất.
  • Pipeline producer–consumer: mỗi việc một luồng, nối bằng queue.Queue(maxsize=...); dừng sạch bằng Event + sentinel + join.
  • Tốc độ hệ = tốc độ khâu chậm nhất; hàng đợi chỉ hấp thụ đợt chậm ngắn. Khâu chậm phải nhanh lên hoặc chạy song song.
  • GIL: luồng Python chạy song song thật khi thời gian nằm trong OpenCV, NumPy, I/O; không giúp gì cho vòng lặp Python thuần.
  • Quyết định trước chính sách khi hàng đợi đầy: ảnh cần kết quả không được bỏ âm thầm; ảnh lưu trữ thì bỏ và đếm, báo động.
  • Bắt lỗi cho từng việc trong luồng; kiểm tra is_alive(); giữ đúng thứ tự kết quả khi xử lý song song.

Bài tập

Bài 1. Chỉ lưu ảnh NG, và lưu JPEG cho ảnh OK

Sửa hàm luu: ảnh NG lưu PNG, ảnh OK lưu JPEG chất lượng 90. Đo lại thời gian lưu trung bình trên các khung mẫu (5 khung OK, 1 khung NG) và trả lời: với một luồng lưu, pipeline còn ứ hàng đợi không?

Xem đáp án
def luu(so, anh, ket_qua):
    if ket_qua == "NG":
        cv2.imwrite(str(THU_MUC / f"{so:06d}_NG.png"), anh)                        # bằng chứng: không mất dữ liệu
    else:
        cv2.imwrite(str(THU_MUC / f"{so:06d}_OK.jpg"), anh, [cv2.IMWRITE_JPEG_QUALITY, 90])


cam_mau = CameraTuDo()
t = time.perf_counter()
for i, a in enumerate(cam_mau.mau):
    luu(i, a, xu_ly(a)[0])
print(f"lưu trung bình (5 OK JPEG + 1 NG PNG): {1000 * (time.perf_counter() - t) / len(cam_mau.mau):.0f} ms/ảnh")
tk = chay_pipeline(so_luong_luu=1)
print(f"pipeline 1 luồng lưu: mất {tk['cuoi'] - tk['da_lay']} khung, hàng đợi lưu dài nhất {tk['max_q_luu']}")
lưu trung bình (5 OK JPEG + 1 NG PNG): 23 ms/ảnh
pipeline 1 luồng lưu: mất 0 khung, hàng đợi lưu dài nhất 1

JPEG nhanh hơn PNG nhiều lần, nên thời gian lưu trung bình (5 khung OK, 1 khung NG) nhỏ hơn hẳn chu kỳ 40 ms và một luồng lưu là đủ. Đổi định dạng thường rẻ hơn thêm luồng. Lưu ý: JPEG nén mất dữ liệu, không dùng cho ảnh cần phân tích lại pixel (ảnh NG làm bằng chứng, ảnh huấn luyện mô hình); ảnh OK lưu để thống kê, xem lại thì JPEG 90 đủ tốt.

Bài 2. Giám sát độ sâu hàng đợi

Thêm vào chay_pipeline một luồng giám sát: mỗi 0,5 giây in độ dài hai hàng đợi. Chạy với một luồng lưu trong 3 giây. Hàng đợi lưu tăng trung bình bao nhiêu ảnh mỗi giây, và con số đó khớp với thời gian lưu và chu kỳ camera thế nào?

Xem đáp án

Trong chay_pipeline, thêm một hàm luồng nữa ngay trước dòng tạo danh sách luong, và thêm nó vào danh sách:

# (minh họa) đoạn chèn vào trong chay_pipeline
    def luong_giam_sat():                    # 4. giám sát: mỗi 0,5 giây ghi độ sâu hai hàng đợi
        t0 = time.perf_counter()
        while not dung.wait(0.5):            # wait trả về True ngay khi có lệnh dừng
            print(f"t={time.perf_counter() - t0:3.1f} s  q_xu_ly={q_xu_ly.qsize():2d}  q_luu={q_luu.qsize():2d}")

    luong = [threading.Thread(target=luong_lay, name="lay"), threading.Thread(target=luong_xu_ly, name="xu_ly"),
             threading.Thread(target=luong_giam_sat, name="giam_sat")]

Gọi chay_pipeline(giay=3.0, so_luong_luu=1), một lần chạy trên máy mình (lưu PNG đo riêng mất 43 ms/khung):

t=0.5 s  q_xu_ly= 0  q_luu= 3
t=1.0 s  q_xu_ly= 0  q_luu= 5
t=1.5 s  q_xu_ly= 0  q_luu= 6
t=2.0 s  q_xu_ly= 0  q_luu= 9
t=2.5 s  q_xu_ly= 0  q_luu= 9

Hàng đợi xử lý luôn trống (khâu xử lý theo kịp), còn hàng đợi lưu tăng từ 3 lên 9 trong 2 giây, khoảng 3 ảnh mỗi giây. Lý thuyết: tốc độ tăng ≈ (khung camera mỗi giây) − (ảnh lưu được mỗi giây) = 25 − 1000/tlưu. Với 3 ảnh/giây, tlưu thực tế ≈ 1000/22 ≈ 45 ms, chậm hơn một chút so với 43 ms đo riêng, vì khi chạy chung, luồng lưu phải tranh CPU và ổ đĩa với các luồng khác. Dùng dung.wait(0.5) thay vì time.sleep(0.5) để luồng giám sát thoát ngay khi có lệnh dừng. Ghi qsize() vào log của trạm thật là cách phát hiện sớm một khâu sắp không theo kịp, trước khi hàng đợi đầy.

Bài 3. Thêm luồng hiển thị

Người vận hành cần xem ảnh trực tiếp kèm kết quả. Thiết kế (chưa cần code) cách thêm luồng hiển thị vào pipeline sao cho hiển thị chậm (ví dụ màn hình remote desktop) không bao giờ làm chậm kết quả kiểm tra. Hàng đợi hiển thị có maxsize bao nhiêu và chính sách khi đầy là gì?

Xem đáp án

Luồng xử lý, sau khi có kết quả, đẩy (ảnh thu nhỏ, kết quả) vào hàng đợi hiển thị maxsize=1 bằng put_nowait; nếu đầy thì lấy bỏ phần tử cũ (get_nowait) rồi đẩy phần tử mới, tức là luôn giữ ảnh mới nhất. Luồng hiển thị lấy ra và vẽ theo tốc độ của nó (có thể chỉ 5–10 khung/giây). Ảnh nên được thu nhỏ trước (người xem không cần 3 MP) để giảm chi phí vẽ. Lưu ý thêm: nhiều thư viện giao diện (kể cả cv2.imshow trên một số hệ điều hành) yêu cầu vẽ từ luồng chính, nên thường luồng chính đảm nhận hiển thị, còn lấy ảnh và xử lý chạy ở luồng phụ.

Bài tiếp theo: Dự án chặng 2: công cụ chụp và lưu ảnh kiểm tra. Hãy tách lấy ảnh và lưu ảnh của công cụ thành hai luồng như bài này.

Nguồn tham khảo: Python: threading (Thread, Event, Lock, Condition, excepthook), Python: queue, Python: concurrent.futures, Python glossary: global interpreter lock, Python HOWTO: free-threaded Python, OpenCV: setNumThreads (Utility and system functions).

Bài tập thực hành

  1. Chạy pipeline với 1 và 2 luồng lưu, giải thích độ dài hàng đợi lưu.
  2. Chỉ lưu PNG cho ảnh NG, JPEG cho ảnh OK; đo lại xem một luồng lưu có đủ không.

Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.