semaphore 数组

Semaphore是一种同步机制，可以用于多线程或多进程环境中控制并发访问资源的数量。它允许多个线程或进程同时访问一个共享资源，但是可以限制同一时间访问该资源的线程或进程的数量。

Semaphore数组是一组Semaphore对象的集合，每个Semaphore对象都有一个计数器和一个等待队列。当有一个线程或进程尝试获得一个Semaphore对象时，如果计数器大于0，那么该线程或进程可以获得Semaphore对象并将计数器减1；如果计数器等于0，那么该线程或进程将被阻塞并加入到等待队列中。当某个线程或进程释放Semaphore对象时，计数器将加1，并唤醒等待队列中的一个线程或进程。

Semaphore数组可以用于管理一组共享资源，例如数据库连接、文件句柄等。通过控制Semaphore对象的数量和初始值，可以限制并发访问这些共享资源的数量，从而避免竞争条件和死锁问题。

相关问题

多个线程访问固定数组的不短段

可能会导致什么问题？

多个线程同时访问固定数组的不同段时，可能会发生竞态条件（Race Condition）的情况。竞态条件指的是多个线程访问共享资源时，执行顺序不确定，导致最终的结果出现不一致的情况。在访问数组时，如果多个线程同时对相同的数组元素进行写操作，可能会导致数据的不一致和损坏。因此，在多线程编程中，需要使用同步机制来避免竞态条件的出现，如使用互斥锁（Mutex）或信号量（Semaphore）等。

使用信号量机制实现：进程A 和B共享浮点数组data[1000], 它们共同完成对data中浮点数 据的累加计算，由进程A输出 最终结果

下面是使用信号量机制实现进程A和B共享浮点数组data[1000]的代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sem.h>

#define SEM_MUTEX 0
#define SEM_FULL 1

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int semid;
float data[1000];

void init_semaphores() {
    union semun arg;
    unsigned short values[2] = {1, 0}; // binary semaphores
    arg.array = values;
    if ((semid = semget(IPC_PRIVATE, 2, 0666 | IPC_CREAT)) == -1) {
        perror("semget");
        exit(1);
    }
    semctl(semid, 0, SETALL, arg);
}

void remove_semaphores() {
    if (semctl(semid, 0, IPC_RMID, NULL) == -1) {
        perror("semctl");
        exit(1);
    }
}

void wait_semaphore(int semindex) {
    struct sembuf sb;
    sb.sem_num = semindex;
    sb.sem_op = -1;
    sb.sem_flg = SEM_UNDO;
    if (semop(semid, &sb, 1) == -1) {
        perror("semop");
        exit(1);
    }
}

void signal_semaphore(int semindex) {
    struct sembuf sb;
    sb.sem_num = semindex;
    sb.sem_op = 1;
    sb.sem_flg = SEM_UNDO;
    if (semop(semid, &sb, 1) == -1) {
        perror("semop");
        exit(1);
    }
}

void process_A() {
    int i;
    float sum = 0.0;
    for (i = 0; i < 1000; i++) {
        wait_semaphore(SEM_MUTEX); // acquire the mutex semaphore
        data[i] += 1.0; // increment the data array element
        sum += data[i]; // accumulate the sum
        signal_semaphore(SEM_MUTEX); // release the mutex semaphore
    }
    printf("Process A result: %f\n", sum);
}

void process_B() {
    int i;
    for (i = 0; i < 1000; i++) {
        wait_semaphore(SEM_MUTEX); // acquire the mutex semaphore
        data[i] += 2.0; // increment the data array element
        signal_semaphore(SEM_FULL); // release the full semaphore
        signal_semaphore(SEM_MUTEX); // release the mutex semaphore
    }
}

int main() {
    init_semaphores();
    pid_t pid;
    if ((pid = fork()) == -1) {
        perror("fork");
        exit(1);
    } else if (pid == 0) { // child process B
        process_B();
    } else { // parent process A
        process_A();
        wait(NULL);
        remove_semaphores();
    }
    return 0;
}

本例中使用了两个二进制信号量：一个表示互斥（SEMAPHORE_MUTEX），另一个表示缓存区是否已满（SEMAPHORE_FULL）。

进程A和B均可以访问data[]数组。进程A对数组进行累加计算，并输出最终结果；进程B对数组进行累加，每次累加完成后发送一个缓存区已满信号，通知进程A可对数组进行处理。信号量机制确保了进程A和B之间对data[]数组的访问顺序。