微服务设计原则——高性能：锁

文章目录

• 1.锁的问题
• 2.无锁
• • 2.1 串行无锁
  • 2.2 无锁数据结构
  • 3.减少锁竞争
  • 参考文献

    1.锁的问题

    高性能系统中使用锁，往往带来的坏处要大于好处。

    并发编程中，锁带解决了安全问题，同时也带来了性能问题，因为锁让并发处理变成了串行操作，所以如无必要，尽量不要显式使用锁。

    锁和并发，貌似有一种相克相生的关系。

    

    为了避免严重的锁竞争导致性能的下降，有些场景采用了无锁化设计，特别是在底层框架上。无锁化主要有两种实现，无锁队列和无锁数据结构。

    2.无锁

    2.1 串行无锁

    串行无锁最简单的实现方式可能就是单线程模型了，如 Redis 6.0 之前采用了这种方式。但是这种方式利用不了 CPU 多核的优势，所以在网络编程模型中，常用的是单 Reactor 多线程模型。

    单 Reactor 多线程模型中，主线程负责处理 I/O 事件，并将读到的数据压入队列，工作线程则从队列中取出数据进行处理，多线程从队列获取数据时需要对队列加锁。如下图所示：

    

    上图的模式可以改成串行无锁的形式，当 MainReactor accept 一个新连接之后从众多的 SubReactor 选取一个进行注册，通过创建一个 Queue 与 I/O 线程进行绑定，此后该连接的读写都在同一个队列和线程中执行，无需对队列加锁。这种模型叫主从 Reactor 多线程模型。

    

    2.2 无锁数据结构

    利用硬件支持的原子操作可以实现无锁的数据结构，很多语言都提供CAS原子操作（如 Go 中的 atomic 包和 C++11 中的 atomic 库），可以用于实现无锁数据结构，如无锁链表。

    我们以一个简单的线程安全单链表的插入操作来看下无锁编程和普通加锁的区别。

    template
    struct Node {
        Node(const T &value) : data(value) {}
        T data;
        Node *next = nullptr;
    };
    

    有锁链表 WithLockList：

    template
    class WithLockList {
        mutex mtx;
        Node *head;
    public:
        void pushFront(const T &value) {
            auto *node = new Node(value);
            lock_guard lock(mtx); // (1)
            node->next = head;
            head = node;
        }
    };
    

    无锁链表 LockFreeList：

    template
    class LockFreeList {
        atomic head;
    public:
        void pushFront(const T &value) {
            auto *node = new Node(value);
            node->next = head.load();
            while(!head.compare_exchange_weak(node->next, node)); // (2)
        }
    };
    

    从代码可以看出，在有锁版本中 (1) 进行了加锁。在无锁版本中，(2) 使用了原子 CAS 操作 compare_exchange_weak，该函数如果存储成功则返回 true，同时为了防止伪失败（即原始值等于期望值时也不一定存储成功，主要发生在缺少单条比较交换指令的硬件机器上），通常将 CAS 放在循环中。

    下面对有锁和无锁版本进行简单的性能比较，分别执行 1000,000 次push操作。测试代码如下：

    int main() {
        const int SIZE = 1000000;
        //有锁测试
        auto start = chrono::steady_clock::now();
        WithLockList wlList;
        for(int i = 0; i