当前位置：首页 > news >正文

C++ 同步原语

news 来源：原创 2025/8/3 15:15:35

同步原语（Synchronization Primitives）是操作系统和编程语言提供的基本工具，用于在多线程或并发环境中协调线程（或进程）之间的执行顺序，管理共享资源的访问，以避免数据竞争（data race）、死锁（deadlock）等问题。它们是实现线程同步和互斥的核心机制，广泛应用于多线程编程中。

同步原语是底层的同步机制，用于：

1.互斥（Mutual Exclusion）：确保同一时间只有一个线程访问共享资源。

2.同步（Synchronization）：协调线程的执行顺序，例如等待某个条件满足后再继续。

3.通信：在线程间传递信号或数据。

C++ 的同步原语:

1.互斥锁（Mutexes）

作用：保证同一时间只有一个线程可以访问共享资源，防止数据竞争。

C++ 实现：

std::mutex（C++11）：基本的互斥锁，提供独占访问。

方法：lock()：获取锁（阻塞直到锁可用）。unlock()：释放锁。try_lock()：尝试获取锁（非阻塞）。

示例：std::lock_guard 确保每次 ++counter 是原子操作，避免数据竞争，保证 counter 最终为 2000。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx;
int counter = 0;void increment() {for (int i = 0; i < 1000; ++i) {std::lock_guard<std::mutex> lock(mtx); // RAII 自动加锁/解锁++counter;}
}int main() {std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();std::cout << counter << std::endl; // 输出 2000return 0;
}

std::recursive_mutex（C++11）：允许同一线程多次锁定（递归加锁），但其他线程仍被阻塞，适合需要递归调用的场景。

方法：同 std::mutex。

示例：

std::recursive_mutex rmtx;
void recursive_func(int n) {std::lock_guard<std::recursive_mutex> lock(rmtx);if (n > 0) recursive_func(n - 1);
}

std::timed_mutex（C++11）：支持超时尝试加锁的互斥锁。避免无限阻塞。

额外方法：try_lock_for(), try_lock_until()。

示例：

std::timed_mutex tmtx;
void try_access() {if (tmtx.try_lock_for(std::chrono::milliseconds(100))) {// 访问资源tmtx.unlock();}
}

std::recursive_timed_mutex（C++11）：结合 recursive_mutex 和 timed_mutex 的特性，支持递归加锁和超时。用于递归场景中需要超时控制。

示例：类似 timed_mutex，但允许同一线程多次加锁。

std::shared_mutex（C++17）：支持读写锁，允许多个线程同时读取共享资源，但写操作独占访问，即允许多个线程共享读锁（lock_shared()），但写锁（lock()）独占。适用于读多写少的场景。

方法：lock() / unlock()：独占写锁。lock_shared() / unlock_shared()：共享读锁。try_lock(), try_lock_shared()。

示例：读写锁允许多个读者并发，但写者独占访问。

#include <shared_mutex>
#include <thread>
#include <iostream>std::shared_mutex rw_mutex;
int data = 0;void reader(int id) {std::shared_lock<std::shared_mutex> lock(rw_mutex);std::cout << "Reader " << id << " reads: " << data << std::endl;
}void writer(int id) {std::unique_lock<std::shared_mutex> lock(rw_mutex);++data;std::cout << "Writer " << id << " writes: " << data << std::endl;
}int main() {std::vector<std::thread> threads;for (int i = 0; i < 3; ++i) {threads.emplace_back(reader, i);threads.emplace_back(writer, i);}for (auto& t : threads) {t.join();}return 0;
}

std::shared_timed_mutex（C++14）：shared_mutex 的超时版本，支持超时尝试读锁或写锁。适用于读写锁需要超时控制。

额外方法：try_lock_for(), try_lock_until(), try_lock_shared_for(), try_lock_shared_until()。

示例：类似 shared_mutex，但支持超时。

2.锁管理（Lock Management）

这些是 RAII 风格的工具，用于管理互斥锁的获取和释放，确保异常安全和简化代码。

std::lock_guard（C++11）：RAII 封装，构造时加锁，析构时解锁，不支持手动解锁。适用于简单、轻量级的锁管理。

std::unique_lock（C++11）：更灵活的 RAII 锁管理，支持手动加锁/解锁、延迟加锁、超时尝试。适用于需要灵活控制锁的场景，如条件变量。

方法：lock(), unlock(), try_lock(), try_lock_for(), try_lock_until().

示例：

std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [] { return !q.empty(); });

std::shared_lock（C++14）：RAII 封装，用于管理 std::shared_mutex 的共享锁（读锁）。适合读写锁的读操作。

示例：

std::shared_lock<std::shared_mutex> lock(smtx);
// 读取共享资源

std::scoped_lock（C++17）：RAII 封装，支持同时锁定多个互斥锁，避免死锁。适合需要锁定多个锁的场景。

示例：

std::mutex m1, m2;
void func() {std::scoped_lock lock(m1, m2); // 同时锁定 m1 和 m2// 访问资源
}

3.条件变量（Condition Variables）

作用：允许线程等待某个条件成立（如队列非空、任务完成），并在条件满足时被唤醒。常与互斥锁配合使用。

C++ 实现：

std::condition_variable（C++11）：允许线程等待条件满足，支持通知机制。

方法：wait(lock, predicate)：释放锁并等待，直到条件满足。wait_for(), wait_until(), notify_one()：唤醒一个等待的线程。notify_all()：唤醒所有等待的线程。

示例：生产者-消费者模型，条件变量协调生产者和消费者，确保消费者在队列非空时才处理数据。

#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <iostream>std::mutex mtx;
std::condition_variable cv;
std::queue<int> q;void producer() {for (int i = 0; i < 5; ++i) {std::lock_guard<std::mutex> lock(mtx);q.push(i);std::cout << "Produced: " << i << std::endl;cv.notify_one(); // 通知消费者}
}void consumer() {while (true) {std::unique_lock<std::mutex> lock(mtx);cv.wait(lock, [] { return !q.empty(); }); // 等待队列非空int value = q.front();q.pop();std::cout << "Consumed: " << value << std::endl;lock.unlock();if (value == 4) break; // 退出条件}
}int main() {std::thread t1(producer);std::thread t2(consumer);t1.join();t2.join();return 0;
}

std::condition_variable_any（C++11）：更通用的条件变量，支持任何符合锁接口的类型（不仅限于 std::mutex）。适用于需要非标准锁类型的场景。

示例：

std::condition_variable_any cv_any;
std::unique_lock<std::shared_mutex> lock(smtx);
cv_any.wait(lock, [] { return true; });

4.原子操作（Atomic Operations）

作用：提供无锁（lock-free）的线程安全的原子操作，适合简单变量（如计数器）的并发访问。

C++ 实现：

std::atomic<T>（C++11）：提供原子操作，支持基本类型（如 int, bool, pointer）和用户定义类型（需满足要求）。用于高效的计数器、标志位。

方法：load(), store(), exchange(), compare_exchange_strong(), fetch_add(), fetch_sub(), 等。

示例：std::atomic 使 counter 的递增操作原子化，解决数据竞争，性能比互斥锁更高。

#include <iostream>
#include <thread>
#include <atomic>std::atomic<int> counter = 0;void increment() {for (int i = 0; i < 1000; ++i) {counter.fetch_add(1); // 原子递增}
}int main() {std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();std::cout << counter << std::endl; // 输出 2000return 0;
}

std::atomic_flag（C++11）：最轻量级的原子类型，仅支持测试和设置操作，保证无锁（lock-free）。用于简单的标志或自旋锁。

方法：test_and_set(), clear(), test() (C++20)。

示例：

std::atomic_flag flag = ATOMIC_FLAG_INIT;
while (flag.test_and_set()) {} // 自旋锁

原子内存序（Memory Ordering）（C++11）：不是独立的原语，但与 std::atomic 密切相关，用于控制原子操作的内存序。用于优化性能或确保正确的同步。

类型：std::memory_order_relaxed, std::memory_order_acquire, std::memory_order_release, std::memory_order_seq_cst, 等。

示例：

std::atomic<int> x = 0;
x.store(1, std::memory_order_release);

5.信号量（Semaphores）

作用：控制有限资源的访问，或协调线程间的执行顺序。信号量是一个计数器，支持增（释放）和减（获取）操作，用于控制资源访问或线程同步。

std::counting_semaphore（C++20）：支持任意计数的信号量，控制有限资源的访问。用于限制并发线程数。

方法：acquire()：减少计数，阻塞如果计数为 0。release()：增加计数，唤醒等待的线程。try_acquire(), try_acquire_for(), try_acquire_until()

示例：信号量限制最多 3 个线程同时运行。

#include <semaphore>
#include <thread>
#include <vector>
#include <iostream>std::counting_semaphore<3> sem(3); // 最多 3 个线程并发void task(int id) {sem.acquire();std::cout << "Task " << id << " running" << std::endl;std::this_thread::sleep_for(std::chrono::milliseconds(100));std::cout << "Task " << id << " done" << std::endl;sem.release();
}int main() {std::vector<std::thread> threads;for (int i = 0; i < 5; ++i) {threads.emplace_back(task, i);}for (auto& t : threads) {t.join();}return 0;
}

std::binary_semaphore（C++20）：计数范围为 0 或 1 的信号量，相当于二进制锁。用于简单的互斥或同步。

示例：

std::binary_semaphore sem(1);
sem.acquire();
// 独占资源
sem.release();

6.屏障（Barriers）

作用：协调一组线程，使它们在某个点同步等待，直到所有线程都到达。

C++ 实现：

std::barrier（C++20）：允许多个线程在到达屏障点时等待，直到所有线程到达。用于多阶段任务同步。

方法：arrive_and_wait()：线程到达屏障并等待。arrive_and_drop()。

示例：屏障确保所有线程完成第一阶段后才进入第二阶段。

#include <barrier>
#include <thread>
#include <iostream>std::barrier sync_point(3);void task(int id) {std::cout << "Task " << id << " phase 1" << std::endl;sync_point.arrive_and_wait();std::cout << "Task " << id << " phase 2" << std::endl;
}int main() {std::vector<std::thread> threads;for (int i = 0; i < 3; ++i) {threads.emplace_back(task, i);}for (auto& t : threads) {t.join();}return 0;
}

7.闩锁（Latches）

闩锁是一次性屏障，等待所有线程完成特定操作。

C++ 实现：

std::latch（C++20）：计数器，线程减少计数，当计数为 0 时继续。用于一次性同步（如初始化完成）。

方法：count_down(), wait(), try_wait(), arrive_and_wait()。

示例：

std::latch latch(3);
void task() {// 初始化latch.count_down();
}
void main_thread() {latch.wait(); // 等待所有任务完成
}

8.其他同步工具

这些工具虽然不完全是传统意义上的同步原语，但与线程同步密切相关。

std::future / std::promise（C++11）：用于异步任务的结果传递和同步，等待异步操作完成。

示例：

std::promise<int> p;
std::future<int> f = p.get_future();
std::thread t([&p] { p.set_value(42); });
std::cout << f.get() << std::endl;
t.join();

std::async（C++11）：启动异步任务，返回 std::future。用于简化异步编程。

示例：

auto f = std::async(std::launch::async, [] { return 42; });
std::cout << f.get() << std::endl;

std::thread::yield（C++11）：让当前线程放弃 CPU，允许其他线程运行，用于优化忙等待。

示例：

while (!ready) {std::this_thread::yield();
}

选择哪种同步原语取决于具体场景：

简单计数器：用 std::atomic。

独占访问：用 std::mutex 和 std::lock_guard。

读多写少：用 std::shared_mutex。

线程等待条件：用 std::condition_variable。

限制并发：用 std::counting_semaphore。

多阶段同步：用 std::barrier。

多个线程互相等待对方释放锁，可能导致死锁。解决：始终按固定顺序获取多个锁，或使用 std::lock 同时获取。

锁（如 mutex）可能导致线程阻塞，降低并发性能。优先考虑无锁机制（如 std::atomic）或减少锁的粒度。

使用 RAII（如 std::lock_guard, std::unique_lock）可以确保锁在异常时释放，保证异常安全。

数据竞争和死锁难以重现时，建议使用线程分析工具（如 ThreadSanitizer）。

选择合适的同步原语需要权衡功能、性能和复杂性。

C++ 同步原语

同步原语（Synchronization Primitives）是操作系统和编程语言提供的基本工具，用于在多线程或并发环境中协调线程（或进程）之间的执行顺序，管理共享资源的访问，以避免数据竞争（data rac…...

编程日记 2025/8/3 15:15:35

mmap详解

mmap详解 mmap基础概念mmap内存映射原理mmap相关函数调用mmap的使用细节mmap和常规文件操作的区别 mmap基础概念 mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一…...

编程日记 2025/7/29 4:28:17

基于大模型底座重构司法信息系统

前置篇章：法律智能体所需的基础知识构建一个高效的法律智能体，特别是在基于RAG（Retrieval-Augmented Generation）架构的背景下，需要融合多种学科和领域的知识。以下是对法律智能体开发和应用所需核心基础知识的简要介…...

编程日记 2025/8/3 15:04:22

如何判断你的PyTorch是GPU版还是CPU版？

如何判断你的PyTorch是GPU版还是CPU版？ PyTorch作为当前最流行的深度学习框架之一，支持在CPU和GPU(NVIDIA CUDA)上运行。对于深度学习开发者来说，正确识别PyTorch版本至关重要，因为GPU版本可以带来10-100倍的性能提升。本文将全面…...

编程日记 2025/7/28 23:44:39

Leetcode刷题记录19——无重复字符的最长子串

题源：https://leetcode.cn/problems/longest-substring-without-repeating-characters/description/?envTypestudy-plan-v2&envIdtop-100-liked 题目描述： 思路一： 通过两个指针，第一个指针指向字串的开头，第二…...

编程日记 2025/7/30 7:40:52

SpringBoot程序的创建以及特点，配置文件，LogBack记录日志，配置过滤器、拦截器、全局异常

一、创建一个SpringBoot程序在之前写过一篇如何创建SpringBoot程序，两种方式，方法1：通过maven创建SpringBoot项目方法2：使用Spring Initialzr创建一个SpringBoot项目（缺点：当创建项目时网络中断&#x…...

编程日记 2025/7/30 17:39:23

Ubuntu20.04 Ollama 配置相关 Ubuntu20.04 Ollama 配置相关ollama修改配置文件常用命令修改端口局域网访问 Ubuntu20.04 Ollama 配置相关 ollama修改配置文件常用命令 sudo gedit /etc/systemd/system/ollama.service systemctl daemon-reload systemctl restart ollama sys…...

编程日记 2025/7/31 21:51:31

python调用ffmpeg对截取视频片段，可批量处理

本文完全免费，非VIP文章，如果您发现需VIP可看全文，请邮箱联系我：openwebsitefoxmail.com 文章目录 python调用ffmpeg对截取视频片段，可批量处理用到的ffmpeg命令python调用bash指令的方法python处理代码准备函数python…...

编程日记 2025/7/30 9:45:38

【WLAN】华为无线AC双机热备负载分担—双链路热备份

配套实验拓扑可以下载学习交流：【WLAN】华为无线AC双机负载分担—双链路热备份双链路备份的传统配置方式是在主、备AC上为AP指定对方AC的IP地址，并分别配置优先级，通过比较优先级的方式来确定主、备AC。为简化配置逻辑，新配置方式…...

编程日记 2025/7/31 18:16:44

学习笔记——《Java面向对象程序设计》-内部类、匿名类、异常类

参考教材： Java面向对象程序设计（第3版）微课视频版清华大学出版社 1、内部类类中可以有两种重要的成员：成员变量和方法。实际上Java还允许类可以有一种成员：内部类。内部类可以使用其外嵌类中的成员变量&#x…...

编程日记 2025/7/29 20:14:40

BS架构与CS架构的对比分析：了解两种架构的不同特点与应用

目录前言1. BS架构概述1.1 什么是BS架构？1.2 BS架构的主要特点 2. CS架构概述2.1 什么是CS架构？2.2 CS架构的主要特点 3. BS架构与CS架构的对比3.1 用户体验3.2 安全性3.3 适用场景 4. 结语前言在现代软件开发中，架构设计决定了应用的性能…...

编程日记 2025/7/30 4:22:21

ARM架构的微控制器总线矩阵优先级与配置

在 ARM 架构的微控制器中，总线矩阵的优先级与配置是确保多主设备（如 CPU、DMA 等）高效协同工作的关键。总线矩阵通过仲裁逻辑（Arbiter）管理主设备对共享资源的访问冲突，优先级配置直接影响系统的实时性、带宽利用率和任务响应速度。以下是总线矩阵优先级机制及配置的详细…...

编程日记 2025/7/25 5:53:52

高速系统设计理论基础

如前一章所述，在进行高速系统设计时，最重要的是要从基本理论出发，只有掌握了基本理论，然后才能谈到其他的设计技术和技巧。本章主要介绍微波电磁理论基础，及其在高速系统设计中的工程化分析方法和应用。通过对微波信号…...

编程日记 2025/8/1 6:14:29

Python-MCPServer开发

Python-MCPServer开发使用FastMCP开发【SSE模式的MCPServer】，熟悉【McpServer编码过程】【McpServer调试方法】 1-核心知识点 1-熟悉【SSE模式的MCPServer】开发2-熟悉【stdio模式的MCPServer】开发3-熟悉【启动MCPServer】的三种方式 3.1-直接启动:python mcp_s…...

编程日记 2025/7/29 17:01:18

Springboot集成SSE实现消息推送＋RabbitMQ解决集群环境下SSE通道跨节点事件推送问题

SSE连接介绍，SSE对比WebSocket Server-Sent Events (SSE) 是一种基于 HTTP 协议的轻量级实时通信技术，允许服务器向客户端推送数据。以下是 SSE 的主要特点： 单向通信：SSE 仅支持服务器向客户端推送数据，客户端不能通…...

编程日记 2025/7/29 15:27:35

Kettle学习

一、Kettle 简介 Kettle（现称为 Pentaho Data Integration）是一款开源ETL工具，支持从多种数据源抽取、转换和加载数据，广泛应用于数据仓库构建、数据迁移和清洗。其核心优势包括：可视化操作：通过拖拽组件设计数据处理流程（转换和作业）。多数据源支持：数据库（MySQL/…...

编程日记 2025/7/29 18:31:01

科学养生，开启健康生活新方式

在快节奏的现代生活中，健康养生已成为人们关注的焦点。科学的养生方式不仅能增强体质，还能有效预防疾病，提升生活质量。合理饮食是健康养生的基础。日常饮食应遵循均衡原则，保证蛋白质、碳水化合物、脂肪、维生素和矿物质的合…...

编程日记 2025/7/29 19:16:06

brew 安装openjdk查看其版本

使用brew（如果你使用Homebrew安装） 如果你通过Homebrew安装了OpenJDK，可以使用以下命令来查看安装的版本,： brew list --versions openjdk8 这将会列出所有通过Homebrew安装的OpenJDK版本及其版本号。 3. 查看/usr/libexec/ja…...

编程日记 2025/7/30 4:38:35

基于大模型对先天性幽门肥厚性狭窄预测及临床方案的研究报告

目录一、引言 1.1 研究背景与目的 1.2 国内外研究现状 1.3 研究方法与创新点二、先天性幽门肥厚性狭窄概述 2.1 定义与发病机制 2.2 流行病学特征 2.3 病理与解剖特点三、大模型预测原理及构建 3.1 大模型简介 3.2 数据收集与预处理 3.3 模型训练与优化四、大…...

编程日记 2025/8/2 21:00:13

【开源】基于51单片机的温湿度检测报警系统

项目说明该设计是一个简易的基于51单片机的温湿度检测报警系统，功能说明： 使用LCD1602实时显示当前的温湿度。读取DHT11的温湿度值，如果温度大于最大设定值，LED1亮，如果温度小于最小设定值，LED2亮。如果…...

编程日记 2025/8/2 17:13:34

2025年4月25日第一轮

1.作文 The increasing reliance on onlineshopping has brought both convince and challenge to consumsers.It is of great nesscity for poeple to adapt better strategies to cope with these challenges.Resons and concrete evidence to support my view are as fello…...

编程日记 2025/8/1 23:56:03

相关文章：