Semaphore: nó là gì, nguyên lý hoạt động và ứng dụng trong đồng bộ hóa luồng

Semaphore là gì?

Semaphore là một nguyên thủy đồng bộ hóa sử dụng bộ đếm để kiểm soát quyền truy cập vào tài nguyên dùng chung. Khái niệm này được Edsger Dijkstra đề xuất vào năm 1965 và trở thành nền tảng cho tất cả các cơ chế đồng bộ hóa hiện đại trong hệ điều hành.

Định nghĩa và mục đích

Semaphore là một biến số nguyên với hai thao tác nguyên tử: wait (acquire) và signal (release). Thao tác wait giảm bộ đếm, trong khi signal tăng nó. Khi bộ đếm về không, luồng gọi wait sẽ bị chặn cho đến khi một luồng khác thực thi signal.

Mục đích chính của semaphore là bảo vệ các phần quan trọng khỏi truy cập đồng thời của nhiều luồng. Không giống mutex, semaphore không yêu cầu ràng buộc với luồng sở hữu, làm cho nó phù hợp với nhiều tác vụ điều phối hơn.

Lịch sử và cơ sở lý thuyết

Khái niệm semaphore xuất hiện trong bối cảnh hệ điều hành THE, được phát triển tại Technische Hogeschool Eindhoven. Dijkstra đã chính thức hóa semaphore như một trừu tượng toán học, chứng minh tính đầy đủ của nó để thực hiện bất kỳ nguyên thủy đồng bộ hóa nào.

Semaphore hoạt động như thế nào?

Cơ chế semaphore dựa trên hai thao tác nguyên tử và một hàng đợi chờ nội bộ. Khi acquire được gọi, luồng kiểm tra giá trị bộ đếm và hoặc tiếp tục thực thi hoặc bị chặn cho đến khi tài nguyên được giải phóng.

Bộ đếm và thao tác nguyên tử

Khi tạo semaphore, một giá trị ban đầu của bộ đếm quyền được thiết lập. Mỗi lần gọi acquire giảm bộ đếm đi 1. Nếu bộ đếm trở thành âm sau đó, luồng bị chặn. Thao tác release tăng bộ đếm và đánh thức một trong các luồng đang chờ.

import java.util.concurrent.Semaphore

val semaphore = Semaphore(3)

fun accessResource() {
    semaphore.acquire()
    try {
        println("${Thread.currentThread().name} đang làm việc")
    } finally {
        semaphore.release()
    }
}

Hàng đợi chờ và lập lịch

Khi một luồng gọi acquire với bộ đếm bằng không, hệ điều hành đặt nó vào hàng đợi FIFO của semaphore. Luồng chuyển sang trạng thái BLOCKED, không tiêu tốn thời gian CPU. Sau một lần gọi release, luồng đầu tiên trong hàng đợi chuyển sang trạng thái RUNNABLE và nhận được quyền truy cập vào tài nguyên.

Các loại semaphore

Trong lý thuyết đồng bộ hóa, hai loại semaphore chính được phân biệt: nhị phân và đếm. Việc chọn loại phụ thuộc vào tác vụ quản lý truy cập tài nguyên cụ thể.

Semaphore nhị phân (Binary Semaphore)

Semaphore nhị phân chỉ nhận giá trị 0 và 1. Về hành vi, nó giống mutex, nhưng không có yêu cầu sở hữu — bất kỳ luồng nào cũng có thể thực thi release. Những semaphore này thuận tiện để thực hiện cờ sẵn sàng và sự kiện giữa các luồng.

val ready = Semaphore(0)

fun producer() {
    Thread.sleep(1000)
    ready.release()
}

fun consumer() {
    ready.acquire()
    println("Dữ liệu đã sẵn sàng")
}

Semaphore đếm (Counting Semaphore)

Semaphore đếm có thể nhận bất kỳ giá trị không âm nào. Nó được sử dụng để quản lý một nhóm tài nguyên tương tự có nhiều phiên bản. Ví dụ, một nhóm 5 kết nối mạng: mỗi lần acquire lấy một kết nối, release trả nó về nhóm.

Semaphore đếm không thể thiếu để giới hạn tốc độ truy cập vào các dịch vụ bên ngoài và thực hiện nhóm luồng. Chúng cho phép kiểm soát chính xác mức độ song song mà không cần quản lý luồng thủ công.

Semaphore vs Mutex

Các nhà phát triển thường nhầm lẫn semaphore và mutex, mặc dù có sự khác biệt cơ bản giữa chúng. Hiểu những khác biệt này rất quan trọng để chọn cơ chế đồng bộ hóa phù hợp trong một dự án.

Nguyên tắc sở hữu

Sự khác biệt chính là khái niệm sở hữu. Mutex luôn biết luồng nào đã chiếm giữ nó và chỉ luồng đó mới có thể giải phóng nó. Semaphore không có chủ sở hữu: bất kỳ luồng nào cũng có thể gọi release mà không cần gọi acquire. Điều này làm cho mutex an toàn hơn để bảo vệ dữ liệu và semaphore linh hoạt hơn để điều phối.

Hiệu suất và trường hợp sử dụng

Trong thực tế, mutex nhanh hơn cho loại trừ lẫn nhau đơn giản nhờ tối ưu hóa cho các kịch bản điển hình. Semaphore yêu cầu chi phí bổ sung để duy trì bộ đếm. Tuy nhiên, để giới hạn song song hoặc thực hiện mô hình nhà sản xuất-người tiêu dùng, semaphore là không thể thiếu.

Semaphore trong phát triển di động

Trong phát triển ứng dụng di động, Semaphore được sử dụng để quản lý quyền truy cập vào các tài nguyên hạn chế: kết nối mạng, tệp tin, cơ sở dữ liệu và thành phần phần cứng. Các nền tảng hiện đại cung cấp các triển khai tích hợp thuận tiện.

Nhóm kết nối máy chủ

Một trường hợp sử dụng điển hình là nhóm kết nối HTTP. Ứng dụng có thể gửi không quá 4 yêu cầu đồng thời đến máy chủ vì API của nhà cung cấp giới hạn song song. Một semaphore với giá trị ban đầu 4 đảm bảo rằng dưới bất kỳ tải nào, số lượng yêu cầu đồng thời không vượt quá giới hạn, trong khi các luồng khác chờ trong hàng đợi.

Không có semaphore, sự gia tăng đột ngột trong hoạt động người dùng có thể gây quá tải bất ngờ cho cơ sở hạ tầng máy chủ, dẫn đến hết thời gian chờ và lỗi 429 Too Many Requests. Semaphore hoạt động như một cầu chì, cho phép một số lượng cuộc gọi đồng thời được chỉ định chặt chẽ bất kể số lượng luồng hoạt động.

Semaphore trong Kotlin cho Android

Android cung cấp lớp Semaphore từ gói java.util.concurrent. Hãy xem ví dụ về giới hạn yêu cầu mạng đồng thời xuống hai luồng để ngăn quá tải máy chủ.

class ApiClient {
    private val throttle = Semaphore(2)

    suspend fun fetch(url: String): Result {
        throttle.acquire()
        return try {
            httpGet(url)
        } finally {
            throttle.release()
        }
    }
}

DispatchSemaphore trong Swift cho iOS

Trong iOS, DispatchSemaphore từ GCD giải quyết cùng một tác vụ. Các nhà phát triển sử dụng nó để đồng bộ hóa quyền truy cập vào tài nguyên trong mã bất đồng bộ mà không chặn luồng chính.

let semaphore = DispatchSemaphore(value: 3)

func processBatch(_ items: [UIImage]) {
    for img in items {
        semaphore.wait()
        DispatchQueue.global().async {
            applyFilter(to: img)
            semaphore.signal()
        }
    }
}

Lỗi điển hình khi làm việc với semaphore

Lỗi phổ biến nhất là quên release khi xảy ra ngoại lệ. Nếu một luồng kết thúc với lỗi trước khi gọi release, semaphore sẽ bị chặn vĩnh viễn cho các luồng khác. Sử dụng try/finally hoặc defer để đảm bảo giải phóng. Vấn đề thứ hai là deadlock khi chiếm giữ nhiều semaphore theo thứ tự khác nhau bởi các luồng khác nhau.

Mẫu sử dụng semaphore

Semaphore không chỉ được sử dụng để bảo vệ dữ liệu mà còn để điều phối luồng trong các kịch bản đa luồng phức tạp. Biết các mẫu phổ biến giúp tăng tốc phát triển và giảm khả năng xảy ra lỗi đồng bộ hóa.

Có một số mẫu đã được chứng minh cho việc sử dụng semaphore trong các dự án thực tế. Biết chúng giúp tránh các lỗi điển hình và xây dựng các hệ thống đa luồng đáng tin cậy.

Bộ giới hạn tốc độ (Rate Limiter)

Một semaphore với giá trị ban đầu N và release định kỳ qua bộ đếm thời gian thực hiện giới hạn tốc độ của các yêu cầu API. Ví dụ, dịch vụ cho phép 10 yêu cầu mỗi giây: semaphore bắt đầu ở 10, mỗi yêu cầu giảm bộ đếm và một TimerTask riêng biệt đưa bộ đếm về giá trị ban đầu mỗi giây. Điều này bảo vệ cả ứng dụng và máy chủ khỏi quá tải.

Nhà sản xuất-Người tiêu dùng qua semaphore

Trong bài toán nhà sản xuất-người tiêu dùng cổ điển, hai semaphore quản lý một bộ đệm: empty (quyền ghi) và full (quyền đọc). Nhà sản xuất gọi acquire trên empty và release trên full, trong khi người tiêu dùng làm ngược lại. Sơ đồ này đảm bảo người tiêu dùng không bao giờ đọc bộ đệm rỗng và nhà sản xuất không bao giờ làm tràn nó.

Sơ đồ tương tự này là nền tảng cho bộ đệm có giới hạn trong hệ điều hành — một bộ đệm vòng có kích thước cố định. Trong các ứng dụng di động, mẫu này được sử dụng để xử lý hàng đợi hình ảnh, tệp video và sự kiện phân tích.

Tiết lưu yêu cầu mạng

Semaphore được sử dụng thành công để tiết lưu cuộc gọi mạng trong các dịch vụ nền. Ví dụ, một ứng dụng phân tích gửi các gói sự kiện đến máy chủ. Nếu không giới hạn các luồng đồng thời trong thời gian tải đỉnh (khởi động ứng dụng, đồng bộ sau khi ngoại tuyến), số lượng yêu cầu đồng thời có thể vượt quá giới hạn máy chủ. Một semaphore với giá trị ban đầu 3 đảm bảo gửi suôn sẻ và ngăn chặn chặn phía máy chủ.