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

multiprocessing trong Python: đa tiến trình

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

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

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

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

Đa tiến trình trong Python với module multiprocessing chạy một việc tính toán nặng trên nhiều nhân CPU cùng lúc, mỗi phần việc trong một tiến trình riêng. Bạn dùng nó khi chương trình phải tính nhiều thứ độc lập, như tổng hợp số liệu của 12 file báo cáo tháng mà mỗi file mất vài giây tính.

Cần biết trước: module và if __name__, pickle và thread pool.

Vì sao cần nhiều tiến trình

Một tiến trình (process) là một chương trình đang chạy, có bộ nhớ riêng và ít nhất một luồng. Các luồng của bài trước nằm chung một tiến trình, nên trên bản Python cài thông thường chúng chỉ chạy code Python lần lượt, như bài GIL và deadlock đã đo. Nhiều tiến trình thì mỗi tiến trình có trình thông dịch riêng, và hệ điều hành đặt chúng lên các nhân khác nhau. Luồng giống nhiều người làm chung một bàn với một cây bút, còn tiến trình là mỗi người một bàn và một bút.

Việc giao cho tiến trình nên là một hàm nhận một phần dữ liệu và trả về kết quả. Hàm dưới đây cộng bình phương các số trong một đoạn (dau, cuoi). Ở đây nó còn chạy trong một tiến trình, bằng map():

python
def tong_doan(doan):
    dau, cuoi = doan
    return sum(i * i for i in range(dau, cuoi))

cac_doan = [(0, 1000), (1000, 2000), (2000, 3000)]
ket_qua = list(map(tong_doan, cac_doan))
print(ket_qua)
print(sum(ket_qua) == tong_doan((0, 3000)))

KẾT QUẢ

[332833500, 2331833500, 6330833500]
True

Ba đoạn nối liền nhau, nên tổng ba kết quả bằng kết quả của cả đoạn (0, 3000). Đổi (2000, 3000)] thành (2000, 4000)] rồi chạy lại: số thứ ba lớn hơn và dòng cuối in False, vì ba đoạn không còn phủ đúng (0, 3000).

Tạo tiến trình bằng multiprocessing.Process

Từ đây các khối code tạo tiến trình không có nút Chạy: trình chạy trên trang là Python trong trình duyệt, nơi không tạo được tiến trình mới. Kết quả bên dưới là của một lần chạy bằng Python 3.14 trên máy tính.

multiprocessing.Process có cùng cách dùng với threading.Thread: target là hàm, args là tuple đối số, name là tên, rồi start() và join():

python
import multiprocessing as mp
import time

def xu_ly(giay):
    time.sleep(giay)
    print("Xong", mp.current_process().name)

if __name__ == "__main__":
    cac_tt = [mp.Process(target=xu_ly, args=(g,), name=t)
              for t, g in [("thang-10", 0.3), ("thang-11", 0.1)]]
    for tt in cac_tt:
        tt.start()
    for tt in cac_tt:
        tt.join()
    print("Tiến trình chính:", mp.current_process().name)

KẾT QUẢ

Xong thang-11
Xong thang-10
Tiến trình chính: MainProcess

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.

Ở đây multiprocessing được viết tắt là mp. mp.current_process().name là tên của tiến trình đang chạy dòng đó, và tiến trình xong trước in trước. Tiến trình chính tên MainProcess. Lưu code vào file main.py rồi chạy trong terminal.

Windows (PowerShell):

bash
py main.py

macOS/Linux:

bash
python3 main.py

Bảo vệ điểm vào bằng if __name__ == "__main__"

Trên Windows và macOS, Python tạo tiến trình con theo cách spawn: nó mở một trình thông dịch mới rồi import lại file chính để tìm hàm target. Mọi dòng ở cấp cao nhất của file vì thế chạy lại trong tiến trình con. Trong tiến trình con, __name__ là "__mp_main__", nên phần dưới if __name__ == "__main__": chỉ chạy ở tiến trình chính.

Trên Linux, Python 3.12 và 3.13 mặc định dùng cách fork (sao chép tiến trình chính, không import lại), nên code thiếu dòng if vẫn chạy và lỗi chỉ lộ khi chép sang máy khác. Từ Python 3.14, Linux mặc định dùng forkserver, cũng import lại file chính và cũng báo lỗi này (What's New In Python 3.14, mục multiprocessing, đọc ngày 15/11/2026). Hàm target cần nằm ở cấp cao nhất của file, vì tiến trình con tìm nó theo tên. Một lambda không có tên như vậy nên không gửi qua được.

Chia việc cho Pool và ProcessPoolExecutor

Tự tạo từng Process thì không lấy được giá trị trả về. Pool giữ sẵn một nhóm tiến trình, và pool.map() chia các phần tử cho chúng như map() của ví dụ đầu:

python
from multiprocessing import Pool

def tong_doan(doan):
    dau, cuoi = doan
    return sum(i * i for i in range(dau, cuoi))

if __name__ == "__main__":
    cac_doan = [(0, 1000), (1000, 2000), (2000, 3000)]
    with Pool(3) as pool:
        ket_qua = pool.map(tong_doan, cac_doan)
    print(ket_qua)

KẾT QUẢ

[332833500, 2331833500, 6330833500]

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.

Kết quả giống hệt bản chạy bằng map(). Các tiến trình trao đổi dữ liệu qua đối số và giá trị trả về: Python đóng gói từng đoạn bằng pickle, gửi sang tiến trình con, rồi gửi kết quả về theo cùng cách. pool.map() trả list theo đúng thứ tự của cac_doan, dù tiến trình nào xong trước.

ProcessPoolExecutor của concurrent.futures có cùng submit(), map() và with như ThreadPoolExecutor ở bài thread pool, chỉ khác là các việc chạy trong tiến trình. Dưới đây cùng bốn phần việc tính hai lần, rồi in thời gian:

python
import time
from concurrent.futures import ProcessPoolExecutor
M = 5_000_000

def tong_phan(k):
    return sum(i * i for i in range(k * M, (k + 1) * M))

if __name__ == "__main__":
    bat_dau = time.monotonic()
    list(map(tong_phan, range(4)))
    print(f"Một tiến trình: {time.monotonic() - bat_dau:.1f} giây")
    bat_dau = time.monotonic()
    with ProcessPoolExecutor(max_workers=4) as ex:
        list(ex.map(tong_phan, range(4)))
    print(f"Bốn tiến trình: {time.monotonic() - bat_dau:.1f} giây")

KẾT QUẢ

Một tiến trình: 1.8 giây
Bốn tiến trình: 0.6 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.

Trên máy rảnh, bốn nhân cùng tính nên thời gian giảm khoảng ba lần, phần còn lại là công tạo tiến trình và gửi dữ liệu. Trên máy chạy thử, thay ProcessPoolExecutor bằng ThreadPoolExecutor cho bốn luồng mất 1.9 giây, gần bằng một tiến trình, vì luồng của bản Python cài thông thường không tính song song. Máy ít nhân hoặc đang bận cho con số khác.

Kiểm tra nhanh

  1. Khi Python tạo tiến trình con theo cách spawn (mặc định trên Windows và macOS), những câu nào đúng?

    • Tiến trình con chạy lại các dòng ở cấp cao nhất của file chính
    • Tiến trình con dùng chung list với tiến trình chính
    • Code tạo tiến trình phải nằm dưới if __name__ == "__main__":
    • Hàm target phải viết bằng lambda để gửi được sang tiến trình con
  2. Trong khung bẫy sửa list da_xu_ly, vì sao dòng cuối in Đã xử lý: []?

    • Thiếu p.join() nên tiến trình con chưa kịp chạy
    • append() không chạy được trong tiến trình con
    • Tiến trình con thêm phần tử vào bản da_xu_ly trong bộ nhớ riêng của nó
  3. Trong ví dụ Pool, nếu đoạn (0, 1000) tính xong sau cùng thì ket_qua xếp theo thứ tự nào?

    • Theo thứ tự của cac_doan, đoạn (0, 1000) vẫn đứng đầu
    • Theo thứ tự xong, đoạn (0, 1000) đứng cuối
    • Mỗi lần chạy một thứ tự khác
  4. Trong ví dụ đo thời gian, nếu đổi ProcessPoolExecutor thành ThreadPoolExecutor thì dòng thứ hai in khoảng bao nhiêu giây trên bản Python cài thông thường?

    • Khoảng 0.6 giây
    • Khoảng 1.9 giây
    • Khoảng 0.2 giây
Đúng hết lần đầu +15 XP

Bài tập

Chia việc thành các đoạn cho Pool

Một chương trình tính trên các số từ 0 tới tong - 1 bằng pool.map(tong_doan, chia_doan(tong, so_phan)). Viết thân hàm chia_doan(tong, so_phan): chia các số đó thành đúng so_phan đoạn liên tiếp, mỗi đoạn là tuple (dau, cuoi) (không tính cuoi). Độ dài các đoạn chênh nhau tối đa 1, đoạn dài hơn đứng trước. Khi tong nhỏ hơn so_phan, các đoạn cuối rỗng, như (2, 2). so_phan luôn từ 1 trở lên.

Ví dụ: chia_doan(10, 3) trả về [(0, 4), (4, 7), (7, 10)].

Trả về: các đoạn theo thứ tự, một list các tuple.

python
def chia_doan(tong, so_phan):
    pass  # Viết thân hàm thay cho dòng này

Tóm tắt

  • Mỗi tiến trình có bộ nhớ và trình thông dịch riêng, nên việc tính toán nặng chạy được trên nhiều nhân CPU.

  • mp.Process(target=xu_ly, args=(g,), name=t) dùng start(), join() như một luồng; tiến trình chính tên MainProcess.

  • Code tạo tiến trình nằm dưới if __name__ == "__main__":, vì cách spawn và forkserver import lại file chính.

  • Tiến trình con không sửa được biến của tiến trình chính; dữ liệu đi qua đối số và giá trị trả về, đóng gói bằng pickle.

  • pool.map() và ProcessPoolExecutor.map() chia việc cho nhóm tiến trình và trả kết quả theo thứ tự đầu vào.

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

Process pool trong Python khác thread pool ở đâu?

ProcessPoolExecutor và ThreadPoolExecutor có cùng submit() và map(). Bản tiến trình hợp với việc tính toán nặng nhưng tốn công tạo tiến trình và đóng gói dữ liệu. Bản luồng hợp với việc chủ yếu là chờ, như tải trang, mà bài thread pool dạy.

Nên dùng bao nhiêu tiến trình?

Thường không quá số nhân CPU, vì thêm tiến trình mà không thêm nhân thì chúng chỉ chia nhau cùng các nhân. Pool() và ProcessPoolExecutor() không có đối số sẽ tự lấy theo số nhân của máy. Việc quá nhỏ thì công gửi dữ liệu lớn hơn phần tiết kiệm được.

Các tiến trình gửi dữ liệu cho nhau thế nào?

Qua đối số và giá trị trả về: Python đóng gói chúng bằng pickle, nên hàm, đối số và kết quả phải là thứ pickle lưu được. Dữ liệu lớn gửi qua lại nhiều lần làm chậm chương trình, nên mỗi tiến trình nên nhận một phần việc vừa đủ lớn.

Làm sao chạy một chương trình khác, như một lệnh terminal, từ Python?

Đó là việc của subprocess.run(), bài subprocess dạy riêng.

Chủ đề

multiprocessing 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