C++ 并发编程:无锁数据结构

最新推荐文章于 2023-09-29 21:02:05 发布
最新推荐文章于 2023-09-29 21:02:05 发布
阅读量2.3k 收藏 9
点赞数 3
分类专栏： C++ 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangdamingll/article/details/107178347
版权

一、无锁数据结构定义

1. 无锁数据结构
  1. 一个以上的线程必须能够同时访问该数据结构，他们不必执行相同的操作
  2. 当其中一个访问线程被调度器中途挂起时，其他线程必须能够继续完成自己的工作， 而无需等待挂起线程
2. 无等待数据结构
  1. 是一种无锁数据结
  2. 具有附加属性，即访问该数据结构的每个线程都可以在一定数量的步骤内完成其操作，而与其他线程的行为无关。因此，由于与其他线程的冲突而可能涉及无数次重试的算法并非没有等待时间。

二、无锁数据结构的利与弊

1. 无锁数据结构的利
  • 主要原因： 将并发最大化。
    使用基于锁的容器， 会让线程阻塞或等待； 互斥锁削弱了结构的并发性。 在无锁数据结构中， 某些线程可以逐步执行。 在无等待数据结构中， 无论其他线程当时在做什么， 每一个线程都可以转发进度。
  • 健壮性.
    如果线程在持有锁的同时死亡，那么该数据结构将永远被破坏。但是，如果线程在对无锁数据结构的操作中途中途死亡，则除了该线程的数据外，什么都不会丢失。其他线程可以正常进行。
  • 死锁活锁问题
    死锁问题不会困扰无锁数据结构; 无等待的代码不会被活锁所困扰,因其操作执行步骤是有上限的。
2. 无锁数据结构的弊

虽然提高了并发访问的能力， 减少了单个线程的等待时间， 但是其可能会将整体性能拉低。下面是原因:

  • 原子操作的无锁代码要慢于无原子操作的代码，原子操作就相当于无锁数据结构中的锁。
  • 不仅如此， 硬件必须通过同一个原子变量对线程间的数据进行同步。

三、设计无锁数据结构的指导建议

1. 使用std::memory_order_seq_cst的原型.

std::memory_order_seq_cst 比起其他内存序要简单的多，因为所有操作都将其作为总序。本章的所有例子，都是从 std::memory_order_seq_cst 开始，只有当基本操作正常工作的时候，才放宽内存序的选择。在这种情况下，使用其他内存序就是进行优化(早起可以不用这样做).

2. 对无锁内存的回收策略

这里与无锁代码最大的区别就是内存管理。当有其他线程对节点进行访问的时候，节点无法被任一线程删除；为避免过多的内存使用，还是希望这个节点在能删除的时候尽快删除。
有三种技术来保证内存可以被安全的回收：

  • 等待无线程对数据结构进行访问时，删除所有等待删除的对象。
  • 使用风险指针来标识正在被线程访问的对象。
  • 对对象进行引用计数，当没有线程对对象进行引用时，将其删除。

在所有例子中，主要的想法都是使用一种方式去跟踪指定对象上的线程访问数量，当没有现成对对象进行引用的时候，将对象删除。当然，在无锁数据结构中，还有很多方式可以用来回收内存。例如，理想情况下使用一个垃圾收集器。比起算法来说，其实现更容易一些。只需要让回收器知道，当节点没被引用的时候，回收节点，就可以了。

3. 小心ABA问题
  • "ABA问题"的产生
    循环使用节点，只在数据结构被销毁的时候才将节点完全删除。因为节点能被复用，那么就不会有非法的内存，所以这就能避免未定义行为的发生。这种方式的缺点：产生“ABA问题”.
    "ABA问题”在使用释放链表和循环使用节点的算法中很是普遍，而将节点返回给分配器，则不会引起这个问题。
  • 其流程是:
    线程1读取原子变量x，并且发现其值是A。
    线程1对这个值进行一些操作，比如，解引用(当其是一个指针的时候)，或做查询，或其他操作。
    操作系统将线程1挂起。
    其他线程对x执行一些操作，并且将其值改为B。
    另一个线程对A相关的数据进行修改(线程1持有)，让其不再合法。可能会在释放指针指向的内存时，代码产生剧烈的反应(大问题)；或者只是修改了相关值而已(小问题)。
    再来一个线程将x的值改回为A。如果A是一个指针，那么其可能指向一个新的对象，只是与旧对象共享同一个地址而已。
    线程1继续运行，并且对x执行“比较/交换”操作，将A进行对比。这里，“比较/交换”成功(因为其值还是A)，不过这是一个 错误的A ( the wrong A value )。从第2步中读取的数据不再合法，但是线程1无法言明这个问题，并且之后的操作将会损坏数据结构。
  • 解决ABA问题方法
    让变量x中包含一个ABA计数器。“比较/交换”会对加入计数器的x进行操作。每次的值都不一样，计数随之增长，所以在x还是原值的前提下，即使有线程对x进行修改，“比较/交换”还是会失败。
4. 识别忙等待循环和帮助其他线程

线程在执行push操作时，可能必须等待另一个push操作流程的完成。等待线程就会被孤立，将会陷入到忙等待循环中，当线程尝试失败的时候，会继续循环，这样就会浪费CPU的计算周期。当忙等待循环结束时，就像一个阻塞操作解除，和使用互斥锁的行为一样。通过对算法的修改，当之前的线程还没有完成操作前，让等待线程执行未完成的步骤，就能让忙等待的线程不再被阻塞。在队列中，需要将一个数据成员转换为一个原子变量，而不是使用非原子变量和使用“比较/交换”操作来做这件事；要是在更加复杂的数据结构中，这将需要更加多的变化来满足需求。

四、无锁数据结构的例子

1. 无锁栈

#include <iostream>
#include <atomic>
#include <memory>
#include <thread>
#include <chrono>
#include <random>

/*
使用无锁std::shared_ptr<>的实现:std::atomic_is_lock_free(&some_shared_ptr)返回true
*/

template<typename T>
class LockFreeStack
{
private:
    struct node
    {
        std::shared_ptr<T> data;
        std::shared_ptr<node> next;
        node(T const& data_) :
            data(std::make_shared<T>(data_))
        {}
    };
    std::shared_ptr<node> head;
public:
    void push(T const& data)
    {
        std::shared_ptr<node> const new_node = std::make_shared<node>(data);
        new_node->next = head;
        while (!std::atomic_compare_exchange_weak(
            &head, &new_node->next, new_node));
    }
    std::shared_ptr<T> pop()
    {
        std::shared_ptr<node> old_head = std::atomic_load(&head);
        while (old_head && !std::atomic_compare_exchange_weak(
            &head, &old_head, old_head->next));
        return old_head ? old_head->data : std::shared_ptr<T>();
    }
};

void PushThreadFun(LockFreeStack<int>& stack) {
    static thread_local int i = 1;
    std::random_device r;
    std::default_random_engine e(r());
    std::uniform_int_distribution<int> uniform_dist(1, 3);
    while (1) {
        std::cout << "PushThreadFun id:" << std::this_thread::get_id()<<" value:"<<i << std::endl;
        stack.push(i++);
        std::this_thread::sleep_for(std::chrono::seconds(uniform_dist(e)));
    }
}

void GetThreadFun(LockFreeStack<int>& stack) {
    while (1) {
        auto res = stack.pop();
        if (res.get() != nullptr) {
            std::cout << "GetThreadFun id:" << std::this_thread::get_id() << " value:" << *res << std::endl;
        }
    }
}

int main()
{
    LockFreeStack<int> stack;
    std::thread pushT1(PushThreadFun,std::ref(stack));
    std::thread pushT2(PushThreadFun, std::ref(stack));
    std::thread getT1(GetThreadFun, std::ref(stack));
    std::thread getT2(GetThreadFun, std::ref(stack));

    pushT1.join();
    pushT2.join();
    getT1.join();
    getT2.join();
    std::cout << "Hello World!\n";
}

#include <iostream>
#include <atomic>
#include <memory>
#include <thread>
#include <chrono>
#include <random>

template<typename T>
class LockFreeStack
{
private:
    struct node;
    struct counted_node_ptr
    {
        int external_count{0};
        node* ptr{nullptr};
    };
    struct node
    {
        std::shared_ptr<T> data;
        std::atomic<int> internal_count;
        counted_node_ptr next;
        node(T const& data_) :
            data(std::make_shared<T>(data_)),
            internal_count(0)
        {}
    };
    std::atomic<counted_node_ptr> head;
    void increase_head_count(counted_node_ptr& old_counter)
    {
        counted_node_ptr new_counter;
        do
        {
            new_counter = old_counter;
            ++new_counter.external_count;
        } while (!head.compare_exchange_strong(
            old_counter, new_counter,
            std::memory_order_acquire,
            std::memory_order_relaxed));
        old_counter.external_count = new_counter.external_count;
    }
public:
    ~LockFreeStack()
    {
        if (head.load(std::memory_order_relaxed).ptr != nullptr) {
            while (pop());
        }
    }
    void push(T const& data)
    {
        counted_node_ptr new_node;
        new_node.ptr = new node(data);
        new_node.external_count = 1;
        new_node.ptr->next = head.load(std::memory_order_relaxed);
            while (!head.compare_exchange_weak(
                new_node.ptr->next, new_node,
                std::memory_order_release,
                std::memory_order_relaxed));
    }
    std::shared_ptr<T> pop()
    {
        counted_node_ptr old_head =
            head.load(std::memory_order_relaxed);
        for (;;)
        {
            increase_head_count(old_head);
            node* const ptr = old_head.ptr;
            if (!ptr)
            {
                return std::shared_ptr<T>();
            }
            if (head.compare_exchange_strong(
                old_head, ptr->next, std::memory_order_relaxed))
            {
                std::shared_ptr<T> res;
                res.swap(ptr->data);
                int const count_increase = old_head.external_count - 2;
                if (ptr->internal_count.fetch_add(
                    count_increase, std::memory_order_release) == -count_increase)
                {
                    delete ptr;
                }
                return res;
            }
            else if (ptr->internal_count.fetch_add(
                -1, std::memory_order_relaxed) == 1)
            {
                ptr->internal_count.load(std::memory_order_acquire);
                delete ptr;
            }
        }
    }
};

void PushThreadFun(LockFreeStack<int>& stack) {
    static thread_local int i = 1;
    std::random_device r;
    std::default_random_engine e(r());
    std::uniform_int_distribution<int> uniform_dist(1, 3);
    while (1) {
        std::cout << "PushThreadFun id:" << std::this_thread::get_id()<<" value:"<<i << std::endl;
        stack.push(i++);
        std::this_thread::sleep_for(std::chrono::seconds(uniform_dist(e)));
    }
}

void GetThreadFun(LockFreeStack<int>& stack) {
    while (1) {
        auto res = stack.pop();
        if (res.get() != nullptr) {
            std::cout << "GetThreadFun id:" << std::this_thread::get_id() << " value:" << *res << std::endl;
        }
    }
}

int main()
{
    LockFreeStack<int> stack;
    std::thread pushT1(PushThreadFun,std::ref(stack));
    std::thread pushT2(PushThreadFun, std::ref(stack));
    std::thread getT1(GetThreadFun, std::ref(stack));
    std::thread getT2(GetThreadFun, std::ref(stack));

    pushT1.join();
    pushT2.join();
    getT1.join();
    getT2.join();
}

2. 无锁队列

#include <iostream>

#include <memory>
#include <atomic>
#include <thread>
#include <chrono>
#include <random>

/*
“单生产者，单消费者”(single-producer,single-consumer SPSC)队列
*/

template<typename T>
class LockFreeQueue
{
private:
    struct node
    {
        std::shared_ptr<T> data;
        node* next;
        node() :
            next(nullptr)
        {}
    };
    std::atomic<node*> head;
    std::atomic<node*> tail;
    node* pop_head()
    {
        node* const old_head = head.load();
        if (old_head == tail.load()) // 1
        {
            return nullptr;
        }
        head.store(old_head->next);
        return old_head;
    }
public:
    LockFreeQueue() :
        head(new node), tail(head.load())
    {}
    LockFreeQueue(const LockFreeQueue& other) = delete;
    LockFreeQueue& operator=(const LockFreeQueue& other) = delete;
    ~LockFreeQueue()
    {
        while (node* const old_head = head.load())
        {
            head.store(old_head->next);
            delete old_head;
        }
    }
    std::shared_ptr<T> pop()
    {
        node* old_head = pop_head();
        if (!old_head)
        {
            return std::shared_ptr<T>();
        }
        std::shared_ptr<T> const res(old_head->data);  
        delete old_head;
        return res;
    }
    void push(T new_value)
    {
        std::shared_ptr<T> new_data(std::make_shared<T>(new_value));
        node* p = new node; 
        node* const old_tail = tail.load(); 
        old_tail->data.swap(new_data); 
        old_tail->next = p;  
        tail.store(p);
    }
};

void PushThreadFun(LockFreeQueue<int>& queue) {
    static thread_local int i = 1;
    std::random_device r;
    std::default_random_engine e(r());
    std::uniform_int_distribution<int> uniform_dist(1, 3);
    while (1) {
        std::cout << "PushThreadFun id:" << std::this_thread::get_id() << " value:" << i << std::endl;
        queue.push(i++);
        std::this_thread::sleep_for(std::chrono::seconds(uniform_dist(e)));
    }
}

void GetThreadFun(LockFreeQueue<int>& queue) {
    while (1) {
        auto res = queue.pop();
        if (res.get() != nullptr) {
            std::cout << "GetThreadFun id:" << std::this_thread::get_id() << " value:" << *res << std::endl;
        }
    }
}

int main()
{
    LockFreeQueue<int> queue;
    std::thread pushT(PushThreadFun, std::ref(queue));
    std::thread getT(GetThreadFun, std::ref(queue));

    pushT.join();
    getT.join();
}
A鱼翔浅底A
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【并发编程十五】无锁数据结构（1）——无锁栈
junxuezheng的博客
02-06 2788
栈容器能加入数据，然后按逆序取出——先进后出（后进先出——last in,fist out,LIFO).因此，我们必须保证，一旦某线程将一项数据加入栈容器，就能立即安全的被另一个线程取出，同时还得保证，只有唯一一个线程能获取该项数据。最简单的栈容器可以通过链表的形式实现：指针head指向第一个节点，各节点内的next成员指针再依次指向后继节点。
第22课：实现无锁数据结构，让多线程应用更快更稳定
yubo112002的专栏
09-22 162
在本节课中，我们要讨论的是无锁编程。我们会通过对基本无锁数据结构设计思路的介绍，来帮助读者入门无锁编程，主要包括以下几部分内容： 无锁编程概述 简单一对一无锁队列 关于指令顺序 22.1 无锁编程概述 免费的午餐早已经结束，多线程编程已经成为当代系统开发者的一项基本技能。在《第12课：掌握线程同步，让复杂工作流协调有序》中，我们介绍了很多种线程间同步的锁方法，它们能很好地解决多个并行线程间协调...
C++ 并发编程实战 第七章 设计无锁数据结构
最新发布
qq_52758467的博客
09-29 455
使用互斥量、条件变量，以及future可以用来同步算法和数据结构。调用库函数将会挂起执行线程，直到其他线程完成某个特定动作。库函数将调用阻塞操作来对线程进行阻塞，在阻塞解除前线程无法继续自己的任务。通常，操作系统会完全挂起一个阻塞线程(并将其时间片交给其他线程)，直到解阻塞。“解阻塞”的方式很多，比如互斥锁解锁、通知条件变量达成，或让“future状态”就绪。
C++游戏编程:创建3D游戏依赖库
09-02
C++游戏编程:创建3D游戏依赖库 C++游戏编程:创建3D游戏依赖库 C++游戏编程:创建3D游戏依赖库
C++11并发编程:多线程std::thread
08-26
今天小编就为大家分享一篇关于C++11并发编程:多线程std::thread，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C++高效编程：内存与性能优化(pdf版）
09-11
C++高效编程：内存与性能优化(pdf版），深入C++经典好书！
C++并发编程实战:示例源源码
06-14
C++并发编程实战 示例源源码 (C++ Concurrency in Action)
无锁数据结构一
紫无之紫的博客
11-13 870
lock-free本文对lock-free进行介绍，主要介绍原子性操作，下一篇介绍内存访问控制什么是lock-free 无锁数据结构无锁数据结构的实现主要基于两个方面：原子性操作和内存访问控制方法。下面先记录原子性操作相关知识。原子性操作原子性操作可以简单地分为读写（read and write）、原子性交换操作（read-modify-write，RMW）两部分。原子操作可认为是
C++并发编程（七）无锁数据结构
CSSS_2021的博客
03-03 1128
《C++并发编程实战》笔记
无锁(lock-free)数据结构
daidodo的专栏
02-17 6470
提到并行计算通常都会想到加锁，事实却并非如此，大多数并发是不需要加锁的。比如在不同电脑上运行的代码编辑器，两者并发运行不需要加锁。在一台电脑上同时运行的媒体播放放器和代码编辑器，两者并发运行不需要加锁(当然系统调用和进程调度是要加锁的)。在同一个进程中运行多个线程，如果各自处理独立的事情也不需要加锁(当然系统调用、进程调度和内存分配是要加锁的)。在以上这些情况里，各个并发实体之间没有共享数据，所以
《C++ Concurrencyin Action》第7章--无锁并发数据结构设计
qq_23350817的博客
07-12 719
本章主要内容：1、设计无锁并发数据结构2、无锁结构中内存管理技术3、对无锁数据结构设计的简单指导上一章中，我们了解了在设计并发数据结构时会遇到的问题，根据指导意见指引，确定设计的安全性。对一些通用数据结构进行检查，并查看使用互斥锁对共享数据进行保护的实现例子。第一组例子就是使用单个互斥量来保护整个数据结构，但之后的例子就会使用多个锁来保护数据结构的不同部分，并且允许对数据结构进行更高级别的并发访问。互斥量是一个强大的工具，其可以保证在多线程情况下可以安全的访问数据结构，并且不会有条件竞争或破坏不变量的情况存
数据结构——栈与队列（特详解），不会我亲自教你！！！
weixin_52439435的博客
04-15 2638
启示： 栈与队列 栈是限定仅在表位进行插入和删除操作的线性表 队列是只允许在一段进行插入操作，而在另一端进行删除操作的线性表 一、栈的定义 在我们软件应用中，栈这种先进先出的数据结构的应用是非常普遍的。比如你用手机浏览器上网时，不管什么浏览器都有一个“后退”键，你点击后可以按访问顺序的逆序加载浏览过的网页，比如你本来看着新闻好好的，突然看到一个链接说，有一个可以让你年薪100万的工作，你毫不犹豫点击它，跳转进去一看，这是啥呀，具体内容我也就不说了，骗人骗得一点水平都没有。此时你还想回去继续看新闻，就可以.
数据结构—树与二叉树(Part Ⅳ)—二叉树的遍历(递归&非递归)
Miss Z的博客
08-28 546
数据结构-树与二叉树(第七章)的整理笔记，若有错误，欢迎指正。 树、森林
《c++并发编程实战解析》 无锁数据结构 doubly-buffered-data
kdb_viewer的博客
05-22 1059
多线程环境设计数据结构相比单线程，需要额外注意的是利用多线程提升并发度同时保持数据结构不变性，即满足如下两个原则： 1、正确性，保证多线程并发访问没有 data race 2、性能，保护最小的数据，提供最大的性能 《c++并发编程实战》提供了一种【无锁数据结构】，注意这里无锁的含义不是真正无锁，而是利用数据结构特性保证运行时并发抢锁的线程数量最小，达到一种常态下访问数据结构不被锁阻塞的状态 使用场景： 1、读远多于写 2、数据小，一般最大为几K字节的元数据 3、数据可以应用到一致性状态机，即b
c++ 高并发队列的实现
BBinChina的专栏
09-11 1883
JAVA如何进行CAS 讲到java的队列时，讲到java中的CAS操作 回顾下java中的cas，主要采用compareAndSet方法，如AtomicReference中所使用的： AtomicRefrence.java /** * Atomically sets the value to the given updated value * if the current value {@code ==} the expected value. * @param expect
Java并发编程中锁的正确使用方法
燕然一勒的博客
12-23 761
有需要的可以先去看看这篇操作系统教材上关于死锁的知识：操作系统 关于死锁的面试题 死锁的必要条件有四个，只要破坏其中一个，就可避免死锁。 互斥条件：在一段时间内，某资源只能被一个进程占用 请求和保持条件：进程已保持了资源，又提出了新的资源请求，而该资源已被其他进程占有，此时该进程阻塞，但不释放已持有的资源 不可抢占条件：进程已经获得的资源，在未使用完之前不能被抢占，只能等该进程使用完后自己释放 循环等待条件：发生死锁时，存在一个进程-资源循环链，1等2，2等3，...... 那么在Java中，具体
JUC并发编程17 | synchronized锁升级
为了远大的理想，冲锋！
05-12 507
谈谈你对 Synchronized 的理解synchronized 的锁升级高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能所区块，就不要所整个方法体；能用对象锁，就不要用类锁。尽可能使加锁的代码工作量尽可能小，避免在所代码中调用RPC方法。synchronized 可以实现数据的安全，但是会带来性能的下降。锁升级的过程：无锁、偏向锁、轻量级锁（cas等），重量级锁（synchronized）synchronized锁升级过程总结:一句话，就是先自旋，不行再阻塞。
juc并发编程入门（二）
qq_21277357的博客
01-15 123
asdaasd
无锁数据结构 ---- 栈实现
子居的博客
06-21 1147
无锁数据结构，即不使用任何锁机制实现可以多线程并发访问的数据结构。相比较有锁数据结构有如下优缺点：实现无锁数据结构，最好不要一开始就直接想着去如何实现无锁数据结构，因为这样能难考虑全面，可以以最简单的单线程栈开始，然后慢慢修改成无锁栈，下面以最简单的单线栈开始。
如何学习C++无锁编程
05-19
学习C++无锁编程，需要具备一定的C++编程基础和多线程编程经验。以下是一些学习C++无锁编程的步骤： 1. 了解无锁编程的概念和原理。无锁编程是一种多线程编程技术，目的是为了避免线程之间的竞争和锁的开销，提高程序的性能。需要了解无锁编程的基本原理，例如CAS操作、ABA问题等。 2. 学习C++11/14/17中的原子操作库。C++11/14/17中新增了原子操作库，提供了对内存原子性操作的支持，可以用于实现无锁编程。需要了解原子操作库中的各种API，例如std::atomic、std::atomic_flag等。 3. 学习无锁数据结构的实现。无锁编程常用于实现无锁数据结构，例如无锁队列、无锁哈希表等。需要了解如何使用原子操作库实现这些数据结构，并了解它们的特点和优劣。 4. 实践编写无锁代码。学习无锁编程最好的方式就是实践编写无锁代码。可以从简单的例子开始，例如使用原子操作实现计数器，逐步深入学习，最终可以实现复杂的无锁算法和数据结构。 5. 学习无锁编程的最佳实践。无锁编程是一种高难度的编程技术，需要注意一些细节问题，例如ABA问题、内存屏障的使用等。需要了解无锁编程的最佳实践，并注意代码的正确性和可读性。 总之，学习C++无锁编程需要具备扎实的C++编程基础和多线程编程经验，需要不断地学习和实践。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值