記錄型信號量

記錄型信號量（counting semaphore）是一種用於進程間同步的機制。它是由內核維護的整型變數，其值在應用程序中被用來控制對共享資源的訪問。當記錄型信號量的值為0時，表示共享資源被佔用，其他進程必須等待直到該資源被釋放。當記錄型信號量的值大於0時，表示共享資源可用。

一、記錄型信號量的基本使用

記錄型信號量的使用通常涉及三個操作：初始化、等待和釋放。在Linux系統中，這些操作通常由下面的函數完成：

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);

使用上述函數，可以創建一個新的記錄型信號量、等待記錄型信號量並且（通過增加一個計數）釋放記錄型信號量。下面是示例代碼：

#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>

static sem_t semaphore; 

int main()
{
    if(sem_init(&semaphore, 0, 1) == -1) {
        perror("Semaphore initialization failed\n");
        exit(EXIT_FAILURE);
    }

    if(fork() == 0) {
        sem_wait(&semaphore);
        printf("Child acquired semaphore\n");
        sleep(2);
        sem_post(&semaphore);
        printf("Child released semaphore\n");
        exit(EXIT_SUCCESS);
    }
    else {
        sem_wait(&semaphore);
        printf("Parent acquired semaphore\n");
        sleep(2);
        sem_post(&semaphore);
        printf("Parent released semaphore\n");
    }

    return 0;
}

上述代碼中，我們創建了一個新的記錄型信號量，並初始化其值為1，表示資源可用。接著，我們使用fork函數創建了一個子進程，父進程和子進程都對資源進行訪問，通過記錄型信號量的等待和釋放建立了對該資源的排他訪問。

二、記錄型信號量的高級用法

記錄型信號量可以用於更高級的機制，如讀寫鎖（RW lock）。如果使用互斥鎖（mutex）來保護共享數據，那麼當一個線程獲取到鎖的時候，其他線程就無法訪問該數據，這時候就存在性能瓶頸。

相比互斥鎖，讀寫鎖通過使多個線程可以同時讀取同一個數據，從而提高了性能。讀寫鎖允許一個線程（或進程）在寫入時獨佔數據，同時允許多個線程（或進程）在讀取時訪問數據。

在Linux系統中，讀寫鎖可以使用記錄型信號量來實現。通過使用兩個信號量，一個信號量記錄讀取數據的線程數，另一個信號量記錄可以寫入數據的線程數（即讀取線程數為0時）。以下是示例代碼：

#include <semaphore.h>
#include <stdio.h>

sem_t read_semaphore;
sem_t write_semaphore;
int reader_count = 0;
int data = 0;
int running = 1;

void *reader(void *arg)
{
    while(running) {
        sem_wait(&read_semaphore);
        reader_count++;
        if(reader_count == 1) {
            sem_wait(&write_semaphore);
        }
        sem_post(&read_semaphore);
        printf("Reader %d read data: %d\n", (int)arg, data);
        sleep(1);
        sem_wait(&read_semaphore);
        reader_count--;
        if(reader_count == 0) {
            sem_post(&write_semaphore);
        }
        sem_post(&read_semaphore);
    }
}

void *writer(void *arg)
{
    while(running) {
        sem_wait(&write_semaphore);
        data++;
        printf("Writer %d wrote data: %d\n", (int)arg, data);
        sleep(2);
        sem_post(&write_semaphore);
    }
}

int main()
{
    pthread_t readers[5], writers[2];
    sem_init(&read_semaphore, 0, 1);
    sem_init(&write_semaphore, 0, 1);
    int i;
    for(i=0;i<5;i++) {
        pthread_create(&readers[i], NULL, reader, (void*)i);
    }
    for(i=0;i<2;i++) {
        pthread_create(&writers[i], NULL, writer, (void*)i);
    }
    sleep(20);
    running = 0;
    return 0;
}

這個示例代碼中，我們定義了一個讀寫鎖，使用兩個記錄型信號量實現。read_semaphore信號量記錄當前讀取數據的線程數，write_semaphore信號量記錄可寫入數據的線程數。在讀取數據時，我們先獲取read_semaphore信號量鎖，同時獲取reader_count計數器，如果當前是第一個讀取數據的線程，則獲取write_semaphore信號量鎖。在讀取完數據後，我們要減少reader_count的計數器。如果當前讀取數據的線程數為0，則釋放write_semaphore信號量鎖。當話，寫入數據時，我們獲取write_semaphore信號量鎖並增加data的值，直到數據被寫入，然後釋放write_semaphore信號量鎖。

三、結論

本文詳細介紹了記錄型信號量的使用，包括基本使用和高級用法。記錄型信號量是內核級別的同步機制，它是用於協調多個進程間對共享資源的訪問的。這種機制可以用於實現信號量、互斥鎖和讀寫鎖等高級同步機制。我們可以在不同的領域中使用記錄型信號量，如系統編程、網路編程、圖形編程和遊戲編程等等，以實現對同步和並發的控制。