【C++ 20 信号量 】C++ 线程同步新特性 C++ 20 std::counting_semaphore 信号量的用法 控制对共享资源的并发访问

简介: 【C++ 20 信号量 】C++ 线程同步新特性 C++ 20 std::counting_semaphore 信号量的用法 控制对共享资源的并发访问

简介

信号量(Semaphore)是一种轻量级的同步原语,用于限制对共享资源的并发访问。与条件变量相比,在某些情况下,使用信号量可以更高效。

在C++标准库的头文件中,定义了以下两种类型的信号量:

counting_semaphore:这是一个模型非负资源计数的信号量类型。它是一个类模板,可以用于实现具有不同计数值的信号量。

binary_semaphore:这是一个只有两个状态的信号量类型。它是一个类型重载,通常用于实现具有互斥访问共享资源的信号量。

这些信号量类型提供了用于等待、释放和获取资源的方法,具体取决于信号量的类型和操作。使用信号量可以有效地控制并发访问,以避免竞争条件和资源泄漏。


counting_semaphore

std::counting_semaphore是C++20标准库中的一个类模板,它实现了一个计数信号量。信号量是一种同步原语,用于控制对共享资源的并发访问,或者在多个线程之间进行同步。

std::counting_semaphore的主要方法包括:

  • acquire(): 如果信号量的内部计数大于0,那么这个方法会减少计数并立即返回。否则,这个方法会阻塞,直到其他线程调用release()方法增加了计数。
  • try_acquire(): 这个方法尝试减少信号量的计数。如果计数大于0,那么这个方法会减少计数并返回true。否则,这个方法不会阻塞,而是立即返回false
  • release(n = 1): 这个方法增加信号量的计数。参数n指定了要增加的数量,默认为1。如果有其他线程在等待信号量(即它们调用了acquire()方法并被阻塞),那么这个方法会唤醒那些线程。

这是一个简单的使用std::counting_semaphore的例子:

#include <iostream>
#include <thread>
#include <semaphore>
std::counting_semaphore<1> sema(0);  // 创建一个初始值为0的信号量
void worker() {
    sema.acquire();  // 等待信号量
    std::cout << "Hello from worker!\n";
}
int main() {
    std::thread t(worker);  // 创建一个新线程
    std::cout << "Hello from main!\n";
    sema.release();  // 增加信号量,唤醒worker线程
    t.join();  // 等待worker线程结束
    return 0;
}

在这个例子中,worker线程在开始执行前会等待信号量。main线程在输出一条消息后会增加信号量,从而唤醒worker线程。因此,这个程序总是先输出"Hello from main!“,然后输出"Hello from worker!”。

以下是一个使用std::counting_semaphore的另一个示例代码

#include <thread>
#include <semaphore>
#include <iostream>
class MyClass {
public:
    MyClass() : sem(0) {}  // 初始化信号量为0
    void sleepThread() {
        std::cout << "Sleep thread waiting...\n";
        sem.acquire();  // 如果信号量为0,这将阻塞线程
        std::cout << "Sleep thread woke up!\n";
    }
    void playThread() {
        std::cout << "Play thread releasing semaphore...\n";
        sem.release();  // 增加信号量的值,如果有线程在等待,它将被唤醒
    }
private:
    std::counting_semaphore<1> sem;  // 信号量
};
int main() {
    MyClass myClass;
    std::thread t1(&MyClass::sleepThread, &myClass);
    std::thread t2(&MyClass::playThread, &myClass);
    t1.join();
    t2.join();
    return 0;
}

在这个代码中,我们在MyClass中声明了一个std::counting_semaphore<1>成员sem,并在构造函数中将其初始化为0。然后我们在sleepThread方法中调用sem.acquire(),这将阻塞线程直到信号量的值大于0。在playThread方法中,我们调用sem.release()来增加信号量的值,这将唤醒任何正在等待的线程。

main函数中,我们创建了一个MyClass实例,并在两个不同的线程中分别调用sleepThreadplayThread方法。

std::counting_semaphore<1>中的1是模板参数,它表示信号量的最大值。这个参数决定了信号量可以同时允许多少个线程访问共享资源。

在这个例子中,我们使用1作为模板参数,创建了一个二元信号量(binary semaphore)。二元信号量的值只能为0或1,因此它只能允许一个线程访问共享资源。这对于互斥(mutex)操作非常有用,例如当你需要保护对共享资源的访问时。

如果你需要允许多个线程同时访问共享资源,你可以使用一个大于1的值作为模板参数。例如,std::counting_semaphore<3>会创建一个可以同时允许三个线程访问共享资源的信号量。

信号量的值

在计算机科学中,信号量(semaphore)是一种用于控制多线程访问共享资源的同步机制。信号量有一个与之关联的计数值,这个计数值表示可以同时访问某个资源的线程数量。

信号量的计数值并不一定只能是0和1。实际上,信号量的计数值可以是任何非负整数。当一个线程尝试获取信号量时,如果信号量的计数值大于0,那么线程可以继续执行,并且信号量的计数值会减1。如果信号量的计数值为0,那么线程会被阻塞,直到信号量的计数值大于0。

当我们说std::counting_semaphore<1>是一个二元信号量,我们是指它的计数值只能是0或1。这意味着它只能允许一个线程访问共享资源。这种类型的信号量通常用于互斥(mutex)操作,即保护对共享资源的访问。

然而,如果我们创建一个std::counting_semaphore<3>,那么它的计数值可以是0,1,2或3。这意味着它可以允许最多三个线程同时访问共享资源。这种类型的信号量可以用于更复杂的同步场景,例如当你需要允许多个线程同时读取某个资源,但只允许一个线程写入该资源时。

所以,信号量的模板参数和初始值决定了可以同时访问共享资源的线程数量。

上限和下限的处理

为零时阻塞,

std::counting_semaphore 中,acquire 方法会尝试减少信号量的值。如果信号量的值大于0,那么 acquire 将成功,并且信号量的值将减1。如果信号量的值为0,那么 acquire 将阻塞,直到信号量的值大于0。

当你调用 semaphore.acquire() 并且信号量的值为0时,线程将会阻塞。如果在此期间,另一个线程调用了 semaphore.release(),那么信号量的值将增加1,原先阻塞的 acquire 操作将继续执行,信号量的值将再次减1,变为0,然后 acquire 操作完成。

所以,当 acquire 操作完成时,信号量的值将是0(假设没有其他线程在此期间改变信号量的值)。如果此时再次调用 acquire,线程将再次阻塞,直到另一个线程调用 release

这就是信号量的基本工作原理:它允许一定数量的线程同时访问某个资源,当资源被全部占用(即信号量的值为0)时,其他线程将被阻塞,直到有资源被释放。

上限值

std::counting_semaphore::release函数会增加信号量的计数。如果信号量的计数已经达到最大值,继续调用release函数会导致未定义行为(undefined behavior)。在C++中,未定义行为意味着程序的行为没有被C++标准规定,可能会导致任何结果,包括程序崩溃、产生错误的结果或者看似正常的行为。因此,你应该避免在信号量已经达到最大值时再次调用release函数。

这是因为std::counting_semaphore的设计目标是用来同步线程,而不是用来做计数器。如果你需要一个可以安全溢出的计数器,你可能需要使用其他的数据结构或者算法。

其他常用的信号量

POSIX 信号量

POSIX 信号量

QSemaphore

Qt框架提供了一个名为QSemaphore的类,它实现了信号量的功能。QSemaphore的使用方式与std::counting_semaphore非常相似,但是它提供了一些额外的功能,例如可以尝试获取信号量而不阻塞线程,或者在一段时间内等待信号量。

以下是一个QSemaphore的基本使用示例:

#include <QSemaphore>
#include <QThread>
#include <QDebug>
class MyThread : public QThread
{
public:
    MyThread(QSemaphore *semaphore) : sem(semaphore) {}
    void run() override {
        sem->acquire();
        qDebug() << "Thread woke up!";
    }
private:
    QSemaphore *sem;
};
int main() {
    QSemaphore semaphore(0);
    MyThread thread(&semaphore);
    thread.start();
    qDebug() << "Releasing semaphore...";
    semaphore.release();
    thread.wait();
    return 0;
}

在这个示例中,我们创建了一个初始值为0的QSemaphore,然后在一个新线程中调用acquire方法。主线程稍后调用release方法,唤醒新线程。

QSemaphorestd::counting_semaphore的主要区别在于它们的接口和功能。QSemaphore提供了tryAcquire方法,它尝试获取信号量,如果信号量的计数值为0,它将立即返回而不是阻塞线程。此外,QSemaphore还提供了一个可以在一段时间内等待信号量的tryAcquire重载。

另一个区别是QSemaphore没有模板参数,它的计数值可以是任何非负整数,而不仅仅是0和1。这意味着你可以创建一个可以同时允许多个线程访问共享资源的信号量。

最后,QSemaphore是Qt框架的一部分,因此它可以与Qt的其他类和功能(例如信号和槽)一起使用。而std::counting_semaphore是C++标准库的一部分,它与C++的其他特性(例如线程和锁)更好地集成。


多种信号量的对比

以下是一个比较QSemaphorestd::counting_semaphore,POSIX信号量和System V信号量的表格:

QSemaphore std::counting_semaphore POSIX Semaphore System V Semaphore
接口 提供了高级的、面向对象的接口,如acquire()release()方法 提供了类似的接口,但是作为C++标准库的一部分 提供了较低级别的、C风格的接口,如sem_wait()sem_post()函数 提供了C风格的接口,但是使用了不同的函数,如semop()
上限值 可以是任何非负整数 可以是任何非负整数 可以是任何非负整数 可以是任何非负整数
行为 如果信号量的值为0,则阻塞调用线程;如果值增加,则解除一个或多个线程的阻塞 如果信号量的值为0,则阻塞调用线程;如果值增加,则解除一个或多个线程的阻塞 如果信号量的值为0,则阻塞调用线程;如果值增加,则解除一个或多个线程的阻塞 如果信号量的值为0,则阻塞调用线程;如果值增加,则解除一个或多个线程的阻塞
底层原理 是Qt框架的一部分,使用Qt的线程和同步原语 是C++标准库的一部分,使用C++运行时提供的线程和同步原语 是Unix API的一部分,使用内核的线程和同步原语 是Unix API的一部分,使用内核的线程和同步原语
限制 受C++运行时和Qt框架的能力限制 受C++运行时的能力限制 受Unix内核的能力限制,并且可能在非Unix系统上不可用 受Unix内核的能力限制,并且可能在非Unix系统上不可用
以下是对QSemaphorestd::counting_semaphore,POSIX信号量和System V信号量的额外比较:
  1. 平台兼容性std::counting_semaphore是C++标准库的一部分,因此在任何支持C++的平台上都可以使用。QSemaphore是Qt框架的一部分,因此需要Qt库的支持。POSIX信号量和System V信号量是Unix API的一部分,因此在Unix和Unix-like系统(如Linux和macOS)上可用,但在Windows等非Unix系统上可能不可用。
  2. 错误处理std::counting_semaphoreQSemaphore都使用C++的异常处理机制来报告错误。POSIX信号量和System V信号量则使用返回值和errno变量来报告错误。
  3. 超时支持QSemaphore提供了一个可以在一段时间内等待信号量的tryAcquire重载。POSIX信号量也提供了一个可以在一段时间内等待信号量的函数sem_timedwaitstd::counting_semaphore和System V信号量没有内置的超时支持。
  4. 资源管理std::counting_semaphoreQSemaphore都是类,因此可以利用C++的构造函数和析构函数进行资源管理。POSIX信号量和System V信号量是通过函数调用进行管理的,需要手动创建和销毁。
  5. 集成QSemaphore可以与Qt的其他类和功能(例如信号和槽)一起使用。std::counting_semaphore可以与C++的其他特性(例如线程和锁)更好地集成。POSIX信号量和System V信号量可以与Unix API的其他部分一起使用。
  6. 命名信号量:POSIX信号量和System V信号量支持命名信号量,这允许不相关的进程共享信号量。std::counting_semaphoreQSemaphore不支持命名信号量。

结语

在我们的编程学习之旅中,理解是我们迈向更高层次的重要一步。然而,掌握新技能、新理念,始终需要时间和坚持。从心理学的角度看,学习往往伴随着不断的试错和调整,这就像是我们的大脑在逐渐优化其解决问题的“算法”。

这就是为什么当我们遇到错误,我们应该将其视为学习和进步的机会,而不仅仅是困扰。通过理解和解决这些问题,我们不仅可以修复当前的代码,更可以提升我们的编程能力,防止在未来的项目中犯相同的错误。

我鼓励大家积极参与进来,不断提升自己的编程技术。无论你是初学者还是有经验的开发者,我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用,不妨点击收藏,或者留下你的评论分享你的见解和经验,也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持,也是对我持续分享和创作的动力。

目录
相关文章
|
1天前
|
C++
C++程序中的派生类成员访问属性
C++程序中的派生类成员访问属性
9 1
|
6天前
|
Linux Shell 开发工具
C++ 的 ini 配置文件读写/注释库 inicpp 用法 [ header-file-only ]
这是一个C++库,名为inicpp,用于读写带有注释的INI配置文件,仅包含一个hpp头文件,无需编译,支持C++11及以上版本。该库提供简单的接口,使得操作INI文件变得容易。用户可通过`git clone`从GitHub或Gitee获取库,并通过包含`inicpp.hpp`来使用`inicpp::iniReader`类。示例代码展示了读取、写入配置项以及添加注释的功能,还提供了转换为字符串、双精度和整型的函数。项目遵循MIT许可证,示例代码可在Linux环境下编译运行。
37 0
|
6天前
|
机器学习/深度学习 JSON 编译器
C++ 资源大全:标准库、Web框架、人工智能等 | 最全整理
C++ 资源列表,内容包括: 标准库、Web应用框架、人工智能、数据库、图片处理、机器学习、日志、代码分析等
52 1
|
6天前
|
自然语言处理 编译器 C语言
【C++】C++ 入门 — 命名空间,输入输出,函数新特性
本文章是我对C++学习的开始,很荣幸与大家一同进步。 首先我先介绍一下C++,C++是上个世纪为了解决软件危机所创立 的一项面向对象的编程语言(OOP思想)。
36 1
【C++】C++ 入门 — 命名空间,输入输出,函数新特性
|
6天前
|
存储 编译器 C语言
【C++】类与对象【定义、访问限定符、this指针】
【C++】类与对象【定义、访问限定符、this指针】
6 1
|
6天前
|
安全 程序员 C++
C++ new和delete的用法
需要注意的是,使用 `new`和 `delete`分配和释放内存时,程序员负责管理内存的分配和释放,这可能导致内存泄漏或释放已释放内存的问题。因此,C++引入了智能指针(如 `std::shared_ptr`和 `std::unique_ptr`)以更安全和自动化地管理内存。
36 2
|
6天前
|
编译器 C++
【C++】【C++的常变量取地址问题(对比C的不同)】const修饰的常变量&volatile修饰用法详解(代码演示)
【C++】【C++的常变量取地址问题(对比C的不同)】const修饰的常变量&volatile修饰用法详解(代码演示)
|
6天前
|
存储 程序员 C语言
深入理解C++:从语言特性到实践应用
深入理解C++:从语言特性到实践应用
25 3
|
6天前
|
Java
【专栏】Java多线程中,锁用于控制共享资源访问,确保数据一致性和正确性,锁是什么意思,有哪些分类?
【4月更文挑战第28天】Java多线程中,锁用于控制共享资源访问,确保数据一致性和正确性。本文探讨锁的概念、作用及分类:乐观锁与悲观锁、自旋锁与适应性自旋锁、公平锁与非公平锁、可重入锁和读写锁。使用锁需注意避免死锁、合理选择锁粒度及性能优化。理解锁有助于提升多线程编程的效率和稳定性。
|
19小时前
|
存储 编译器 C语言
从C语言到C++_11(string类的常用函数)力扣58和415(中)
从C语言到C++_11(string类的常用函数)力扣58和415
5 0