《Linux系统编程篇》POSIX信号量（Linux 进程间通信（IPC））——基础篇

引言

知道了什么是管道，什么是消息队列之后，我们来看一下什么是信号量。

在写这篇文章的时候，提到了线程，但我又没有系统性的讲解过线程，关于线程，我打算讲解完进程之后给大家补一下这方面的知识点。

线程的概念和进程的概念是不一样的，但使用上却极其的相似，包括他们所占用的内存空间等等，笔者在后面介绍线程时候给大家拆解。

在这里线程扫盲的话，可以先看一下老版本笔者写的文章，当遇到看不懂的API时候，可以参考一下。⭐️"传送门"⭐️

我总能找到回家的路

——家驹(StrangeHead)

Linux 信号量是什么(快速扫盲)

在 Linux 系统编程中，信号量（Semaphore）是一种重要的同步机制，主要用于解决并发访问的互斥和同步问题。

在多线程、多进程的编程环境中，信号量能够控制对共享资源的访问，确保操作的安全性。

大家可能对这句话不是很敏感，现在笔者在项目中，可是吃了不少这样的并发问题，两个线程或者进程，甚至多个，如果在某一个瞬间，同时操作了一个变量，那么悲催的事情就要来了。你的程序会直接死机！！
提示什么Double free 或者奇怪的一些问题。。。

所以要么用线程锁保护起来，要么用信号量严格把控你的线程或者进程的逻辑。

本文将详细介绍信号量的基本概念、常见类型、以及在 Linux 环境下如何使用信号量进行编程。以及使用POSIX信号量的使用的实例代码。帮助学员们理解这个东东。

Linux 提供了两种信号量实现

信号量有两种实现，一个是System V信号量，另一个是POSIX信号量。本节围绕POSIX信号量作为实例讲解，下节我们将使用并学习System V信号量.

System V 信号量

较为传统，使用较多，但控制复杂。

POSIX 信号量

较新且更为简单，推荐在多线程编程中使用。

这里仅仅让学员们知道，Linux系统当中是有俩套API的，千万别学混咯，这篇文章的代码实例主要是基于POSIX信号量开始，他比较简单，可以快速上手，帮助学员们理解信号量。

System V 信号量 和 POSIX 信号量 都可以用于进程间同步；然而，POSIX 信号量 由于设计上的优势，也可以直接用于线程间同步。以下是两者的详细比较与用途解析：

System V 信号量与 POSIX 信号量的主要区别

System V 信号量：进程间同步的经典方案

System V 信号量诞生于早期 UNIX 系统，设计初衷是为 进程间同步 提供服务。其信号量集合的概念，使其非常适合复杂的进程间通信场景。

• 信号量集合：一次可以管理多个信号量（多个共享资源）。
• 跨进程共享：通过唯一的键值 (key_t) 实现多个进程间共享同一信号量。

尽管 System V 信号量也可以用于线程同步，但由于操作复杂且性能较低，在现代编程中并不常用于线程间同步。

POSIX 信号量：线程间和进程间同步的现代选择

POSIX 信号量更轻量化，API 简洁，能够同时满足线程和进程同步需求：

1. 线程间同步：

   • sem_init 创建未命名信号量，适合线程同步。
   • 信号量存在于进程的地址空间中，线程可以直接访问。

2. 进程间同步：

   • 通过 sem_open 创建命名信号量，并将其映射到系统范围内的命名空间。
   • 多个进程可以通过相同的名称共享该信号量。

POSIX 信号量因其灵活性和高效性，通常在多线程编程中被优先选择。

使用场景总结

• System V 信号量：
  适用于复杂的进程间同步，尤其是需要使用信号量集合来管理多资源的场景。示例：

  • 数据库进程池管理。
  • IPC 缓冲区管理。

• POSIX 信号量：
  更通用，适合线程同步或简单的进程间同步。示例：

  • 多线程间的资源互斥。
  • 生产者-消费者模型的线程或进程实现。

推荐使用场景

1. 如果仅涉及线程同步：
   首选 POSIX 信号量。它与线程的内存模型更匹配，操作简单，性能优越。

2. 如果涉及复杂的进程间通信（多个资源共享）：
   使用 System V 信号量，其集合特性能够更好地处理复杂的同步需求。

3. 如果是跨平台开发：
   POSIX 信号量通常是更现代和标准的选择，具备更好的可移植性。

信号量的种类

信号量是一种特殊的计数器，用于控制多线程或多进程对共享资源的访问。最早由计算机科学家 Edsger Dijkstra 引入，信号量有两种类型：

• 计数信号量（Counting Semaphore）：用于表示可以并发访问资源的数量。
• 二值信号量（Binary Semaphore）：只取值 0 或 1，常用于互斥量（Mutex）的实现。

计数信号量（Counting Semaphore）

计数信号量（Counting Semaphore）是信号量的一种类型，用于控制多个线程或进程对共享资源的并发访问。它是一个具有整数值的变量，通过两种操作（通常称为 P 和 V 或 wait 和 signal）对其进行修改。计数信号量的值可以是非负整数，表示可用资源的数量。

计数信号量的特点

1. 整数值表示资源数量：

   • 初始值通常设定为可用资源的总数。
   • 值为正数时，表示有多少个资源可以被访问。
   • 值为 0 时，表示没有可用资源，进程或线程需要等待。
   • 值不能为负数。

2. 同步控制：

   • 减少信号量（P 操作或 wait）：表示一个进程/线程请求使用资源。
     • 如果信号量值 > 0，则资源可用，减少信号量值。
     • 如果信号量值 = 0，则阻塞进程/线程直到资源可用。
   • 增加信号量（V 操作或 signal）：表示一个进程/线程释放资源。
     • 信号量值增加，可能唤醒等待的进程/线程。

3. 适用于多资源共享：

   • 计数信号量允许多个线程同时访问有限的资源，例如线程池、数据库连接池等。

计数信号量的工作原理

假设一个资源池中有 5 个资源，计数信号量的初始值设为 5。多个线程需要访问这些资源：

1. 初始信号量值为 5，表示有 5 个资源可用。
2. 第一个线程请求资源：
   • 执行 P 操作，信号量值减为 4。
   • 线程获得资源。
3. 第二个线程请求资源：
   • 执行 P 操作，信号量值减为 3。
   • 线程获得资源。
4. 一个线程释放资源：
   • 执行 V 操作，信号量值加为 4。
   • 表示有一个资源可用。
5. 如果所有资源都被占用，信号量值变为 0。
   • 请求资源的线程将被阻塞，直到有资源被释放。

计数信号量的实现

使用 POSIX 信号量实现：

以下代码展示了如何使用计数信号量控制对有限资源的访问：

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

#define NUM_RESOURCES 3  // 资源数量
#define NUM_THREADS 5    // 线程数量

sem_t semaphore; // 定义计数信号量

void* thread_func(void* arg) {
    int id = (int)(long)arg;

    printf("Thread %d: Waiting for resource...\n", id);
    sem_wait(&semaphore); // P 操作，减少信号量

    printf("Thread %d: Acquired resource!\n", id);
    sleep(2); // 模拟资源使用

    printf("Thread %d: Releasing resource...\n", id);
    sem_post(&semaphore); // V 操作，增加信号量

    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];

    // 初始化信号量，初始值为 NUM_RESOURCES
    sem_init(&semaphore, 0, NUM_RESOURCES);

    // 创建线程
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, thread_func, (void*)(long)i);
    }

    // 等待线程完成
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    // 销毁信号量
    sem_destroy(&semaphore);

    return 0;
}

运行结果（输出示例）：

Thread 0: Waiting for resource...
Thread 0: Acquired resource!
Thread 1: Waiting for resource...
Thread 1: Acquired resource!
Thread 2: Waiting for resource...
Thread 2: Acquired resource!
Thread 3: Waiting for resource...
Thread 0: Releasing resource...
Thread 3: Acquired resource!
Thread 4: Waiting for resource...
Thread 1: Releasing resource...
Thread 4: Acquired resource!
Thread 2: Releasing resource...
Thread 3: Releasing resource...
Thread 4: Releasing resource...

计数信号量的应用场景

1. 线程池：
   • 控制同时运行的线程数量。
2. 数据库连接池：
   • 限制同时访问数据库的连接数。
3. 资源分配：
   • 管理有限资源的访问，例如磁盘块、内存缓冲区。
4. 网络服务器：
   • 控制同时连接的客户端数量。

与二值信号量的对比

总结

计数信号量是强大的同步工具，适用于控制对有限资源的并发访问。通过学习其概念、API 和编程实践，可以灵活地应用于多线程编程和进程间通信中。

通俗易懂的来讲，信号量就是为了保护某一个东西，相当于给某个物品上锁，锁是公共的，每个人都可以看到，那么既然有锁一定有钥匙去开这把锁，然后拿到里面的东西，去使用。

所谓的P操作就是用钥匙开这把锁（开完锁之后钥匙自动销毁），V操作就是制造一把钥匙给下一个开锁的人（钥匙加一）。

二值信号量（Binary Semaphore）

二值信号量（Binary Semaphore）是一种特殊类型的信号量，其值仅能是 0 或 1。二值信号量通常用于解决互斥（Mutex）问题，即确保同一时间只有一个线程或进程访问某个关键资源或执行临界区代码。

二值信号量的特点

1. 值范围：

   • 只有两种状态：0（不可用）和 1（可用）。
   • 初始值通常设为 1，表示资源可用。

2. P（wait）操作：

   • 当信号量值为 1 时，P 操作将其值减为 0，表示资源被占用。
   • 如果信号量值为 0，执行 P 操作的线程或进程会阻塞，直到信号量值恢复为 1。

3. V（signal）操作：

   • 将信号量值从 0 置为 1，表示资源被释放，可以被其他线程或进程使用。

4. 应用场景：

   • 用于实现互斥（类似于 Mutex）。
   • 用于简单的线程同步。

二值信号量的工作原理

假设一个线程需要访问一个临界资源：

1. 信号量初始值为 1，表示资源可用。
2. 线程 A 执行 P 操作：
   • 检查信号量值是否为 1。
   • 如果是，减为 0 并进入临界区。
   • 如果信号量值为 0，线程 A 被阻塞。
3. 线程 A 释放资源：
   • 执行 V 操作，将信号量值恢复为 1。
   • 如果有其他线程在等待，则唤醒它们。

二值信号量的实现

POSIX 信号量实现

以下是一个使用 POSIX 信号量实现二值信号量的示例：

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

sem_t binary_semaphore; // 定义二值信号量

void* thread_func(void* arg) {
    int id = (int)(long)arg;

    printf("Thread %d: Waiting to enter critical section...\n", id);
    sem_wait(&binary_semaphore); // P 操作，尝试进入临界区

    printf("Thread %d: Entered critical section.\n", id);
    sleep(2); // 模拟临界区操作

    printf("Thread %d: Exiting critical section.\n", id);
    sem_post(&binary_semaphore); // V 操作，释放临界区

    return NULL;
}

int main() {
    pthread_t t1, t2;

    // 初始化二值信号量，初始值为 1
    sem_init(&binary_semaphore, 0, 1);

    // 创建两个线程
    pthread_create(&t1, NULL, thread_func, (void*)1);
    pthread_create(&t2, NULL, thread_func, (void*)2);

    // 等待两个线程完成
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    // 销毁信号量
    sem_destroy(&binary_semaphore);

    return 0;
}

运行结果（输出示例）：

Thread 1: Waiting to enter critical section...
Thread 1: Entered critical section.
Thread 2: Waiting to enter critical section...
Thread 1: Exiting critical section.
Thread 2: Entered critical section.
Thread 2: Exiting critical section.

二值信号量 vs 互斥锁

二值信号量的应用场景

1. 线程同步：
   • 控制线程的执行顺序，例如一个线程需要等待另一个线程完成后再执行。
2. 临界区保护：
   • 确保同一时间只有一个线程可以访问共享资源。
3. 简单的生产者-消费者模型：
   • 限制生产者和消费者对共享缓冲区的访问。

二值信号量示例：线程同步

以下示例展示如何使用二值信号量实现线程间的同步：

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

sem_t sync_semaphore; // 定义二值信号量

void* thread_func1(void* arg) {
    printf("Thread 1: Performing task...\n");
    sleep(2); // 模拟任务
    printf("Thread 1: Task complete, signaling thread 2.\n");
    sem_post(&sync_semaphore); // V 操作，通知线程 2
    return NULL;
}

void* thread_func2(void* arg) {
    printf("Thread 2: Waiting for thread 1 to complete...\n");
    sem_wait(&sync_semaphore); // P 操作，等待线程 1
    printf("Thread 2: Received signal from thread 1, continuing task.\n");
    return NULL;
}

int main() {
    pthread_t t1, t2;

    // 初始化二值信号量，初始值为 0
    sem_init(&sync_semaphore, 0, 0);

    // 创建线程
    pthread_create(&t1, NULL, thread_func1, NULL);
    pthread_create(&t2, NULL, thread_func2, NULL);

    // 等待线程完成
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    // 销毁信号量
    sem_destroy(&sync_semaphore);

    return 0;
}

运行结果（输出示例）：

Thread 1: Performing task...
Thread 2: Waiting for thread 1 to complete...
Thread 1: Task complete, signaling thread 2.
Thread 2: Received signal from thread 1, continuing task.

总结

• 二值信号量适合用于互斥和简单的线程同步任务。
• 如果你的需求是对共享资源的访问控制，且仅允许一个线程访问，二值信号量是一个不错的选择。
• 需要更高级的互斥功能（如递归锁或超时机制）时，可以考虑使用互斥锁。

结束

持续更新，分享优质内容，加油！.