信号量机制：原语PV操作的实现｜源代码和解释

信号量机制

**目的：**实现互斥访问共享资源，实现进程同步。

一共3个操作

1. 初始化
2. P原语
3. V原语

类型：

1. 整型信号量：只包含临界资源数量。当资源不足的时候会自旋，会发生忙等，违背“让权等待”
2. 记录型信号量：包含等待队列等信息。当资源不足的时候，会进入等待队列。

单词解释： 源于荷兰语
P-V原语操作
P = plantinga = Probeer(’try’)=尝试
V= Verhoog = increment = 增加1

整型信号量

了解即可

加锁确保原子操作
wait(S)原语：P操作，上锁+检查，避免了异步并发导致的死锁的问题。
signal(S)原语：V操作 上锁+检查

伪代码实现：

// 初始化，共享资源(临界资源)的数量
int S = 1;

// P操作
void wait(int S) 
	lock();     //加锁  
	while (S <= 0); ///< 如果s<0,会自旋，忙等
	S = S + 1;
	unlock();    //解锁  
}
// V操作
void signal(int S) {
	lock();//加锁
	S = S + 1;
	unlock();//解锁
}
/**********************************/
// 进程访问访问临界资源
wait(S);	// 进入临界区
访问临界资源;  //  临界区
signal(S);  // 退出临界区

为了解决“自旋”问题，引入等待队列。

记录型信号量的原理

引用维基百科解释 Semaphore_(programming)

A simple way to understand wait § and signal (V) operations is:
wait: Decrements the value of semaphore variable by 1. If the new value of the semaphore variable is negative, the process executing wait is blocked (i.e., added to the semaphore’s queue). Otherwise, the process continues execution, having used a unit of the resource.
signal: Increments the value of semaphore variable by 1. After the increment, if the pre-increment value was negative (meaning there are processes waiting for a resource), it transfers a blocked process from the semaphore’s waiting queue to the ready queue.

这是阿里云给出的步骤，与原版一致

P (S):
① reduce the semaphore s value by 1, that is, S = S-1;
② If S> = 0, the process continues to run; otherwise, the process is set to the waiting status and is discharged into the waiting queue.
V (s):
① Add 1 to the semaphore s value, that is, S = S + 1;
② If S> 0, the process continues; otherwise, the first process in the queue is released waiting for the semaphore.

翻译过来
P原语操作：
sem减1；
若sem减1后仍大于或等于0，则P原语返回，该进程继续执行；
若sem减1后小于0，则该进程被阻塞后进入与该信号相对应的队列中，然后转进程调度。

V原语操作：
sem加1；
若相加结果大于0，V原语停止执行，该进程返回调用处，继续执行；
若相加结果小于或等于0，则从该信号的等待队列中唤醒一个等待进程，然后再返回原进程继续执行或转进程调度。

总的来说，就是先修改信号量，然后再检查。

但是：
在信号量的实现中，通常的做法是首先检查信号量的状态，然后根据这个状态来决定是否减少信号量的值。这是为了确保只有在资源确实可用的情况下，线程才会减少信号量的值并进入临界区。在资源不可用时，线程应该等待，直到资源变得可用。

然而，在通过添加互斥锁的前提下，两者的实现一致！

---

---

记录型信号量的实现

下面与原版保持一致

PV操作的c语言实现

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

/// 定义信号量，包含其他信息。
typedef struct {
	int value;   ///<  信号量的值，临界资源数量
	pthread_mutex_t mutex; ///< 互斥锁，用于原语操作
	/// 条件变量实现了等待队列
	pthread_cond_t cond; ///< 条件变量，下面有详解
} semaphore;

/// 初始化信号量
void semaphore_init(semaphore *s, int value) {
	s->value = value;
	pthread_mutex_init(&s->mutex, NULL);
	pthread_cond_init(&s->cond, NULL);
}

/// P操作wait(S)
void P(semaphore *s) {
	pthread_mutex_lock(&s->mutex); ///< 加锁
    s->value--;
    
    /// 先判断的话是<=,后判断是<
	while (s->value < 0) {
		pthread_cond_wait(&s->cond, &s->mutex);	///< 进程进入等待队列
	}

	pthread_mutex_unlock(&s->mutex); ///< 释放锁
}

/// S操作signal(S)
void V(semaphore *s) {
	pthread_mutex_lock(&s->mutex); ///< 加锁
	s->value++;
	///< 如果等待队列中存在进程，进行唤醒，让它去使用临界资源
	if (s->value <= 0){ ///< 其实可以不加判断，pthread_cond_signal函数中包含判断
		pthread_cond_signal(&s->cond);  ///< 唤醒等待列中的进程
	}
	pthread_mutex_unlock(&s->mutex);///< 释放锁
}

/// 测试函数
void *thread_function(void *arg) {
	semaphore *s = (semaphore *)arg;
	
	printf("Thread %ld: Waitling to enter critical section...\n", pthread_self());
	P(s);
	printf("Thread %ld: Entered critical section.\n", pthread_self());
    sleep(1);  // 模拟访问临界资源
    printf("Thread %ld: Exiting critical section.\n", pthread_self());
	V(s);

	return NULL;
}

int main() {
	pthread_t t1, t2;
	semaphore sem;
	sephore_init(&sem, 1);
	
	pthread_create(&t1, NULL, thread_function, &sem);
    pthread_create(&t2, NULL, thread_function, &sem);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

	return 0;
}

条件变量（cond）的作用可以通过一个现实生活中的比喻来解释，让我们以餐厅里的顾客和服务员的互动为例：

想象你在一家餐厅里等待你的食物。餐厅里有很多桌子，每个桌子上都有一个按钮，当你按下这个按钮时，就表示你的食物准备好了。在这个比喻中，每个桌子上的按钮就像一个条件变量。

1. 等待条件变量（pthread_cond_wait）：你（一个线程）到达餐厅并下了订单。然后，你等待食物准备好。在这个时候，你不会一直盯着服务员（忙等），而是会做一些其他事情，比如聊天或看手机。这个等待过程就像是线程在条件变量上的等待。你知道，直到你的食物准备好（条件发生变化），你都不需要做任何事。
2. 通知条件变量（pthread_cond_signal）：当厨师准备好你的食物后，服务员（另一个线程）会按下你桌子上的按钮。这个动作就像是在条件变量上发送信号。按下按钮后，你知道你的食物已经准备好了，你可以停止等待，开始吃饭。
3. 互斥锁（pthread_mutex_t）：为了保证订单不会混乱（避免数据竞争），每个订单都是在一种互斥的方式下处理的。这就像是每个服务员在处理一个订单时都拿着一个特定的笔（互斥锁），该订单只能由携带该笔的服务员处理，且这个笔一次只能由一个服务员使用（互斥）。当服务员处理完订单后，他们会放下笔，让其他服务员可以使用（释放锁）。

在这个比喻中，你等待的过程是非活跃的，不会占用资源（如不会一直盯着服务员）。这正是条件变量在多线程编程中的作用：允许线程在某些条件尚未满足时，以非忙等的方式等待，从而提高资源的利用效率和程序的响应性。当条件满足（比如食物准备好了），通过发送信号的方式通知等待的线程，允许它们继续执行。