C++ Linux編程中如何使用信號量

在C++ Linux編程中，信號量（semaphore）是一種用于進程間同步和互斥的機制。它通常用于控制對共享資源的訪問，以防止多個進程同時修改同一資源導致的數據不一致問題。信號量有兩種類型：命名信號量和未命名信號量。

以下是使用信號量的基本步驟：

1. 包含頭文件

首先，需要包含相關的頭文件：

#include <semaphore.h>
#include <fcntl.h>
#include <unistd.h>
#include <iostream>

2. 初始化信號量

可以使用sem_init函數來初始化一個信號量：

sem_t sem;
int ret = sem_init(&sem, 0, 1); // 第一個參數是指向信號量的指針，第二個參數是標志位（0表示信號量在進程內共享），第三個參數是初始值
if (ret != 0) {
    std::cerr << "Failed to initialize semaphore" << std::endl;
    return -1;
}

3. 等待信號量（P操作）

使用sem_wait函數來等待信號量，這相當于執行P操作（減操作）：

ret = sem_wait(&sem);
if (ret != 0) {
    std::cerr << "Failed to wait on semaphore" << std::endl;
    return -1;
}

4. 釋放信號量（V操作）

使用sem_post函數來釋放信號量，這相當于執行V操作（加操作）：

ret = sem_post(&sem);
if (ret != 0) {
    std::cerr << "Failed to post semaphore" << std::endl;
    return -1;
}

5. 銷毀信號量

使用sem_destroy函數來銷毀信號量：

ret = sem_destroy(&sem);
if (ret != 0) {
    std::cerr << "Failed to destroy semaphore" << std::endl;
    return -1;
}

示例代碼

以下是一個簡單的示例，展示了如何使用信號量來保護共享資源：

#include <semaphore.h>
#include <fcntl.h>
#include <unistd.h>
#include <iostream>

sem_t sem;

void* thread_func(void* arg) {
    int fd = *(static_cast<int*>(arg));

    // 等待信號量
    if (sem_wait(&sem) != 0) {
        std::cerr << "Failed to wait on semaphore in thread" << std::endl;
        return nullptr;
    }

    // 訪問共享資源
    std::cout << "Thread " << pthread_self() << " is accessing the shared resource" << std::endl;
    sleep(1); // 模擬對共享資源的操作

    // 釋放信號量
    if (sem_post(&sem) != 0) {
        std::cerr << "Failed to post semaphore in thread" << std::endl;
    }

    return nullptr;
}

int main() {
    // 初始化信號量
    if (sem_init(&sem, 0, 1) != 0) {
        std::cerr << "Failed to initialize semaphore" << std::endl;
        return -1;
    }

    int fd = open("shared_resource.txt", O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        std::cerr << "Failed to open shared resource file" << std::endl;
        sem_destroy(&sem);
        return -1;
    }

    pthread_t threads[5];
    for (int i = 0; i < 5; ++i) {
        int* thread_arg = new int(fd);
        if (pthread_create(&threads[i], nullptr, thread_func, thread_arg) != 0) {
            std::cerr << "Failed to create thread" << std::endl;
            delete thread_arg;
            sem_destroy(&sem);
            close(fd);
            return -1;
        }
    }

    for (int i = 0; i < 5; ++i) {
        pthread_join(threads[i], nullptr);
    }

    // 銷毀信號量
    if (sem_destroy(&sem) != 0) {
        std::cerr << "Failed to destroy semaphore" << std::endl;
    }

    close(fd);
    return 0;
}

在這個示例中，多個線程通過信號量來同步對共享文件的訪問，確保同一時間只有一個線程可以訪問文件。

注意事項

1. 信號量的初始值：信號量的初始值決定了可以同時訪問共享資源的線程數量。例如，初始值為1表示互斥鎖，初始值為N表示最多允許N個線程同時訪問。
2. 錯誤處理：在實際應用中，應該仔細處理所有可能的錯誤情況。
3. 資源清理：確保在程序結束前正確銷毀信號量和關閉文件描述符，以避免資源泄漏。

通過以上步驟和示例代碼，你可以在C++ Linux編程中使用信號量來實現進程間或線程間的同步和互斥。