【嵌入式Linux应用开发基础】进程间通信(5)：信号量

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg);

#include <sys/types.h>
#include <sys/sem.h>

int semop(int semid, struct sembuf *sops, unsigned nsops);

struct sembuf {
    unsigned short sem_num;  // 信号量集中信号量的编号（从 0 开始）
    short          sem_op;   // 操作值，P 操作为 -1，V 操作为 +1
    short          sem_flg;  // 操作标志，如 IPC_NOWAIT（非阻塞操作）
};

#include <sys/types.h>
#include <sys/sem.h>

int semctl(int semid, int semnum, int cmd, ...);

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

// 定义信号量操作函数
void semaphore_p(int semid) {
    struct sembuf sem_op;
    sem_op.sem_num = 0;  // 信号量编号为 0
    sem_op.sem_op = -1;  // P 操作
    sem_op.sem_flg = 0;
    semop(semid, &sem_op, 1);
}

void semaphore_v(int semid) {
    struct sembuf sem_op;
    sem_op.sem_num = 0;  // 信号量编号为 0
    sem_op.sem_op = 1;   // V 操作
    sem_op.sem_flg = 0;
    semop(semid, &sem_op, 1);
}

int main() {
    key_t key;
    int semid;

    // 生成唯一的键值
    key = ftok(".", 'a');
    if (key == -1) {
        perror("ftok");
        exit(1);
    }

    // 创建信号量集
    semid = semget(key, 1, IPC_CREAT | 0666);
    if (semid == -1) {
        perror("semget");
        exit(1);
    }

    // 初始化信号量的值为 1（二进制信号量，用于互斥）
    if (semctl(semid, 0, SETVAL, 1) == -1) {
        perror("semctl");
        exit(1);
    }

    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {  // 子进程
        semaphore_p(semid);
        printf("Child process: Entering critical section\n");
        sleep(2);  // 模拟在临界区的操作
        printf("Child process: Leaving critical section\n");
        semaphore_v(semid);
    } else {  // 父进程
        semaphore_p(semid);
        printf("Parent process: Entering critical section\n");
        sleep(1);  // 模拟在临界区的操作
        printf("Parent process: Leaving critical section\n");
        semaphore_v(semid);
    }

    // 删除信号量集
    if (semctl(semid, 0, IPC_RMID) == -1) {
        perror("semctl");
        exit(1);
    }

    return 0;
}

sem_t mutex;
sem_init(&mutex, 1, 1); // 初始化为1（跨进程）

// 进程A
sem_wait(&mutex);  // 进入临界区
access_shared_resource();
sem_post(&mutex);  // 退出临界区

// 进程B同理

sem_t empty, full;
sem_init(&empty, 1, BUFFER_SIZE); // 初始空闲缓冲区数量
sem_init(&full, 1, 0);           // 初始已填充数量

// 生产者
sem_wait(&empty);  // 等待空闲缓冲区
write_to_buffer();
sem_post(&full);   // 增加已填充计数

// 消费者
sem_wait(&full);   // 等待有数据的缓冲区
read_from_buffer();
sem_post(&empty);  // 释放空闲缓冲区

sem_t sync_sem;
sem_init(&sync_sem, 1, 0);  // 初始值为0

// 每个线程完成初始化后调用
sem_post(&sync_sem);

// 主线程等待所有线程完成
for (int i=0; i<3; i++) {
    sem_wait(&sync_sem);
}

sem_t pool;
sem_init(&pool, 1, MAX_CONNECTIONS); // 初始为最大连接数

// 申请资源
sem_wait(&pool);  // 资源数-1
use_connection();
sem_post(&pool);  // 资源数+1

sem_t rw_mutex, read_count_mutex;
int read_count = 0;

// 读者
sem_wait(&read_count_mutex);
read_count++;
if (read_count == 1) sem_wait(&rw_mutex); // 第一个读者锁写
sem_post(&read_count_mutex);

// 读操作...

sem_wait(&read_count_mutex);
read_count--;
if (read_count == 0) sem_post(&rw_mutex); // 最后一个读者解锁写
sem_post(&read_count_mutex);

// 写者
sem_wait(&rw_mutex);
// 写操作...
sem_post(&rw_mutex);

if (sem_wait(sem) == -1) {
    perror("sem_wait failed");
    // 处理错误（如超时或信号中断）
}