学懂C++（三十一）：高级教程——深入详解C++高级多线程编程技术之锁优化与替代

猿享天开

于 2024-08-14 13:04:34 发布

阅读量691

点赞数 20

分类专栏：学懂C++语言-C++核心编程精讲文章标签： c++ 开发语言多线程锁（Lock）

本文链接：https://blog.csdn.net/martian665/article/details/141188114

版权

学懂C++语言-C++核心编程精讲专栏收录该内容

32 篇文章 0 订阅

订阅专栏

引言

随着多核处理器的普及，多线程编程技术已经成为提高应用程序性能的关键手段。在多线程环境下，如何高效、安全地管理线程之间的共享资源是开发者面临的主要挑战。传统的锁机制，如互斥锁（Mutex）、临界区（Critical Section）等，虽然能有效防止数据竞争，但也存在性能瓶颈。在高并发场景下，这些锁可能会导致线程频繁阻塞，从而降低整体性能。因此，锁优化和无锁编程技术应运而生，旨在提高多线程程序的性能和扩展性。

本文将深入探讨几种高级多线程编程技术，包括自动锁、读写锁、无锁编程技术。我们将结合经典示例和详细解析，帮助开发者掌握这些技术的核心概念和使用技巧。

1. 自动锁（RAII锁）

1.1 自动锁的概念

自动锁（RAII锁）是一种利用C++的RAII（Resource Acquisition Is Initialization）机制自动管理锁的技术。RAII锁通过构造函数获取锁，通过析构函数释放锁，从而避免了手动管理锁的繁琐，并且在异常处理或函数提前返回的情况下，确保锁能够正确释放。

1.2 示例：使用 `std::lock_guard` 实现自动锁

std::lock_guard 是 C++11 提供的自动锁工具，它能够确保在作用域结束时自动释放锁。

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

std::mutex mtx;
int counter = 0;

void incrementCounter() {
    std::lock_guard<std::mutex> lock(mtx);  // 自动获取和释放锁
    ++counter;
    std::cout << "Counter: " << counter << std::endl;
}

int main() {
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);

    t1.join();
    t2.join();

    std::cout << "Final counter: " << counter << std::endl;
    return 0;
}

1.3 运行结果

Counter: 1
Counter: 2
Final counter: 2

这段C++程序展示了如何使用std::mutex和std::lock_guard来确保线程安全地更新一个共享变量counter。下面是对程序各部分的解释：

包含头文件:

#include <iostream>: 包含输入输出流库，用于标准输入输出操作。
#include <thread>: 包含线程库，用于创建和管理线程。
#include <mutex>: 包含互斥量库，用于实现同步机制。

全局变量声明:

std::mutex mtx;: 声明一个互斥量对象mtx，用于保护对counter的访问。
int counter = 0;: 声明一个整型变量counter，初始值为0，该变量将在多个线程间共享。

函数定义:

void incrementCounter(): 定义了一个名为incrementCounter的函数，用于增加counter的值。
std::lock_guard<std::mutex> lock(mtx);: 使用std::lock_guard自动锁定互斥量mtx，确保函数体内的代码原子性执行。当lock_guard对象生命周期结束时，互斥量自动解锁。
++counter;: 增加counter的值。
std::cout << "Counter: " << counter << std::endl;: 输出当前counter的值。

主函数:

std::thread t1(incrementCounter);: 创建一个线程t1，它将调用incrementCounter函数。
std::thread t2(incrementCounter);: 创建另一个线程t2，同样调用incrementCounter函数。
t1.join();: 等待t1线程执行完成。
t2.join();: 等待t2线程执行完成。
std::cout << "Final counter: " << counter << std::endl;: 输出最终的counter值。

程序行为:

当t1和t2两个线程并发运行时，由于incrementCounter函数使用了std::lock_guard来锁定mtx，因此每次只有一个线程能够进入函数体并增加counter的值。
这样可以避免竞态条件，保证counter的值正确更新。
std::lock_guard: std::lock_guard<std::mutex> lock(mtx);: 这行代码创建了一个std::lock_guard对象lock，并传入互斥量mtx作为构造函数的参数。std::lock_guard是一个RAII（Resource Acquisition Is Initialization）风格的类模板，它会在构造时自动锁定给定的互斥量，并在析构时自动解锁。

锁的自动释放:
当incrementCounter函数执行完毕，std::lock_guard对象lock的生命周期结束，mtx互斥量会自动解锁。

总结来说，这段程序演示了如何使用std::mutex和std::lock_guard来实现线程间的同步，确保共享资源的安全访问。

1.4 核心点解析

自动锁的关键在于它将锁的获取和释放操作封装在对象的生命周期内，利用C++的作用域规则自动管理锁的生存期。使用 std::lock_guard 可以有效避免因忘记释放锁而导致的死锁问题，提高代码的安全性和可维护性。

2. 读写锁（Shared Mutex）

2.1 读写锁的概念

读写锁（Shared Mutex）是一种允许多个线程同时读取共享资源，但在写入时只允许一个线程操作的锁机制。这种锁能够显著提高多线程程序的并发性能，特别是在读操作远多于写操作的情况下。

2.2 示例：使用 `std::shared_mutex` 实现读写锁

C++17 引入了 std::shared_mutex，它允许多个线程同时持有读锁（共享锁），但在写锁（独占锁）被持有时，其他线程的任何读写操作都会被阻塞。

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>

std::shared_mutex rw_mtx;
std::vector<int> data;

void readData(int thread_id) {
    std::shared_lock<std::shared_mutex> lock(rw_mtx);  // 读锁
    std::cout << "Thread " << thread_id << " reading data: ";
    for (const auto& item : data) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

void writeData(int value) {
    std::unique_lock<std::shared_mutex> lock(rw_mtx);  // 写锁
    data.push_back(value);
    std::cout << "Writing data: " << value << std::endl;
}

int main() {
    std::thread writer1(writeData, 1);
    std::thread writer2(writeData, 2);
    std::thread reader1(readData, 1);
    std::thread reader2(readData, 2);

    writer1.join();
    writer2.join();
    reader1.join();
    reader2.join();

    return 0;
}

2.3 运行结果

Writing data: 1
Writing data: 2
Thread 1 reading data: 1 2 
Thread 2 reading data: 1 2

这段C++程序展示了如何使用std::shared_mutex（读写锁）来实现多线程环境下对共享数据data的读写操作。下面是程序各部分的详细解释：

包含头文件:

#include <iostream>: 包含输入输出流库，用于标准输入输出操作。
#include <thread>: 包含线程库，用于创建和管理线程。
#include <shared_mutex>: 包含读写锁库，用于实现读写锁机制。
#include <vector>: 包含向量容器库，用于存储共享数据。

全局变量声明:

std::shared_mutex rw_mtx;: 声明一个读写锁对象rw_mtx，用于保护对data的访问。
std::vector<int> data;: 声明一个整型向量data，用于存储共享数据。

函数定义:

void readData(int thread_id): 定义了一个名为readData的函数，用于读取data向量中的数据。
std::shared_lock<std::shared_mutex> lock(rw_mtx);: 使用std::shared_lock自动获取读锁，允许多个线程同时读取数据。
for (const auto& item : data): 遍历data向量并打印其中的元素。
void writeData(int value): 定义了一个名为writeData的函数，用于向data向量中添加新元素。
std::unique_lock<std::shared_mutex> lock(rw_mtx);: 使用std::unique_lock自动获取写锁，确保一次只有一个线程能够写入数据。
data.push_back(value);: 向data向量中添加新元素。

主函数:

std::thread writer1(writeData, 1);: 创建一个线程writer1，它将调用writeData函数并将值1传递给它。
std::thread writer2(writeData, 2);: 创建另一个线程writer2，同样调用writeData函数并将值2传递给它。
std::thread reader1(readData, 1);: 创建一个线程reader1，它将调用readData函数，并传递线程标识符1。
std::thread reader2(readData, 2);: 创建另一个线程reader2，同样调用readData函数，并传递线程标识符2。
writer1.join();: 等待writer1线程执行完成。
writer2.join();: 等待writer2线程执行完成。
reader1.join();: 等待reader1线程执行完成。
reader2.join();: 等待reader2线程执行完成。

程序行为:

std::shared_mutex是一种读写锁，允许多个线程同时读取数据（即可以有多个读锁），但一次只能有一个线程写入数据（即只能有一个写锁）。
std::shared_lock用于读操作，它允许同时存在多个std::shared_lock实例，即多个线程可以同时读取数据。
std::unique_lock用于写操作，确保在写入数据时不会有其他线程读取或写入数据。
当writer1和writer2尝试写入数据时，它们必须等待，直到没有任何其他线程持有写锁或读锁。
当reader1和reader2尝试读取数据时，它们可以同时读取数据，因为读锁之间不相互排斥。

总结来说，这段程序演示了如何使用std::shared_mutex来实现线程间的同步，确保读写操作的正确性。std::shared_mutex的使用可以提高程序的并发性能，尤其是在读操作远多于写操作的情况下。

2.4 核心点解析

读写锁的主要优势在于它提高了读操作的并发性，适合读多写少的场景。使用 std::shared_mutex 可以让多个读线程并行执行，从而提升程序的性能。然而，需要注意的是，在写锁持有时，所有读写操作都会被阻塞，因此在写操作频繁的情况下，读写锁可能无法带来显著的性能提升。

3. 无锁编程技术

3.1 无锁编程的概念

无锁编程技术旨在通过避免使用传统的锁机制来提高多线程程序的性能和扩展性。在无锁编程中，通常使用原子操作和内存模型来确保线程安全，并避免了锁带来的上下文切换和竞争开销。

3.2 原子操作：`std::atomic`

C++11 引入了 std::atomic 模板类，它提供了一组简单、高效的原子操作接口，能够在多线程环境下确保变量的原子性操作。

示例：使用 `std::atomic` 实现无锁计数器

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

std::atomic<int> atomic_counter(0);

void incrementAtomicCounter() {
    for (int i = 0; i < 10000; ++i) {
        atomic_counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    std::thread t1(incrementAtomicCounter);
    std::thread t2(incrementAtomicCounter);

    t1.join();
    t2.join();

    std::cout << "Final atomic counter: " << atomic_counter << std::endl;
    return 0;
}

3.3 运行结果

Final atomic counter: 20000

3.4 无锁队列

无锁队列是一种先进先出（FIFO）的数据结构，使用无锁技术来确保线程安全。Michael & Scott (M&S) 队列是最著名的无锁队列之一，通过使用原子操作实现队列的无锁入队和出队操作。

示例：使用 `std::atomic` 实现简单的无锁队列

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

template<typename T>
class LockFreeQueue {
private:
    struct Node {
        T data;
        Node* next;
        Node(T value) : data(value), next(nullptr) {}
    };

    std::atomic<Node*> head;
    std::atomic<Node*> tail;

public:
    LockFreeQueue() {
        Node* dummy = new Node(T());
        head.store(dummy);
        tail.store(dummy);
    }

    ~LockFreeQueue() {
        while (Node* node = head.load()) {
            head.store(node->next);
            delete node;
        }
    }

    void enqueue(T value) {
        Node* new_node = new Node(value);
        Node* old_tail = nullptr;

        while (true) {
            old_tail = tail.load();
            Node* next = old_tail->next;

            if (old_tail == tail.load()) {
                if (next == nullptr) {
                    if (std::atomic_compare_exchange_weak(&(old_tail->next), &next, new_node)) {
                        break;
                    }
                } else {
                    std::atomic_compare_exchange_weak(&tail, &old_tail, next);
                }
            }
        }
        std::atomic_compare_exchange_weak(&tail, &old_tail, new_node);
    }

    bool dequeue(T& result) {
        Node* old_head = nullptr;

        while (true) {
            old_head = head.load();
            Node* old_tail = tail.load();
            Node* next = old_head->next;

            if (old_head == head.load()) {
                if (old_head == old_tail) {
                    if (next == nullptr) {
                        return false;  // 队列空
                    }
                    std::atomic_compare_exchange_weak(&tail, &old_tail, next);
                } else {
                    result = next->data;
                    if (std::atomic_compare_exchange_weak(&head, &old_head, next)) {
                        break;
                    }
                }
            }
        }
        delete old_head;
        return true;
    }
};

void producer(LockFreeQueue<int>& queue) {
    for (int i = 0; i < 100; ++i) {
        queue.enqueue(i);
    }
}

void consumer(LockFreeQueue<int>& queue) {
    int value;
    for (int i = 0; i < 100; ++i) {
         while (!queue.dequeue(value)) {
                // Busy-wait until a value is dequeued
            }
            std::cout << "Consumed: " << value << std::endl;
        }
    }
}

int main() {
    LockFreeQueue<int> queue;

    std::thread prod1(producer, std::ref(queue));
    std::thread prod2(producer, std::ref(queue));
    std::thread cons1(consumer, std::ref(queue));
    std::thread cons2(consumer, std::ref(queue));

    prod1.join();
    prod2.join();
    cons1.join();
    cons2.join();

    return 0;
}

3.5 运行结果

由于输出顺序可能有所不同，以下是典型的输出结果示例：

Consumed: 0
Consumed: 1
Consumed: 2
...
Consumed: 99
Consumed: 0
Consumed: 1
...
Consumed: 99

3.6 核心点解析

无锁编程技术通过使用原子操作和正确的内存序来确保并发操作的安全性。std::atomic 提供了一种简单的方式来实现基本的无锁数据结构，而更复杂的数据结构（如无锁队列）则需要使用更复杂的原子操作和算法。

无锁编程的主要优势在于它避免了锁的开销，减少了线程间的阻塞和上下文切换。然而，实现无锁算法通常比锁机制更复杂，需要开发者深入理解硬件级的并发控制机制，如原子操作和内存屏障。此外，无锁编程并不能完全消除竞争条件，还需要特别注意数据结构的一致性和正确性。

无锁队列是一种典型的无锁数据结构，通过设计合理的算法和使用原子操作，可以有效地避免竞争条件和死锁问题。需要注意的是，无锁数据结构的设计往往比锁机制更复杂，并且更容易出错，因此在使用时需要仔细验证其正确性和性能。

4. 结合场景进行技术选择

在实际的多线程编程中，选择适当的并发控制技术至关重要。以下是几种常见的场景以及相应的技术选择建议：

简单的临界区保护：
如果只是保护简单的临界区，使用 std::lock_guard 是最为直接和安全的选择。它能够简化代码，并减少因忘记解锁而引发的死锁风险。
读多写少的场景：
如果读操作远多于写操作，使用 std::shared_mutex 这种读写锁可以显著提高性能。多个读线程可以并发执行，而写线程仍然能够确保数据的一致性。
高性能需求且争用严重：
在需要极高性能、且线程间争用严重的场景中，无锁编程技术可能是最佳选择。虽然无锁编程复杂且容易出错，但它能够避免锁的开销，减少线程阻塞，提升整体性能。
生产者-消费者模式：
这种模式非常适合使用无锁队列进行数据传递。生产者和消费者可以独立并行地工作，避免了锁带来的性能损耗。
需要细粒度锁控制：
在某些复杂的场景下，可能需要更细粒度的锁控制以优化性能。这时，可以结合使用条件变量、独占锁和共享锁，甚至是自定义的锁机制来进行精细化控制。