怎么搜索网站百度上看了不健康的内容犯法吗

简介： CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！

优质专栏：Audio工程师进阶系列【原创干货持续更新中……】🚀

人生格言： 人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药.

更多原创,欢迎关注：Android系统攻城狮

1.前言

本篇目的：理解C++之std::atomic原子操作解决多线程竟态问题用法。

2.std::atomic可以解决的C++多线程问题

在C++中，std::atomic提供了一种线程安全的访问原子类型的机制，可以解决以下七个多线程之间的问题：

1. 竞态条件（Race Condition）：多个线程同时访问和修改同一个变量时可能导致数据错误。
2. 内存可见性（Memory Visibility）：不同线程对共享变量的修改可能不可见，导致读取到过期的值。
3. 乱序执行（Out-of-Order Execution）：处理器可能以不同的顺序执行指令，导致结果的不确定性。
4. 死锁（Deadlock）：多个线程相互等待对方释放资源，导致程序无法继续执行。
5. 活锁（Live Lock）：多个线程相互响应对方的动作，而无法继续向前推进。
6. 数据竞争（Data Race）：多个线程同时访问和修改共享数据，没有同步机制可能导致不确定的行为。
7. 优先级反转（Priority Inversion）：高优先级任务被低优先级任务持续占用共享资源，导致高优先级任务无法及时执行。

3.应用实例

1. 竞态条件（Race Condition）：

v1.0 未使用atomic原子操作

#include <atomic>
#include <thread>
#include <cstdio>//std::atomic<int> counter(0); // 原子变量
int counter = 0; // 普通变量void increment() {for (int i = 0; i < 1000; i++) {counter++; // 原子操作：递增printf("counter = %d\n",counter);//打印出来的数据是乱序的}
}int main() {std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();return 0;
}

v2.0 使用atomic原子操作

#include <atomic>
#include <thread>std::atomic<int> counter(0); // 原子变量void increment() {for (int i = 0; i < 1000; i++) {counter++; // 原子操作：递增printf("counter = %d\n",counter.load());//按顺序打印0 - 2000.	}
}int main() {std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();return 0;
}

多个线程同时对counter进行递增操作，使用std::atomic可以避免竞态条件，保证递增操作的原子性。

2. 内存可见性（Memory Visibility）：

#include <atomic>
#include <thread>
#include <iostream>std::atomic<bool> flag(false); // 原子标志void run() {while (!flag.load()) {// do something}printf("flag = %d\n",flag.load());
}int main() {std::thread t(run);// 假设这里执行一些耗时的计算std::this_thread::sleep_for(std::chrono::seconds(1));flag.store(true); // 原子操作：标志位置为truet.join();return 0;
}

flag作为一个标志位，在一个线程中修改为true，其他线程可以通过读取flag的原子操作来感知到修改，保证内存的可见性。

3. 乱序执行（Out-of-Order Execution）：

#include <atomic>
#include <thread>
#include <iostream>std::atomic<int> value(0); // 原子变量void write() {value.store(42, std::memory_order_relaxed); // 原子操作：无序存储
}void read() {while (value.load(std::memory_order_relaxed) == 0) {// do something}std::cout << "Value: " << value.load(std::memory_order_relaxed) << std::endl;
}int main() {std::thread t1(write);std::thread t2(read);t1.join();t2.join();return 0;
}

通过使用适当的内存顺序(memory_order)来进行原子操作，可以避免乱序执行带来的问题，例如使用std::memory_order_relaxed来指定无序存储。

4. 死锁（Deadlock）：

#include <atomic>
#include <mutex>
#include <thread>std::atomic<bool> flag1(false);
std::atomic<bool> flag2(false);std::mutex mutex1;
std::mutex mutex2;void process1() {mutex1.lock(); // 获取锁1// 假设这里执行一些操作flag1.store(true); // 标记为已处理mutex2.lock(); // 获取锁2// 执行需要锁2的操作mutex2.unlock();mutex1.unlock();
}void process2() {mutex2.lock(); // 获取锁2// 假设这里执行一些操作flag2.store(true); // 标记为已处理mutex1.lock(); // 获取锁1// 执行需要锁1的操作mutex1.unlock();mutex2.unlock();
}int main() {std::thread t1(process1);std::thread t2(process2);t1.join();t2.join();return 0;
}

多个线程对两个互斥量(mutex)进行获取操作，可能导致死锁，std::atomic不能直接解决死锁问题，但可以用来作为线程间的通信机制。

5. 活锁（Live Lock）：

#include <atomic>
#include <thread>
#include <iostream>std::atomic<bool> flag1(false);
std::atomic<bool> flag2(false);void process1() {while (!flag2) {// 假设这里执行一些操作// 暂停一段时间，避免忙等待std::this_thread::sleep_for(std::chrono::milliseconds(100));flag1.store(true);// 假设这里还有其他判断逻辑}
}void process2() {while (!flag1.load()) {// 假设这里执行一些操作// 暂停一段时间，避免忙等待std::this_thread::sleep_for(std::chrono::milliseconds(100));flag2.store(true);// 假设这里还有其他判断逻辑}
}int main() {std::thread t1(process1);std::thread t2(process2);t1.join();t2.join();std::cout << "Live lock detected!" << std::endl;return 0;
}

两个线程互相等待对方设置标志位，但由于不断地执行操作和忙等待，两个线程无法继续前进，造成活锁。

6. 数据竞争（Data Race）：

#include <atomic>
#include <thread>
#include <iostream>std::atomic<int> counter(0); // 原子计数器void increment() {for (int i = 0; i < 1000; i++) {int temp = counter.load(); // 读取计数器的当前值counter.store(temp + 1);   // 原子操作：递增}
}int main() {std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();std::cout << "Counter: " << counter.load() << std::endl;return 0;
}

两个线程同时读取和修改计数器的值，使用std::atomic可以避免数据竞争，保证计数器的正确递增。

7. 优先级反转（Priority Inversion）：

#include <atomic>
#include <thread>
#include <iostream>std::atomic<int> sharedResource(0); // 共享资源void lowPriorityThread() {while (true) {// 低优先级任务需要访问共享资源while (sharedResource.load() == 0) {// do something}std::cout << "Low priority thread accessing shared resource." << std::endl;// 假设这里执行一些低优先级任务的操作// 完成低优先级任务后释放共享资源sharedResource.store(0);}
}void highPriorityThread() {// 高优先级任务需要持有共享资源sharedResource.store(1);std::cout << "High priority thread acquired shared resource." << std::endl;// 假设这里执行一些高优先级任务的操作// 完成高优先级任务后释放共享资源sharedResource.store(0);
}int main() {std::thread t1(lowPriorityThread);std::thread t2(highPriorityThread);t1.join();t2.join();return 0;
}