std::atomic 对指针进行运算的用途

std::atomic 提供了一种在多线程环境中安全地操作指针的方法。这对于实现线程安全的指针管理、动态内存分配、链表操作等场景非常有用。通过使用std::atomic对指针进行运算，可以确保指针操作的原子性和多线程安全性。

常见用途

1. 线程安全的指针管理：在多线程环境下，安全地分配和释放内存。
2. 链表操作：安全地插入和删除链表节点。
3. 同步数据结构：实现线程安全的数据结构，如队列、栈等。
4. 原子指针的自增和自减：用于实现计数器或迭代器。

示例代码

以下是一些使用std::atomic对指针进行操作的示例代码。

1. 线程安全的动态内存管理

#include <iostream>
#include <thread>
#include <atomic>
#include <vector>std::atomic<int*> shared_ptr(nullptr);void thread_func() {int* local_ptr = new int(42);std::atomic_store(&shared_ptr, local_ptr); // 原子地存储指针int* loaded_ptr = std::atomic_load(&shared_ptr); // 原子地加载指针if (loaded_ptr != nullptr) {std::cout << "Loaded value: " << *loaded_ptr << std::endl;delete loaded_ptr;}
}int main() {std::vector<std::thread> threads;for (int i = 0; i < 10; ++i) {threads.emplace_back(thread_func);}for (auto& t : threads) {t.join();}return 0;
}

代码说明

1. shared_ptr：一个std::atomic<int*>类型的原子指针，用于在多线程之间共享指针。
2. thread_func：
   • 创建一个局部指针local_ptr，并使用std::atomic_store原子地将指针存储到shared_ptr中。
   • 使用std::atomic_load原子地从shared_ptr中加载指针，并在使用后删除指针。
3. main：
   • 创建多个线程，每个线程执行thread_func。
   • 等待所有线程完成。

2. 线程安全的链表操作

#include <iostream>
#include <thread>
#include <atomic>
#include <memory>struct Node {int data;std::atomic<Node*> next;Node(int value) : data(value), next(nullptr) {}
};std::atomic<Node*> head(nullptr);void insert_node(int value) {Node* new_node = new Node(value);Node* current_head = std::atomic_load(&head);while (true) {new_node->next = current_head;if (std::atomic_compare_exchange_weak(&head, &current_head, new_node)) {break; // 插入成功}}
}void print_list() {Node* current = std::atomic_load(&head);while (current != nullptr) {std::cout << current->data << " -> ";current = current->next.load();}std::cout << "nullptr" << std::endl;
}void delete_list() {Node* current = std::atomic_load(&head);while (current != nullptr) {Node* next = current->next.load();delete current;current = next;}std::atomic_store(&head, nullptr);
}int main() {std::vector<std::thread> threads;for (int i = 0; i < 10; ++i) {threads.emplace_back(insert_node, i);}for (auto& t : threads) {t.join();}print_list();delete_list();return 0;
}

代码说明

1. Node 结构体：表示链表节点，包含一个整数data和一个原子指针next。
2. head：一个std::atomic<Node*>类型的原子指针，用于表示链表的头部。
3. insert_node：
   • 创建一个新节点new_node。
   • 使用std::atomic_load和std::atomic_compare_exchange_weak原子地将新节点插入链表头部。
4. print_list：遍历链表并打印节点值。
5. delete_list：遍历链表并删除所有节点。
6. main：
   • 创建多个线程，每个线程插入一个节点。
   • 等待所有线程完成。
   • 打印链表。
   • 删除链表。

总结

通过使用std::atomic对指针进行操作，可以确保多线程环境下指针操作的原子性和安全性。这在动态内存管理、链表操作和其他需要同步的场景中非常有用。std::atomic提供了多种原子操作，如load、store、compare_exchange_weak等，这些操作可以确保在多线程环境下安全地进行指针操作。