Tối Ưu Hóa Go Concurrency: Bí Kíp Kiểm Soát Goroutines Với Worker Pool (Ví dụ QuickSort)

Lê Lân

18/08/2025

Tối Ưu Hóa Việc Sử Dụng Goroutines Trong Go Với Mô Hình Worker Pool

Mở Đầu

Bạn đã học xong về goroutines và channels trong Go và rất hào hứng với lập trình đồng thời? Tuy nhiên, trước khi bạn bắt đầu tạo ra hàng ngàn goroutine một cách tùy tiện, hãy dành một chút thời gian để tìm hiểu cách quản lý chúng một cách hiệu quả. Trong bài viết này, chúng ta sẽ khám phá khái niệm worker pool và cách thiết kế này giúp quản lý đồng thời trong Go mà không gây quá tải hệ thống.

Hãy tưởng tượng bạn đang dọn đến một nơi ở mới. Đồ đạc của bạn được đóng gói trong các thùng, và bạn có thể mang từng thùng một – nhưng cách này rất mất thời gian. Nếu sức khỏe tốt, bạn có thể mang hai thùng cùng lúc. Tuy nhiên, nếu bạn chủ yếu là “dân cà kê”, thay vì tự mình làm hết, bạn sẽ mời bạn bè đến giúp. Có một đội nhóm hỗ trợ, công việc sẽ hoàn thành nhanh hơn nhiều.

Nhưng vấn đề là, bao nhiêu người là đủ? Cũng chỉ có một cánh cửa để ra vào, nếu quá nhiều người cố mang thùng cùng lúc, họ sẽ va chạm và làm chậm tiến trình. Tương tự trong Go, goroutines giống như những người bạn giúp bạn chuyển đồ, mang đến khả năng xử lý song song, nhưng nếu tạo quá nhiều goroutine, chúng có thể gây ra “kẹt” và ảnh hưởng hiệu suất. Đây chính là lúc worker pool phát huy tác dụng.

1. Goroutines và Channels: Những Khái Niệm Cơ Bản

1.1 Goroutines là gì?

Goroutine là luồng nhẹ (lightweight thread) do runtime Go quản lý, cho phép bạn chạy các hàm đồng thời mà không cần quản lý luồng phức tạp.

1.2 Channels trong Go

Channels được sử dụng để giao tiếp giữa các goroutines, giúp đồng bộ và chia sẻ dữ liệu an toàn. Phù hợp với triết lý của Go: "Đừng giao tiếp bằng cách chia sẻ bộ nhớ mà hãy chia sẻ bộ nhớ bằng cách giao tiếp".

1.3 Ví dụ đơn giản về goroutine và channel

ch := make(chan int)
go func() {
    ch <- someWork()  // Gửi kết quả khi xong việc
}()

otherWork()  // Tiếp tục công việc khác

result := <-ch  // Chờ nhận dữ liệu từ goroutine
fmt.Printf("Got result: %d\n", result)

Ở đây, goroutine con chạy song song, main goroutine tiếp tục làm nhiệm vụ khác, và đợi kết quả thông qua channel. Channels có thể là blocking (chặn đến khi có dữ liệu) hoặc non-blocking.

Thông tin quan trọng: Sử dụng channels với goroutines đảm bảo sự an toàn khi truyền dữ liệu song song, tránh race condition.

2. Concurrency ≠ Parallelism: Vấn Đề Cần Hiểu Rõ

Nhiều người dễ nhầm lẫn concurrency (đa nhiệm) với parallelism (đa luồng song song). Trong Go, bạn có thể có rất nhiều goroutine chạy đồng thời, nhưng số lượng luồng xử lý song song bị giới hạn bởi số lõi CPU thực tế.

Go runtime xếp lịch để chạy goroutine trên các luồng OS, nhưng không đồng nghĩa tất cả goroutine đều chạy cùng lúc. Quá nhiều goroutine cũng tạo ra overhead cho bộ nhớ và bộ điều phối, khiến hiệu năng giảm đi. Vì thế, việc kiểm soát số lượng goroutine là rất cần thiết.

3. Parallelizing Thuật Toán Chia Để Trị Với Worker Pool

3.1 Thuật toán QuickSort truyền thống

QuickSort là ví dụ kinh điển cho chia để trị: chia mảng ban đầu thành hai phần nhỏ hơn, sắp xếp từng phần riêng biệt rồi hợp nhất lại.

func quickSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }

    pivot := arr[len(arr)/2]
    left, right := []int{}, []int{}
    for _, v := range arr {
        if v < pivot {
            left = append(left, v)
        } else if v > pivot {
            right = append(right, v)
        }
    }

    left = quickSort(left)
    right = quickSort(right)
    return append(append(left, pivot), right...)
}

3.2 Phiên bản song song naïve của QuickSort

Ý tưởng đơn giản: tạo ra 2 goroutine để xử lý hai nửa mảng song song:

func quickSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }

    pivot := arr[len(arr)/2]
    left, right := []int{}, []int{}
    for _, v := range arr {
        if v < pivot {
            left = append(left, v)
        } else if v > pivot {
            right = append(right, v)
        }
    }

    leftCh := make(chan []int)
    rightCh := make(chan []int)

    go func() { leftCh <- quickSort(left) }()
    go func() { rightCh <- quickSort(right) }()

    left = <-leftCh
    right = <-rightCh
    return append(append(left, pivot), right...)
}

Tuy nhiên, cách này có một vấn đề lớn: mỗi lần đệ quy chia hai goroutine, số lượng goroutine tăng theo cấp số nhân, dễ dàng vượt quá khả năng CPU xử lý, gây ra tình trạng quá tải.

Lưu ý: Mặc dù goroutine nhẹ, nhưng việc tạo hàng triệu goroutine là không thực tế và ảnh hưởng tiêu cực tới hiệu suất.

3.3 Giải pháp: Worker Pool cho QuickSort

Worker pool là mô hình quản lý một số lượng nhất định “worker” (goroutine) để thực hiện các công việc trong hàng đợi. Giúp kiểm soát độ lớn đồng thời và tránh tạo quá nhiều goroutine.

Ví dụ đơn giản worker pool cho QuickSort:

var workerPool chan struct{}

func init() {
    workerPool = make(chan struct{}, runtime.NumCPU())  // Số worker = số lõi CPU
}

func quickSortWithPool(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }
    if len(arr) < 1000 {  // Dùng thuật toán tuần tự cho mảng nhỏ
        return quickSort(arr)
    }

    pivot := arr[len(arr)/2]
    left, right := []int{}, []int{}
    for _, v := range arr {
        if v < pivot {
            left = append(left, v)
        } else if v > pivot {
            right = append(right, v)
        }
    }

    leftCh := make(chan []int, 1)
    rightCh := make(chan []int, 1)

    // Thuê worker xử lý left partition
    select {
    case workerPool <- struct{}{}:
        go func() {
            defer func() { <-workerPool }()
            leftCh <- quickSortWithPool(left)
        }()
    default:
        leftCh <- quickSort(left)
    }

    // Thuê worker xử lý right partition
    select {
    case workerPool <- struct{}{}:
        go func() {
            defer func() { <-workerPool }()
            rightCh <- quickSortWithPool(right)
        }()
    default:
        rightCh <- quickSort(right)
    }

    sortedLeft := <-leftCh
    sortedRight := <-rightCh
    return append(append(sortedLeft, pivot), sortedRight...)
}

Ở đây, workerPool đóng vai trò là semaphore, giới hạn số goroutine đồng thời chạy không vượt quá số lõi CPU. Nếu không có worker trống, việc xử lý quay về thuật toán tuần tự tránh chờ đợi vô nghĩa.

Điểm nhấn: Mô hình này vừa tận dụng được đa luồng, vừa kiểm soát được độ lớn của concurrency, tránh chạy quá tải.

4. Benchmarking Các Phiên Bản QuickSort

Các thử nghiệm chạy trên tập dữ liệu 100,000 phần tử cho thấy:

Phiên bản	Thời gian thực thi (ms)	Nhận xét
QuickSort tuần tự	32.9421	Nhanh và ổn định
QuickSort song song naïve	66.6936	Chậm hơn do quá tải goroutine
QuickSort với worker pool	31.0905	Tối ưu hơn, vượt QuickSort tuần tự

Lưu ý: Phiên bản naïve song song chậm hơn tuần tự vì chi phí tạo và quản lý nhiều goroutine vượt trội lợi ích song song.

5. Tổng Kết

Qua bài viết, chúng ta nhận thấy:

Goroutines và channels trong Go là công cụ mạnh mẽ nhưng cần sử dụng có kiểm soát.

Concurrency không đồng nghĩa với việc chạy song song hoàn toàn, bị giới hạn bởi số lõi CPU.

Spawn quá nhiều goroutine dễ gây ra hiệu suất kém, chiếm dụng tài nguyên bộ nhớ và xử lý.

Mô hình worker pool giúp giới hạn số goroutine đồng thời, tối ưu sử dụng CPU và cải thiện hiệu năng.

Áp dụng worker pool cho thuật toán QuickSort song song cho thấy cải thiện đáng giá so với cách implementation sơ khai.

Hãy luôn nhớ: Quản lý số lượng goroutine phản ánh sự chuyên nghiệp của lập trình viên Go. Controlled parallelism beats chaotic concurrency every time.

Tham Khảo

Go Blog – Concurrency is not Parallelism

Effective Go – Goroutines and Channels

Kavya Joshi. “Mastering Go concurrency Patterns”, 2023

Go source code repository for this article: https://github.com/gkoos/article-taming-goroutines

Rob Pike, “Concurrency Patterns in Go” – Google Tech Talk

June 15, 2024