操作系统

// 两线程互斥算法
int flag[2] = {0, 0};
int turn = 0;

void lock(int self) {
    flag[self] = 1;
    turn = 1 - self;
    while (flag[1-self] && turn == 1-self);
}

void unlock(int self) {
    flag[self] = 0;
}

// 使用CAS实现自旋锁
typedef struct {
    int locked;
} spinlock_t;

void spin_lock(spinlock_t *lock) {
    while (__sync_lock_test_and_set(&lock->locked, 1));
}

void spin_unlock(spinlock_t *lock) {
    __sync_lock_release(&lock->locked);
}

// 条件变量使用范式
pthread_mutex_t lock;
pthread_cond_t cond;

// 等待方
pthread_mutex_lock(&lock);
while (!condition) {
    pthread_cond_wait(&cond, &lock);
}

// 执行操作

pthread_mutex_unlock(&lock);



// 通知方
pthread_mutex_lock(&lock);
condition = true;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&lock);

#include <stdio.h>
#include <pthread.h>
#include <stdbool.h>
#include <unistd.h>

#define BUFFER_SIZE 5

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_not_empty = PTHREAD_COND_INITIALIZER;  // 缓冲区非空条件
pthread_cond_t cond_not_full = PTHREAD_COND_INITIALIZER;   // 缓冲区未满条件

int buffer[BUFFER_SIZE];
int count = 0;  // 当前缓冲区中的数据量

void* consumer(void* arg) {
    while (1) {
        pthread_mutex_lock(&lock);
        ​    // 只有缓冲区非空时才能消费
            ​    while (count == 0) {
                ​        printf("Consumer: 缓冲区空，等待...\n");
                ​        pthread_cond_wait(&cond_not_empty, &lock);
                ​    }
        ​    
            ​    // 消费数据
            ​    int item = buffer[--count];
        ​    printf("Consumer: 消费数据 %d (缓冲区剩余: %d)\n", item, count);
        ​    
            ​    // 通知生产者缓冲区未满
            ​    pthread_cond_signal(&cond_not_full);
        ​    pthread_mutex_unlock(&lock);
        ​    
            ​    sleep(1);  // 模拟消费耗时
    }
    return NULL;

}

void* producer(void* arg) {
    int item = 0;
    while (1) {
        pthread_mutex_lock(&lock);
        ​    // 只有缓冲区未满时才能生产
            ​    while (count == BUFFER_SIZE) {
                ​        printf("Producer: 缓冲区满，等待...\n");
                ​        pthread_cond_wait(&cond_not_full, &lock);
                ​    }
        ​    
            ​    // 生产数据
            ​    buffer[count++] = item;
        ​    printf("Producer: 生产数据 %d (缓冲区总量: %d)\n", item++, count);
        ​    
            ​    // 通知消费者缓冲区非空
            ​    pthread_cond_signal(&cond_not_empty);
        ​    pthread_mutex_unlock(&lock);
        ​    
            ​    sleep(1);  // 模拟生产耗时
    }
    return NULL;

}

int main() {
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, consumer, NULL);
    pthread_create(&tid2, NULL, producer, NULL);


    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;

}

//管道实现父子进程通信
int main() {
    int pipefd[2];
    pid_t pid;
    char buf;

// 创建管道
if (pipe(pipefd) == -1) {
    perror("pipe");
    exit(EXIT_FAILURE);
}

pid = fork();
if (pid == -1) {
    perror("fork");
    exit(EXIT_FAILURE);
}

if (pid == 0) {
    // 子进程
    close(pipefd[1]); // 关闭写端
    read(pipefd[0], &buf, 1);
    printf("子进程读取到: %c\n", buf);
    close(pipefd[0]); // 关闭读端
    exit(EXIT_SUCCESS);
} else {
    // 父进程
    close(pipefd[0]); // 关闭读端
    write(pipefd[1], "A", 1);
    printf("父进程写入: A\n");
    close(pipefd[1]); // 关闭写端
    wait(NULL); // 等待子进程结束
}

return 0;

}

#define BUFFER_SIZE 10

sem_t empty;    // 空槽位
sem_t full;     // 已填充
sem_t mutex;    // 互斥锁

void producer() {
    while (1) {
        item = produce_item();
        sem_wait(&empty);
        sem_wait(&mutex);
        insert_item(item);
        sem_post(&mutex);
        sem_post(&full);
    }
}

void consumer() {
    while (1) {
        sem_wait(&full);
        sem_wait(&mutex);
        item = remove_item();
        sem_post(&mutex);
        sem_post(&empty);
        consume_item(item);
    }
}

sem_t mutex; //⽤于互斥的信号量（也可以⽤互斥锁）
sem_init(sem_t &mutex, 0, 1);
sem_t empty; //缓冲区有多少空
sem_init(sem_t &empty, 0, MAX); 
sem_t full; //缓冲区有多少资源
sem_init(sem_t &full, 0, 0);

void produce() { 
 	while(1) { 
 		P(&mutex); 
 		P(&empty); 
 		produce_shared_buffer();
 		V(&full); 
 		V(&mutex);
 	}
}
void consume() { 
 	while(1) { 
 		P(&mutex);
        P(&full); 
 		consume_shared_buffer();
		V(&mutex); 
 		V(&empty); 
 	} 
}
//这里P代表检验，也写作decrease/down/wait/acquire，如果sem的值不是正数就阻塞自己，否则将sem的值减⼀后返回运⾏
//V代表⾃增， 也写作increase/up/post/signal/release，将信号量sem的值加1，如果有⼀个或多个线程阻塞在这个信号量上，选择⼀个唤醒

pthread_mutex_t lock;
pthread_cond_t cond;
int count = 0;
#define MAX 10

void producer() {
    while (1) {
        pthread_mutex_lock(&lock);
        while (count == MAX) {
            pthread_cond_wait(&cond, &lock);
        }
        insert_item();
        count++;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&lock);
    }
}

void consumer() {
    while (1) {
        pthread_mutex_lock(&lock);
        while (count == 0) {
            pthread_cond_wait(&cond, &lock);
        }
        remove_item();
        count--;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&lock);
    }
}