C++11实现自旋锁

最新推荐文章于 2024-09-28 11:05:17 发布
最新推荐文章于 2024-09-28 11:05:17 发布
阅读量1.4w 收藏 39
点赞数 8
分类专栏： 服务器

http://blog.poxiao.me/p/spinlock-implementation-in-cpp11/

自旋锁(Spinlock)

自旋锁是一种用于保护多线程共享资源的锁，与一般的互斥锁(mutex)不同之处在于当自旋锁尝试获取锁的所有权时会以忙等待(busy waiting)的形式不断的循环检查锁是否可用。在多处理器环境中对持有锁时间较短的程序来说使用自旋锁代替一般的互斥锁往往能提高程序的性能。

自旋锁的原理

自旋锁有两种基本状态：

  1. 锁定状态
    锁定状态又称不可用状态，当自旋锁被某个线程持有时就是锁定状态，在自旋锁被释放之前其他线程不能获得锁的所有权。
  2. 可用状态
    当自选锁未被任何线程持有时的状态就是可用状态。

假设某自旋锁内部使用bool类型的flag变量来标识自旋锁的状态。当flag为true表示锁定状态，为false表示可用状态。
获取自旋锁的一种可行的流程如下

其中灰色方框中的3步应是一个不可分割的原子操作。
释放自旋锁时只需以原子操作的形式将flag置为false。

使用C++11的原子操作实现自旋锁

C++11提供了对原子操作的支持，其中std::atomic是标准库提供的一个原子类模板。可以这样来声明一个自旋锁互斥对象spin_mutex。

1
2
3
4
5
6
7
8
9
10
11
 
#include <atomic>

class spin_mutex {
  std::atomic<bool> flag = ATOMIC_VAR_INIT(false);
public:
  spin_mutex() = default;
  spin_mutex(const spin_mutex&) = delete;
  spin_mutex& operator= (const spin_mutex&) = delete;
  void lock(); // 获取自旋锁
  void unlock(); // 释放自旋锁
};

对于lock函数，若根据前面的流程图来实现，需要CAS(compare and swap)的原子操作，可以使用std::atomic类模板的成员函数compare_exchange_strong。该成员函数的4个重载(overload)声明如下

1
2
3
4
5
6
7
8
9
10
 
bool compare_exchange_strong(T& expected, T desired,
                              std::memory_order success,
                              std::memory_order failure); // overload 1
bool compare_exchange_strong(T& expected, T desired,
                              std::memory_order success,
                              std::memory_order failure) volatile; // overload 2
bool compare_exchange_strong(T& expected, T desired,
                              std::memory_order order = std::memory_order_seq_cst); // overload 3
bool compare_exchange_strong(T& expected, T desired,
                              std::memory_order order = std::memory_order_seq_cst) volatile; // overload 4

compare_exchange_strong能够自动比较*this与expected的值，如果二者相等,会将*this的值修改为desired的值(执行read-modify-write操作)，否则将expected的值修改为*this的值。
当*this被改变时compare_exchange_strong返回true,否则返回false。
这4个重载中还有3个类型为std::memory_order的参数，这些参数用于指定内存序(memory order)，对内存序的介绍超出了本文的范围，之后会在《C++11之多线程(五、内存序(Memory Order)）》中较为详细的介绍，这里仅做简单介绍。
简单的讲就是程序的内存访问顺序在编译期(代码优化)和运行期(CPU的乱序执行)可能会被重新排序，这种重新排序往往是为了提高程序的执行速度，并且在单处理器的情况下这种重新排序不会对程序的正确性产生影响，但在多处理器的多线程环境中就可能得到非预期的结果。memory order就是用来指定原子操作周围(指前后)的非原子操作的内存访问如何被排序和同步。std::memory_order_seq_cst是标准库中原子操作内存序的默认值，这是最为严格的memory order对性能有一定的损害，若不苛求性能可以总是使用这个值。
简单介绍完了memory order再回到compare_exchange_strong的函数声明中来。
在重载1和2中success参数用于指定当比较成功(*this与expected值相等时)执行read-modify-write操作的内存序，failure参数用于指定当比较失败时执行load操作的内存序。
在重载3和4中order参数同时指定sccuess和failure时的内存序。
下面两种调用方式是等价的。

1
2
 
flag.compare_exchange_strong(expected, desired, order);
flag.compare_exchange_strong(expected, desired, order, order);

对于unlock函数，可以使用std::atomic类模板的成员函数store来以原子操作的方式将flag置false。

1
2
 
void store(T desired, memory_order = std::memory_order_seq_cst);
void store(T desired, memory_order = std::memory_order_seq_cst) volatile;

使用默认内存序的自旋锁完整的实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class spin_mutex {
  std::atomic<bool> flag = ATOMIC_VAR_INIT(false);
public:
  spin_mutex() = default;
  spin_mutex(const spin_mutex&) = delete;
  spin_mutex& operator= (const spin_mutex&) = delete;
  void lock() {
    bool expected = false;
    while(!flag.compare_exchange_strong(expected, true))
      expected = false;
  }
  void unlock() {
    flag.store(false);
  }
};

下面的代码演示了使用自旋锁保护变量num

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
int num = 0;
spin_mutex sm;

void thread_proc()
{

  for(int i = 0; i < 100000; ++i) {
    sm.lock();
    ++num;
    sm.unlock();
  }
}

int main()
{
  std::thread td1(thread_proc), td2(thread_proc);
  td1.join();
  td2.join();
  std::cout << num << std::endl;
  return 0;
}

指定内存序提高性能

通过指定内存序代替默认的std::memory_order_seq_cst可以提高性能。C++11的std::memory_order有6个枚举值。

Value描述
std::memory_order_relaxed没有任何同步和排序限制，只需保证操作是原子的。
std::memory_order_consume一个指定了此值的load操作在受影响的内存位置上执行consume操作，此操作使得另一个在同一内存位置执行了release操作的线程在此之前对数据依赖(data-dependent)的内存位置的写操作为当前线程可见。 
std::memory_order_acquire一个指定了此值的load操作在受影响的内存位置上执行acquire操作，此操作使得另一个在同一内存位置执行了release操作的线程在此之前对任意的内存位置的写操作为当前线程可见。
std::memory_order_release一个指定了此值的store操作在受影响的内存位置上执行release操作，此操作使得此线程之前对数据依赖(data-dependent)的内存位置的写操作为另一个在此之后通过对同一内存位置执行consume操作的线程可见，使得此线程之前对任意的内存位置的写操作为另一个在此之后通过对同一个内存位置执行acquire操作的线程可见。
std::memory_order_acq_rel一个指定了此值的read-modify-write操作，在读阶段(相当于load)对受影响的内存位置执行acquire操作，在写阶段(相当于store)对同一内存位置执行release操作。
std::memory_order_seq_cst顺序一致性，所有的线程观察到的整个程序中内存修改顺序是一致的。

在指定memory order前需要明确自旋锁的责任:自旋锁除了要避免多线程重入，还要保证一个线程在持有自旋锁期间对内存的写操作要能够被另一个线程在获得自旋锁的时候可观测到(可见)。
对照前面memory order枚举值的表，优先考虑性能。可以在unlock中对flag调用store置false的执行release操作。而在lock中对flag调用compare_exchange_strong的时候执行acquire操作。
使用Rlease-Acquire内存序的自旋锁的完整实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class spin_mutex {
  std::atomic<bool> flag = ATOMIC_VAR_INIT(false);
public:
  spin_mutex() = default;
  spin_mutex(const spin_mutex&) = delete;
  spin_mutex& operator= (const spin_mutex&) = delete;
  void lock() {
    bool expected = false;
    while(!flag.compare_exchange_strong(expected, true, std::memory_order_acquire))
      expected = false;
  }
  void unlock() {
    flag.store(false, std::memory_order_release);
  }
};

其中flag.compare_exchange_strong(expected, true, std::memory_order_acquire)等价于flag.compare_exchange_strong(expected, true, std::memory_order_acquire, std::memory_order_acquire)。获得自旋锁的所有权的充分必要条件是当且仅当compare_exchange_strong比较成功且成功改变flag的值为true，也就是说当比较失败时是没有必要执行acquire操作的。
于是lock函数可以再修改成

1
2
3
4
5
 
void lock() {
  bool expected = false;
  while(!flag.compare_exchange_strong(expected, true, std::memory_order_acquire, std::memory_order_relaxed))
    expected = false;
}

不使用CAS(compare-and-swap)的实现

前面的CAS实现中lock函数中的原子操作需要3个步骤:

  1. 取flag的值；
  2. 比较flag的值；
  3. 置flag一个新值。

由于自旋锁只有两个状态，事实上获取自旋锁可以使用下面的流程


其中灰色矩形中的2步应是一个不可分割的原子操作:

  1. 取flag的值;
  2. 置flag一个新值。

这样就将原子操作中需要做的3步减少到2步了。
std::atomic类模板的exchange成员函数能够以原子的方式对其进行赋值并返回旧值。

1
2
 
T exchange(T desired, memory_order = std::memory_order_seq_cst);
T exchange(T desired, memory_order = std::memory_order_seq_cst) volatile;

使用exchange实现的自旋锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class spin_mutex {
  std::atomic<bool> flag = ATOMIC_VAR_INIT(false);
public:
  spin_mutex() = default;
  spin_mutex(const spin_mutex&) = delete;
  spin_mutex& operator= (const spin_mutex&) = delete;
  void lock() {
    while(flag.exchange(true, std::memory_order_acquire))
      ;
  }
  void unlock() {
    flag.store(false, std::memory_order_release);
  }
};

使用std::atomic_flag的实现

C++11并不要求std::atomic的实现必须是无锁的(lock-free)，可以通过使用std::atomic类模板的成员函数is_lock_free来检查atomic对象是不是无锁的。如果自旋锁内部的flag不是无锁的类型那么这个自旋锁就没有存在的意义了。所幸C++11提供了一个无锁的二值(bool)原子类型std::atomic_flag。使用std::atomic_flag就可以实现一个真正有用的自旋锁了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class spin_mutex {
  std::atomic_flag flag = ATOMIC_FLAG_INIT;
public:
  spin_mutex() = default;
  spin_mutex(const spin_mutex&) = delete;
  spin_mutex& operator= (const spin_mutex&) = delete;
  void lock() {
    while(flag.test_and_set(std::memory_order_acquire))
      ;
  }
  void unlock() {
    flag.clear(std::memory_order_release);
  }
};

与标准库的std::mutex一样这里实现的spin_mutex同样不建议直接去调用lock和unlock函数，而推荐使用std::lock_guard来自动管理自旋锁。完整的实现和使用代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
#include <atomic>
#include <thread>
#include <mutex>
#include <iostream>

class spin_mutex {
  std::atomic_flag flag = ATOMIC_FLAG_INIT;
public:
  spin_mutex() = default;
  spin_mutex(const spin_mutex&) = delete;
  spin_mutex& operator= (const spin_mutex&) = delete;
  void lock() {
    while(flag.test_and_set(std::memory_order_acquire))
      ;
  }
  void unlock() {
    flag.clear(std::memory_order_release);
  }
};

int num = 0;
spin_mutex sm;

void thread_proc()
{

  for(int i = 0; i < 100000; ++i) {
    std::lock_guard<spin_mutex> lock(sm);
    ++num;
  }
}

int main()
{
  std::thread td1(thread_proc), td2(thread_proc);
  td1.join();
  td2.join();
  std::cout << num << std::endl;
  return 0;
}
嘎嘎嘎498451
关注
专栏目录
C++实现自旋锁
CyberJolt的博客
09-07 409
自旋锁适用于临界区的保护时间较短，且线程占用锁的时间较短的情况。自旋锁在某些情况下可以提供较低的开销和较高的性能，但在长时间的自旋等待情况下可能会浪费CPU资源。自旋锁是多线程编程中一种常见的同步机制，用于保护临界区，避免多个线程同时访问共享资源造成的竞态条件。在本文中，我们将详细介绍如何在C++中实现一个简单的自旋锁，并提供相应的源代码。方法用于获取锁，如果锁已被其他线程占用，则会进入自旋等待，直到锁可用。提供了原子操作，确保了多线程环境下的操作的原子性。在上面的代码中，我们使用了C++11中的。
自旋锁的应用
cenchure的专栏
11-27 1835
通常自旋锁分三种： 纯自旋，队列自旋锁和MCS 锁。 MCS 锁也是基于队列自旋锁的。 但最基本的还是纯自旋锁了。  自旋锁使用场景：   1. 通常在一些需要短暂等待的情况下被使用。通常用sleep（0）  也可以办到，但sleep无法控制不切换上下文。   2. 当多线程锁使用。通常系统底层用来同步多个CPU访问。 纯自旋锁实现如下： class Spin
C++11 实现自旋锁
pulata的博客
11-22 378
C++11 实现自旋锁
详解自旋锁
最新发布
努力学习游泳的鱼的博客
09-28 882
自旋锁（Spinlock）是一种用于保护临界区的同步机制，其主要特点是通过循环检测锁的状态来避免线程或进程的阻塞。在自旋锁的实现中，当一个线程尝试获取已被其他线程占用的锁时，它不会进入睡眠状态，而是持续循环检查锁的状态，直到锁被释放为止。自旋锁在Linux内核中得到了广泛应用，特别是在中断处理和设备驱动程序中。Linux内核提供了多种自旋锁API，如spin_lock、spin_lock_irqsave等，用于不同场景下的锁操作。
C++11 自旋锁Spinlock
weixin_34092370的博客
12-09 1859
为什么80%的码农都做不了架构师？>>> ...
使用C++11原子量实现自旋锁
weixin_34185320的博客
06-11 598
一、自旋锁 自旋锁是一种基础的同步原语，用于保障对共享数据的互斥访问。与互斥锁的相比，在获取锁失败的时候不会使得线程阻塞而是一直自旋尝试获取锁。当线程等待自旋锁的时候，CPU不能做其他事情，而是一直处于轮询忙等的状态。自旋锁主要适用于被持有时间短，线程不希望在重新调度上花过多时间的情况。实际上许多其他类型的锁在底层使用了自旋锁实现，例如多数互斥锁在试图获取锁的时候会先自旋一小段时间，然后才会休眠。...
C++11 自旋锁简单实现
好好学习，天天向上~
11-16 2096
C++11 自旋锁简单实现前言一、自旋锁1.自旋锁实现2.测试 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、自旋锁 1.自旋锁实现 自旋锁简单实现代码如下： class SpinlLock{ atomic_flag flg; public: void lock(){ while(flg
利用C++11原子量如何实现自旋锁详解
12-26
实际上许多其他类型的锁在底层使用了自旋锁实现，例如多数互斥锁在试图获取锁的时候会先自旋一小段时间，然后才会休眠。如果在持锁时间很长的场景下使用自旋锁，则会导致CPU在这个线程的时间片用尽之前一直消耗在无...
C++11实现一个读写自旋锁-1
moter的专栏
12-16 1800
本文介绍两种使用自旋锁方式实现读写锁的方案。 方案一 基本原理是使用一个原子变量作为计数器，如果该计数器的值大于0，说明有读者在持有读锁，它的值就是读者的数量，当计数器的值为-1时，说明有写者在持有写锁，如果计数器的值为0，则说明既没有读者持有读锁，也没有写锁持有写锁。所提供的接口有申请读锁，尝试申请读锁，释放读锁，申请写锁，尝试申请写锁，释放写锁等。 定义读写锁rw_spin_lock类如下，它包含一个atomic_int类型的数据成员和六个申请锁、释放锁的成员函数，没有拷贝和移动语义。在实现时，要注意申
无锁编程之自旋锁的C++实现
05-16
根据《多处理器编程的艺术》一书第七章“自旋锁与争用”编写的C++代码，演示了10种锁的实现。代码为本人学习研究所用，欢迎高手赐教。
C++11原子量实现自旋锁
C/C++Linux、音视频、DPDK
11-01 339
首先，我们需要一个bool值来表示锁的状态，这里直接使用标准库中的原子量 atomic (C++ 11的原子量可以参考：https://www.cnblogs.com/FateTHarlaown/p/8919235.html) ，在我的平台（Cygwin64、GCC7.3）上 atomic 的成员函数is_lock_free（）返回值为true，是无锁的实现（如果内部使用了锁来实现的话那还叫什么自旋锁 = =）。当V的值与A相等时，将V与B的值交换。需要强调的是上面的操作是原子的，要么不做，要么全部完成。
c++11 原子操作实现自旋锁
BJUT_bluecat的博客
05-17 808
参考： https://www.cnblogs.com/ittinybird/p/4830834.html https://blog.csdn.net/sharemyfree/article/details/47338001 https://blog.csdn.net/qccz123456/article/details/81329261 自旋锁是一种非阻塞锁，也就是说，如果某线程需要获...
自旋锁（cpp11）
Zx13170918986的博客
03-14 492
自旋锁（cpp11实现）
C++11多线程基础：使用std::atomic_flag实现自旋锁
在么升龙拳的博客
02-08 360
#include <atomic> #include <iostream> #include <thread> class spinlock_mutex { std::atomic_flag flag; public: spinlock_mutex(): flag(ATOMIC_FLAG_INIT) {} void lock() { while(flag.test_and_set(std:.
【并发编程十四】c++原子操作（2）——实现自旋锁
junxuezheng的博客
02-02 1311
在介绍完原子操作，我们这篇使用c++提供的原子操作，实现一个自旋锁，并加以利用。原子操作参见[【并发编程十三】c++原子操作]
C++实战篇（一）——自旋锁的使用
qq_73924465的博客
04-19 961
自旋锁指的是当一个线程在获取锁的时候，如果锁已经被其他线程所获取,那么该线程就将进入一个循环，不断的去判断自身是否能够获得锁 ,直到该线程获得了锁，线程才会退出循环。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值