操作系统及计算机组成原理 (二) - 信号量

int sem_init(sem_t *sem, int pshared, unsigned int value);

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

#define SEM_NAME "/demo_sem"

int main() {
    sem_t *sem = sem_open(SEM_NAME, O_CREAT, 0644, 0);  // 初始值为 0
    if (sem == SEM_FAILED) {
        perror("sem_open");
        return 1;
    }

    printf("Process A: Waiting for signal...\n");
    sem_wait(sem);  // 阻塞直到信号量值 > 0
    printf("Process A: Received signal!\n");

    sem_close(sem);
    sem_unlink(SEM_NAME);  // 删除信号量
    return 0;
}

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

#define SEM_NAME "/demo_sem"

int main() {
    sem_t *sem = sem_open(SEM_NAME, 0);  // 打开已存在的信号量
    if (sem == SEM_FAILED) {
        perror("sem_open");
        return 1;
    }

    printf("Process B: Sending signal...\n");
    sem_post(sem);  // 增加信号量值，唤醒进程A

    sem_close(sem);
    return 0;
}

gcc -o process_a process_a.c -lrt
gcc -o process_b process_b.c -lrt

// shared.h
#include <sys/shm.h>
#include <semaphore.h>

#define SHM_KEY 1234
#define SEM_SIZE sizeof(sem_t)

struct shared_data {
    sem_t sem;
    int counter;
};

#include "shared.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>

int main() {
    // 创建共享内存
    int shmid = shmget(SHM_KEY, sizeof(struct shared_data), IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }

    // 附加共享内存进程地址空间
    struct shared_data *shm = shmat(shmid, NULL, 0);
    if (shm == (void *)-1) {
        perror("shmat");
        exit(1);
    }

    // 初始化匿名信号量（跨进程共享需设置 pshared = 1）
    if (sem_init(&shm->sem, 1, 0) == -1) {
        perror("sem_init");
        exit(1);
    }

    printf("Process A: Waiting for signal...\n");
    sem_wait(&shm->sem);  // 阻塞等待
    printf("Process A: Counter = %d\n", shm->counter);

    // 清理
    sem_destroy(&shm->sem);
    shmdt(shm);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

#include "shared.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>

int main() {
    // 获取共享内存
    int shmid = shmget(SHM_KEY, sizeof(struct shared_data), 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }

    // 附加共享内存
    struct shared_data *shm = shmat(shmid, NULL, 0);
    if (shm == (void *)-1) {
        perror("shmat");
        exit(1);
    }

    // 修改数据并发送信号
    shm->counter = 42;
    sem_post(&shm->sem);  // 唤醒进程 A

    shmdt(shm);
    return 0;
}

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

#define BUFFER_SIZE 5
#define MAX_ITEMS 10

int buffer[BUFFER_SIZE];       // 共享缓冲区
int in = 0, out = 0;           // 缓冲区索引

sem_t mutex, empty, full;      // 信号量

void *producer(void *arg) {
    int item;
    for (int i = 0; i < MAX_ITEMS; i++) {
        item = rand() % 100;   // 模拟生产数据

        sem_wait(&empty);      // 等待空位（P(empty)）
        sem_wait(&mutex);      // 进入临界区（P(mutex)）

        buffer[in] = item;
        printf("生产者生产: %d 于位置 %d\n", item, in);
        in = (in + 1) % BUFFER_SIZE;

        sem_post(&mutex);      // 离开临界区（V(mutex)）
        sem_post(&full);       // 增加满位（V(full)）
    }
    return NULL;
}

void *consumer(void *arg) {
    int item;
    for (int i = 0; i < MAX_ITEMS; i++) {
        sem_wait(&full);       // 等待数据（P(full)）
        sem_wait(&mutex);      // 进入临界区（P(mutex)）

        item = buffer[out];
        printf("消费者消费: %d 自位置 %d\n", item, out);
        out = (out + 1) % BUFFER_SIZE;

        sem_post(&mutex);      // 离开临界区（V(mutex)）
        sem_post(&empty);      // 增加空位（V(empty)）
    }
    return NULL;
}

int main() {
    pthread_t prod_thread, cons_thread;

    // 初始化信号量
    sem_init(&mutex, 0, 1);    // 互斥信号量初始为1（二进制锁）
    sem_init(&empty, 0, BUFFER_SIZE);  // 空位初始为缓冲区大小
    sem_init(&full, 0, 0);     // 满位初始为0

    // 创建线程
    pthread_create(&prod_thread, NULL, producer, NULL);
    pthread_create(&cons_thread, NULL, consumer, NULL);

    // 等待线程结束
    pthread_join(prod_thread, NULL);
    pthread_join(cons_thread, NULL);

    // 销毁信号量
    sem_destroy(&mutex);
    sem_destroy(&empty);
    sem_destroy(&full);

    return 0;
}

生产者生产: 83 于位置 0
生产者生产: 86 于位置 1
消费者消费: 83 自位置 0
消费者消费: 86 自位置 1
生产者生产: 77 于位置 2
生产者生产: 15 于位置 3
...
（交替执行，直到生产消费各完成10次）

// 创建 3 个生产者和 2 个消费者
pthread_t prod_threads[3], cons_threads[2];
for (int i = 0; i < 3; i++) {
    pthread_create(&prod_threads[i], NULL, producer, NULL);
}
for (int i = 0; i < 2; i++) {
    pthread_create(&cons_threads[i], NULL, consumer, NULL);
}

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        // 创建一个信号量，初始许可数量为 2，表示最多允许 2 个线程同时访问资源
        Semaphore semaphore = new Semaphore(2);

        // 创建 5 个线程
        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            new Thread(() -> {
                try {
                    // 获取许可
                    semaphore.acquire();
                    System.out.println("线程 " + threadId + " 已获取许可，开始执行任务");
                    // 模拟任务执行
                    Thread.sleep(2000);
                    System.out.println("线程 " + threadId + " 完成任务，释放许可");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放许可
                    semaphore.release();
                }
            }).start();
        }
    }
}