Giải thích chi tiết về multiprocessing trong Python｜Từ cơ bản đến nâng cao về xử lý song song

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Giới thiệu

Python là một ngôn ngữ lập trình đa dụng, cung cấp các công cụ mạnh mẽ đặc biệt trong các lĩnh vực xử lý dữ liệu, học máy và phát triển web. Trong số đó, mô-đun multiprocessing là một thư viện quan trọng để thực hiện xử lý song song. Bài viết này sẽ hướng dẫn chi tiết từ cơ bản đến nâng cao về cách sử dụng mô-đun multiprocessing trong Python, kèm theo các minh họa trực quan và kỹ thuật thực tiễn để tối ưu hóa hiệu suất.

2. multiprocessing là gì?

2.1 Tại sao cần xử lý song song?

Python mặc định chạy với một luồng duy nhất (single-thread), nhưng khi xử lý các tác vụ nặng hoặc khối lượng dữ liệu lớn, phương pháp này có giới hạn về tốc độ xử lý. Bằng cách sử dụng xử lý song song, ta có thể thực hiện nhiều tác vụ cùng lúc, tận dụng tối đa tất cả các lõi của CPU và rút ngắn thời gian xử lý. Mô-đun multiprocessing giúp tránh GIL (Global Interpreter Lock) của Python, cho phép sử dụng nhiều tiến trình để thực hiện xử lý song song thực sự.

2.2 Sự khác biệt so với luồng đơn (single-thread)

Trong mô hình luồng đơn, một tiến trình thực hiện từng tác vụ một cách tuần tự, trong khi đa tiến trình (multi-process) cho phép nhiều tiến trình chạy song song. Điều này giúp cải thiện hiệu suất đáng kể trong các tác vụ tiêu tốn nhiều tài nguyên CPU, chẳng hạn như tính toán số lượng lớn hoặc phân tích dữ liệu.

3. Cú pháp cơ bản của mô-đun multiprocessing

3.1 Cách sử dụng lớp Process

Thành phần cơ bản của mô-đun multiprocessing là lớp Process. Lớp này cho phép tạo tiến trình mới một cách đơn giản để thực hiện xử lý song song.

import multiprocessing

def worker_function():
    print("Tiến trình mới đã được thực thi")

if __name__ == "__main__":
    process = multiprocessing.Process(target=worker_function)
    process.start()
    process.join()

Trong đoạn mã trên, worker_function được thực thi trong một tiến trình mới. Phương thức start() dùng để bắt đầu tiến trình, và join() giúp đảm bảo tiến trình hoàn tất trước khi chương trình tiếp tục.

3.2 Truyền tham số vào tiến trình

Để truyền tham số vào tiến trình, ta có thể sử dụng tham số args. Ví dụ sau minh họa cách truyền giá trị vào hàm worker.

def worker(number):
    print(f'Worker {number} đã được thực thi')

if __name__ == "__main__":
    process = multiprocessing.Process(target=worker, args=(5,))
    process.start()
    process.join()

Nhờ cách này, ta có thể truyền dữ liệu động vào tiến trình để thực hiện các tác vụ song song.

4. Chia sẻ dữ liệu và đồng bộ hóa

4.1 Chia sẻ dữ liệu bằng bộ nhớ dùng chung

Trong lập trình đa tiến trình, để chia sẻ dữ liệu một cách an toàn giữa các tiến trình, ta có thể sử dụng Value và Array. Đây là các đối tượng bộ nhớ chia sẻ giúp nhiều tiến trình có thể truy cập mà không xảy ra lỗi đồng thời.

import multiprocessing

def increment_value(shared_value):
    with shared_value.get_lock():
        shared_value.value += 1

if __name__ == "__main__":
    shared_value = multiprocessing.Value('i', 0)
    processes = [multiprocessing.Process(target=increment_value, args=(shared_value,)) for _ in range(5)]

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    print(f'Giá trị cuối cùng: {shared_value.value}')

Trong đoạn mã trên, có 5 tiến trình cùng tăng giá trị của một biến chia sẻ. Để tránh lỗi đồng bộ, ta sử dụng get_lock() để khóa tài nguyên trong quá trình cập nhật.

4.2 Ngăn chặn xung đột dữ liệu bằng Lock

Khi nhiều tiến trình cùng thao tác trên một tài nguyên, cần sử dụng cơ chế Lock để ngăn chặn xung đột dữ liệu. Lock giúp đảm bảo rằng tại một thời điểm, chỉ có một tiến trình có thể truy cập vào dữ liệu.

5. Phân phối tác vụ bằng Pool

5.1 Sử dụng lớp Pool

Lớp Pool giúp phân chia nhiều tác vụ cho nhiều tiến trình để thực thi song song. Điều này rất hữu ích khi xử lý lượng lớn dữ liệu hoặc phân phối tác vụ một cách hiệu quả.

from multiprocessing import Pool

def square(x):
    return x * x

if __name__ == "__main__":
    with Pool(4) as pool:
        results = pool.map(square, range(10))
    print(results)

Đoạn mã trên thực hiện tính bình phương của các phần tử trong danh sách và phân phối công việc cho 4 tiến trình chạy song song bằng map().

Hình minh họa: Phân phối tác vụ với lớp Pool

5.2 Ví dụ nâng cao: Sử dụng starmap với nhiều tham số

Hàm starmap() giúp xử lý các hàm có nhiều tham số theo cách song song. Ví dụ sau đây minh họa cách truyền cặp tham số vào một hàm xử lý song song.

def multiply(x, y):
    return x * y

if __name__ == "__main__":
    with Pool(4) as pool:
        results = pool.starmap(multiply, [(1, 2), (3, 4), (5, 6), (7, 8)])
    print(results)

6. Tận dụng tài nguyên CPU một cách tối ưu

6.1 Tối ưu số lượng tiến trình với cpu_count()

Bằng cách sử dụng multiprocessing.cpu_count(), ta có thể lấy số lượng lõi CPU hiện có và tối ưu số lượng tiến trình phù hợp để tránh tình trạng quá tải hệ thống.

from multiprocessing import Pool, cpu_count

if __name__ == "__main__":
    with Pool(cpu_count() - 1) as pool:
        results = pool.map(square, range(100))
    print(results)

6.2 Sử dụng tài nguyên hệ thống một cách hiệu quả

Không nên sử dụng toàn bộ lõi CPU cho tiến trình song song, thay vào đó nên để lại một lõi cho các tác vụ hệ thống để tránh làm chậm toàn bộ hệ thống.

7. Trường hợp sử dụng thực tế và các phương pháp tốt nhất

7.1 Các trường hợp sử dụng cụ thể

Multiprocessing rất hữu ích trong các tình huống sau:

• Xử lý dữ liệu lớn: Hữu ích khi đọc và xử lý nhiều tệp đồng thời.
• Huấn luyện mô hình học máy song song: Giúp huấn luyện mô hình nhanh hơn bằng cách chia dữ liệu cho nhiều tiến trình.
• Web Crawling: Cho phép tải xuống và thu thập dữ liệu từ nhiều trang web cùng một lúc.

7.2 Các phương pháp tốt nhất

• Phân bổ tài nguyên tối ưu: Sử dụng số tiến trình phù hợp với số lõi CPU để tránh quá tải hệ thống.
• Sử dụng logging và debug: Sử dụng mô-đun logging để theo dõi trạng thái của từng tiến trình.

import logging
import multiprocessing

def worker_function():
    logging.info(f'Tiến trình {multiprocessing.current_process().name} đã bắt đầu')

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    process = multiprocessing.Process(target=worker_function, name='Worker 1')
    process.start()
    process.join()

Đoạn mã trên sử dụng logging để theo dõi hoạt động của các tiến trình, giúp dễ dàng kiểm tra lỗi nếu có.

• Xử lý lỗi hợp lý: Khi sử dụng multiprocessing, lỗi có thể ảnh hưởng đến nhiều tiến trình. Cần sử dụng khối try-except để đảm bảo chương trình không bị gián đoạn.

8. Kết luận

Bài viết này đã hướng dẫn cách sử dụng mô-đun multiprocessing trong Python để thực hiện xử lý song song hiệu quả. Từ cách sử dụng lớp Process, chia sẻ dữ liệu, đến phân phối tác vụ bằng Pool, cũng như các trường hợp ứng dụng thực tế.

Bằng cách áp dụng đúng các kỹ thuật xử lý song song, bạn có thể tối ưu hóa hiệu suất của các tác vụ như xử lý dữ liệu lớn, huấn luyện mô hình máy học và thu thập dữ liệu web. Mô-đun multiprocessing là một công cụ mạnh mẽ giúp tận dụng tối đa tài nguyên hệ thống và cải thiện hiệu suất xử lý trong Python.

Hãy thử áp dụng những kiến thức này vào các dự án thực tế để nâng cao hiệu suất lập trình của bạn!