探索多线程下原子操作与锁的区别：何时选择何种同步机制

Comely • 2024-09-26 • C++

内容纲要

探索多线程下原子操作与锁的区别：何时选择何种同步机制

在现代软件开发中，多线程编程已成为提升应用性能和响应性的关键手段。然而，多线程环境下的资源共享和数据一致性问题也随之而来。为了确保线程安全，开发者通常需要使用同步机制，如原子操作（Atomic Operations）和锁（Locks）。本文将深入探讨这两种同步机制的区别、各自的优缺点，并结合实际代码示例，帮助你在不同场景下选择最优的解决方案。

引言

多线程编程能够显著提高程序的并发性能，但也带来了资源竞争和数据一致性的问题。为了解决这些问题，开发者需要确保多个线程在访问共享资源时不会引发竞态条件。常见的同步机制包括原子操作和锁。理解它们的区别和适用场景，对于编写高效、可靠的多线程程序至关重要。

原子操作（Atomic Operations）

什么是原子操作？

原子操作是一种不可分割的操作，意味着在执行过程中不会被中断或干扰。原子操作在多线程环境中用于对共享数据进行安全的读写，而无需使用锁机制。

C++中的原子类型

C++11引入了原子类型（std::atomic），为开发者提供了在多线程环境下进行原子操作的工具。原子类型保证了对变量的操作是原子的，避免了竞态条件。

常见的原子类型

std::atomic<bool>
std::atomic<int>
std::atomic<T*>
std::atomic_flag

代码示例：使用 `std::atomic_bool`

以下代码展示了如何使用std::atomic_bool来控制一个函数在多线程环境下只被一个线程执行：

#include <atomic>
#include <iostream>
#include <thread>

std::atomic_bool isRunning = false;

void process() {
    bool expected = false;
    // 尝试将 isRunning 从 false 设置为 true
    if (!isRunning.compare_exchange_strong(expected, true)) {
        return; // 如果失败，说明已有线程在运行
    }
    std::cout << "processing ..." <<  std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    std::cout << "finished" <<  std::endl;
    isRunning.store(false, std::memory_order_release);
}

int main()
{
    std::thread th1(process);
    std::thread th2(process);
    std::thread th3(process);
    std::thread th4(process);
    std::thread th5(process);
    th1.join();
    th2.join();
    th3.join();
    th4.join();
    th5.join();
    return 0;
}

代码解析

原子变量声明：
```
std::atomic_bool isRunning = false;
```
isRunning是一个原子布尔变量，初始值为false。
原子操作：
```
if (!isRunning.compare_exchange_strong(expected, true)) {
    return;
}
```
使用compare_exchange_strong尝试将isRunning从false设置为true。如果成功，当前线程继续执行；否则，说明已有线程在运行，直接返回。

任务执行与重置：

std::cout << "processing ..." <<  std::endl;
std::this_thread::sleep_for(std::chrono::seconds(5));
std::cout << "finished" <<  std::endl;
isRunning.store(false, std::memory_order_release);

执行任务后，将isRunning重置为false，允许其他线程执行。

锁（Locks）

什么是锁？

锁是一种同步机制，用于控制多个线程对共享资源的访问。通过锁，确保同一时间只有一个线程可以访问被保护的资源，避免数据竞争和不一致。

C++中的锁机制

C++11提供了多种锁机制，最常见的是互斥锁（std::mutex）。此外，还有读写锁（std::shared_mutex）、递归锁（std::recursive_mutex）等。

常见的锁类型

std::mutex
std::recursive_mutex
std::timed_mutex
std::shared_mutex

代码示例：使用 `std::mutex`

以下代码展示了如何使用std::mutex来控制一个函数在多线程环境下的同步执行：

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

std::mutex mtx;
bool isRunning = false;

void process() {
    std::lock_guard<std::mutex> lock(mtx);
    if (isRunning) {
        return;
    }
    isRunning = true;
    std::cout << "processing ..." <<  std::endl;
    mtx.unlock(); // 解锁以允许其他线程等待
    std::this_thread::sleep_for(std::chrono::seconds(5));
    mtx.lock(); // 再次加锁以修改 isRunning
    std::cout << "finished" <<  std::endl;
    isRunning = false;
}

int main()
{
    std::thread th1(process);
    std::thread th2(process);
    std::thread th3(process);
    std::thread th4(process);
    std::thread th5(process);
    th1.join();
    th2.join();
    th3.join();
    th4.join();
    th5.join();
    return 0;
}

代码解析

互斥锁声明：
```
std::mutex mtx;
bool isRunning = false;
```
mtx是一个互斥锁，isRunning用于标识任务是否正在运行。
锁的使用：
```
std::lock_guard lock(mtx);
if (isRunning) {
    return;
}
isRunning = true;
```
使用std::lock_guard自动加锁和解锁，确保isRunning的检查和设置是线程安全的。

任务执行与重置：

mtx.unlock();
std::this_thread::sleep_for(std::chrono::seconds(5));
mtx.lock();
std::cout << "finished" <<  std::endl;
isRunning = false;

解锁后执行任务，完成后再次加锁以重置isRunning。

原子操作与锁的比较

性能对比

原子操作：
- 优势：通常比锁更高效，因为它们避免了上下文切换和线程阻塞的开销。
- 劣势：适用于简单的同步场景，如单一变量的读写。复杂操作可能需要多个原子操作，增加实现复杂度。
锁：
- 优势：适用于复杂的同步需求，能够保护多个变量或复杂的数据结构。
- 劣势：可能导致性能瓶颈，尤其在高竞争情况下，锁的获取和释放开销较大。

使用复杂度

原子操作：
- 优点：代码简洁，适合简单的同步场景。
- 缺点：对于复杂的同步需求，代码实现可能变得复杂且容易出错。
锁：
- 优点：直观易用，适用于各种复杂的同步场景。
- 缺点：需要小心避免死锁、优先级反转等问题。

适用场景

原子操作：
- 适用于对单一变量的读写控制。
- 高性能要求下，避免使用锁。
- 简单的状态标志控制。
锁：
- 需要保护多个相关变量或复杂数据结构。
- 需要执行一系列操作的原子性。
- 复杂的同步逻辑，无法通过简单的原子操作实现。

实战案例分析

单例模式中的同步

在实现单例模式时，确保只有一个实例被创建是至关重要的。以下是两种实现方式，分别使用原子操作和锁机制。

使用锁实现单例模式

#include <mutex>

class SingletonLock
{
public:
    static SingletonLock* getInstance()
    {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> guard(mutex);
            if (instance == nullptr) {
                instance = new SingletonLock();
                atexit(Destructor);
            }
        }
        return instance;
    }

private:
    static void Destructor()
    {
        delete instance;
        instance = nullptr;
    }
    SingletonLock() {}
    ~SingletonLock() {}
    SingletonLock(const SingletonLock&) = delete;
    SingletonLock& operator=(const SingletonLock&) = delete;

    static SingletonLock* instance;
    static std::mutex mutex;
};

SingletonLock* SingletonLock::instance = nullptr;
std::mutex SingletonLock::mutex;

使用原子操作实现单例模式

#include <atomic>
#include <mutex>

class SingletonAtomic
{
public:
    static SingletonAtomic* getInstance()
    {
        SingletonAtomic* temp = instance.load(std::memory_order_acquire);
        if (temp == nullptr) {
            std::lock_guard<std::mutex> guard(mutex);
            temp = instance.load(std::memory_order_relaxed);
            if (temp == nullptr) {
                temp = new SingletonAtomic();
                instance.store(temp, std::memory_order_release);
                atexit(Destructor);
            }
        }
        return temp;
    }

private:
    static void Destructor()
    {
        delete instance.load();
        instance.store(nullptr);
    }
    SingletonAtomic() {}
    ~SingletonAtomic() {}
    SingletonAtomic(const SingletonAtomic&) = delete;
    SingletonAtomic& operator=(const SingletonAtomic&) = delete;

    static std::atomic<SingletonAtomic*> instance;
    static std::mutex mutex;
};

std::atomic<SingletonAtomic*> SingletonAtomic::instance{nullptr};
std::mutex SingletonAtomic::mutex;

代码对比

锁实现：
- 使用双重检查锁定（Double-Checked Locking）模式。
- 简单直观，但需要使用锁来确保线程安全。
原子操作实现：
- 使用std::atomic确保指针操作的原子性。
- 结合锁进一步保证线程安全，适用于更高性能的需求。

多线程下的任务处理

以下是一个任务处理函数的示例，展示了原子操作与锁机制在控制任务执行中的应用。

问题描述

有多个线程同时调用process函数，要求同一时间内只有一个线程可以执行任务，其他线程应直接返回。

使用原子操作实现

#include <atomic>
#include <iostream>
#include <thread>

std::atomic_bool isRunning = false;

void process() {
    bool expected = false;
    // 尝试将 isRunning 从 false 设置为 true
    if (!isRunning.compare_exchange_strong(expected, true)) {
        return; // 如果失败，说明已有线程在运行
    }
    std::cout << "processing ..." <<  std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    std::cout << "finished" <<  std::endl;
    isRunning.store(false, std::memory_order_release);
}

int main()
{
    std::thread th1(process);
    std::thread th2(process);
    std::thread th3(process);
    std::thread th4(process);
    std::thread th5(process);
    th1.join();
    th2.join();
    th3.join();
    th4.join();
    th5.join();
    return 0;
}

使用锁实现

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

std::mutex mtx;
bool isRunning = false;

void process() {
    std::lock_guard<std::mutex> lock(mtx);
    if (isRunning) {
        return;
    }
    isRunning = true;
    std::cout << "processing ..." <<  std::endl;
    mtx.unlock(); // 解锁以允许其他线程等待
    std::this_thread::sleep_for(std::chrono::seconds(5));
    mtx.lock(); // 再次加锁以修改 isRunning
    std::cout << "finished" <<  std::endl;
    isRunning = false;
}

int main()
{
    std::thread th1(process);
    std::thread th2(process);
    std::thread th3(process);
    std::thread th4(process);
    std::thread th5(process);
    th1.join();
    th2.join();
    th3.join();
    th4.join();
    th5.join();
    return 0;
}

代码对比

原子操作：
- 更加高效，避免了锁的开销。
- 代码简洁，适用于简单的状态控制。
锁机制：
- 代码复杂度较高，需要手动管理锁的解锁和重锁。
- 更加通用，适用于复杂的同步需求。

原子操作与锁的比较

性能对比

原子操作通常比锁更高效，因为它们避免了上下文切换和线程阻塞的开销。在需要高频度同步的场景下，原子操作能显著提升性能。
锁机制在低竞争的场景下性能影响较小，但在高竞争下可能成为性能瓶颈，尤其是锁的获取和释放需要耗费额外的时间。

使用复杂度

原子操作适用于简单的同步需求，如单一变量的读写。对于复杂的操作，使用原子操作可能导致代码复杂度增加，容易出错。
锁机制更加通用，适用于保护多个相关变量或复杂的数据结构。虽然使用起来较为复杂，但在复杂同步需求下提供了更好的灵活性。

适用场景

原子操作适用于：
- 单一变量的简单状态控制。
- 高性能要求的低复杂度同步场景。
- 避免锁带来的性能开销。
锁机制适用于：
- 保护多个相关变量或复杂数据结构。
- 需要执行一系列原子操作的同步场景。
- 复杂的同步逻辑，无法通过简单的原子操作实现。

实战案例分析

单例模式中的同步

单例模式要求类只有一个实例，并提供全局访问点。在多线程环境下，确保单例实例的唯一性是关键。

使用锁实现单例模式

#include <mutex>

class SingletonLock
{
public:
    static SingletonLock* getInstance()
    {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> guard(mutex);
            if (instance == nullptr) {
                instance = new SingletonLock();
                atexit(Destructor);
            }
        }
        return instance;
    }

private:
    static void Destructor()
    {
        delete instance;
        instance = nullptr;
    }
    SingletonLock() {}
    ~SingletonLock() {}
    SingletonLock(const SingletonLock&) = delete;
    SingletonLock& operator=(const SingletonLock&) = delete;

    static SingletonLock* instance;
    static std::mutex mutex;
};

SingletonLock* SingletonLock::instance = nullptr;
std::mutex SingletonLock::mutex;

使用原子操作实现单例模式

#include <atomic>
#include <mutex>

class SingletonAtomic
{
public:
    static SingletonAtomic* getInstance()
    {
        SingletonAtomic* temp = instance.load(std::memory_order_acquire);
        if (temp == nullptr) {
            std::lock_guard<std::mutex> guard(mutex);
            temp = instance.load(std::memory_order_relaxed);
            if (temp == nullptr) {
                temp = new SingletonAtomic();
                instance.store(temp, std::memory_order_release);
                atexit(Destructor);
            }
        }
        return temp;
    }

private:
    static void Destructor()
    {
        delete instance.load();
        instance.store(nullptr);
    }
    SingletonAtomic() {}
    ~SingletonAtomic() {}
    SingletonAtomic(const SingletonAtomic&) = delete;
    SingletonAtomic& operator=(const SingletonAtomic&) = delete;

    static std::atomic<SingletonAtomic*> instance;
    static std::mutex mutex;
};

std::atomic<SingletonAtomic*> SingletonAtomic::instance{nullptr};
std::mutex SingletonAtomic::mutex;

多线程下的任务处理

控制多个线程对同一任务的访问，确保任务在同一时间只被一个线程执行。

使用原子操作实现

#include <atomic>
#include <iostream>
#include <thread>

std::atomic_bool isRunning = false;

void process() {
    bool expected = false;
    if (!isRunning.compare_exchange_strong(expected, true)) {
        return;
    }
    std::cout << "processing ..." <<  std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    std::cout << "finished" <<  std::endl;
    isRunning.store(false, std::memory_order_release);
}

int main()
{
    std::thread th1(process);
    std::thread th2(process);
    std::thread th3(process);
    std::thread th4(process);
    std::thread th5(process);
    th1.join();
    th2.join();
    th3.join();
    th4.join();
    th5.join();
    return 0;
}

使用锁实现

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

std::mutex mtx;
bool isRunning = false;

void process() {
    std::lock_guard<std::mutex> lock(mtx);
    if (isRunning) {
        return;
    }
    isRunning = true;
    std::cout << "processing ..." <<  std::endl;
    mtx.unlock();
    std::this_thread::sleep_for(std::chrono::seconds(5));
    mtx.lock();
    std::cout << "finished" <<  std::endl;
    isRunning = false;
}

int main()
{
    std::thread th1(process);
    std::thread th2(process);
    std::thread th3(process);
    std::thread th4(process);
    std::thread th5(process);
    th1.join();
    th2.join();
    th3.join();
    th4.join();
    th5.join();
    return 0;
}

选择指南：何时使用原子操作，何时使用锁

使用原子操作的建议

简单状态控制：当需要控制简单的状态标志，如任务是否正在运行时，原子操作是高效的选择。
高性能要求：在高频度的同步场景下，避免锁的开销，使用原子操作可以显著提升性能。
单一变量同步：适用于对单一变量进行读写的同步需求。

使用锁的建议

复杂同步需求：当需要保护多个相关变量或复杂的数据结构时，锁机制更加合适。
一系列原子操作：需要执行一系列操作的原子性时，锁提供了更好的控制。
易于理解和维护：锁机制相对直观，适用于需要代码易读性和可维护性的场景。

结论

在多线程编程中，选择合适的同步机制对程序的性能和可靠性至关重要。原子操作适用于简单、高性能的同步需求，而锁机制则适用于更复杂的同步场景。理解它们的区别和各自的优缺点，结合实际需求，能够帮助开发者编写出高效、可靠的多线程程序。

通过本文的深入分析和代码示例，希望你能够更好地理解原子操作与锁机制的使用场景，并在实际开发中做出明智的选择。

版权声明：
作者：Comely
链接：https://www.alimzs.com/index.php/2024/09/26/atomic/
来源：CAE
文章版权归作者所有，未经允许请勿转载。

THE END

二维码

海报

探索多线程下原子操作与锁的区别：何时选择何种同步机制

内容纲要探索多线程下原子操作与锁的区别：何时选择何种同步机制在现代软件开发中，多线程编程已成为提升应用性能和响应性的关键手段……

探究C++单例模式

<<上一篇

探索批量属性修改的方法

下一篇>>

探索多线程下原子操作与锁的区别：何时选择何种同步机制

探索多线程下原子操作与锁的区别：何时选择何种同步机制

目录

引言

原子操作（Atomic Operations）

什么是原子操作？

C++中的原子类型

常见的原子类型

代码示例：使用 std::atomic_bool

代码解析

锁（Locks）

什么是锁？

C++中的锁机制

常见的锁类型

代码示例：使用 std::mutex

代码解析

原子操作与锁的比较

性能对比

使用复杂度

适用场景

实战案例分析

单例模式中的同步

使用锁实现单例模式

使用原子操作实现单例模式

代码对比

多线程下的任务处理

问题描述

使用原子操作实现

使用锁实现

代码对比

原子操作与锁的比较

性能对比

使用复杂度

适用场景

实战案例分析

单例模式中的同步

使用锁实现单例模式

使用原子操作实现单例模式

多线程下的任务处理

使用原子操作实现

使用锁实现

选择指南：何时使用原子操作，何时使用锁

使用原子操作的建议

使用锁的建议

结论

取消回复

共有 0 条评论

代码示例：使用 `std::atomic_bool`

代码示例：使用 `std::mutex`