mutex和atomic的效率比较

该博客通过示例代码展示了多线程环境下,普通变量、原子变量以及互斥锁在并发计数中的性能差异。实验中创建了三个函数,分别使用普通变量、原子变量和互斥锁进行10000次递增操作。结果显示,原子变量和互斥锁相比普通变量能避免数据竞争,但原子操作通常具有更高的效率。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

#include <iostream>
#include <vector>
#include <atomic>
#include <thread>
#include <mutex>

using namespace std;

long long a = 0;
atomic<long long> b(0);
long long c = 0;
mutex mt;

void fun1(){
    for(int i = 0; i < 10000; i++){
        a++;
    }
}

void fun2(){
    for(int i = 0; i < 10000; i++){
        b++;
    }
}

void fun3(){
    for(int i = 0; i < 10000; i ++){
        mt.lock();
        c++;
        mt.unlock();
    }
}

int main(){
    vector<thread> save1;
    vector<thread> save2;
    vector<thread> save3;

    clock_t start_time1,end_time1,start_time2,end_time2,start_time3,end_time3;

    cout << "P1 ,GO" <<endl;
    cout << "P2, GO" <<endl;
    cout << "P3, GO" <<endl;

    start_time1 = clock();
    for(int i = 0; i < 10000; i++){
        save1.push_back(thread(fun1));
    }
    for(auto& a: save1){
        a.join();
    }
    end_time1 = clock();

    start_time2 = clock();
    for(int i = 0; i < 10000; i++){
        save2.push_back(thread(fun2));
    }
    for(auto& b: save2){
        b.join();
    }
    end_time2 = clock();

    start_time3 = clock();
    for(int i = 0; i < 10000; i++){
        save3.push_back(thread(fun3));
    }
    for(auto& c: save3){
        c.join();
    }
    end_time3 = clock();

    cout << a << " waste time:"<<end_time1- start_time1<<endl;
    cout << b << " waste time:"<<end_time2- start_time2<<endl;
    cout << c << " waste time:"<<end_time3- start_time3<<endl;

    cout << "Final" << endl;

    return 0;
}


输出结果
在这里插入图片描述

### C++ 中多线程编程的支持 #### std::thread 的基本用法 `std::thread` 是 C++11 引入的标准库组件之一,用于创建管理线程。它可以轻松启动一个新的线程来执行指定的任务函数。 以下是 `std::thread` 的简单示例: ```cpp #include <iostream> #include <thread> void thread_function() { std::cout << "This is a new thread." << std::endl; } int main() { std::thread t(thread_function); if (t.joinable()) { t.join(); // 等待子线程完成 } return 0; } ``` 在这个例子中,主线程会等待新创建的线程结束之后再继续运行[^2]。 --- #### std::mutex 的作用与实现方式 为了保护共享资源不被多个线程同时访问而导致数据竞争问题,C++ 提供了互斥量(`std::mutex`)。通过锁定机制防止其他线程进入临界区直到当前线程释放锁为止。 下面是一个使用 `std::mutex` 来保护全局变量的例子: ```cpp #include <iostream> #include <thread> #include <mutex> std::mutex mtx; // 定义一个互斥对象 int shared_variable = 0; void increment_with_mutex(int id) { for (int i = 0; i < 5; ++i) { std::lock_guard<std::mutex> lock(mtx); // 自动获取并释放锁 ++shared_variable; std::cout << "Thread ID: " << id << ", Value: " << shared_variable << std::endl; } } int main() { std::thread t1(increment_with_mutex, 1); std::thread t2(increment_with_mutex, 2); t1.join(); t2.join(); return 0; } ``` 这里展示了如何利用 `std::lock_guard` 对象简化手动调用 `lock()` `unlock()` 方法的过程[^2]。 --- #### std::atomic 的概念及其优势 当只需要确保某些特定类型的单个操作具有原子性时,可以考虑采用更轻量级的选择——`std::atomic` 类型。相比起传统意义上的锁机制来说效率更高一些因为它们通常不会涉及操作系统级别的上下文切换开销。 例如,在计数器场景下可以直接应用如下代码片段替代之前提到过的基于互斥锁版本: ```cpp #include <iostream> #include <thread> #include <atomic> std::atomic<int> atomic_counter(0); void increment_atomic() { for (size_t i = 0; i < 1000; ++i) { atomic_counter.fetch_add(1, std::memory_order_relaxed); } } int main(){ const size_t num_threads = 8; std::vector<std::thread> threads(num_threads); for(auto& th : threads){ th=std::thread(increment_atomic); } for(auto& th : threads){ th.join(); } std::cout<<"Final counter value:"<<atomic_counter<<'\n'; return 0; } ``` 此程序段说明即使存在大量并发修改也不会破坏最终结果的一致性准确性[^3]. --- ### 总结 以上分别介绍了三种主要针对不同需求设计出来的同步手段:如果只是想让一段代码块只允许单一时刻只有一个活跃实例去执行那么就选用 Mutex;而对于那些仅仅关心某个单独数值变化情况则推荐 Atomic 。每种方法都有各自适用范围以及优缺点所以在实际开发过程中应该依据具体情况做出最佳决策[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值