服务器之家

服务器之家 > 正文

详解C++11原子类型与原子操作

时间:2021-09-22 14:54     来源/作者:Dabelv

1.认识原子操作

原子操作就是在多线程程序中“最小的且不可并行化的”操作,意味着多个线程访问同一个资源时,有且仅有一个线程能对资源进行操作。通常情况下原子操作可以通过互斥的访问方式来保证,例如Linux下的互斥锁(mutex),Windows下的临界区(Critical Section)等。下面看一个Linux环境使用POSIX标准的pthread库实现多线程下的原子操作:

?
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
#include <pthread.h>
#include <iostream>
using namespace std;
 
int64_t total=0;
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
 
//线程函数,用于累加
void* threadFunc(void* args)
{
  int64_t endNum=*(int64_t*)args;
  for(int64_t i=1;i<=endNum;++i)
  {
    pthread_mutex_lock(&m);
    total+=i;
    pthread_mutex_unlock(&m);
  }
}
 
int main()
{
  int64_t endNum=100;
  pthread_t thread1ID=0,thread2ID=0;
  
  //创建线程1
  pthread_create(&thread1ID,NULL,threadFunc,&endNum);
  //创建线程2
  pthread_create(&thread2ID,NULL,threadFunc,&endNum);
  
  //阻塞等待线程1结束并回收资源
  pthread_join(thread1ID,NULL);
  //阻塞等待线程2结束并回收资源
  pthread_join(thread2ID,NULL);
 
  cout<<"total="<<total<<endl;    //10100
}

上面的代码,两个线程同时对total进行操作,为了保证total+=i 的原子性,采用互斥锁来保证同一时刻只有同一线程执行total+=i操作,所以得出正确结果total=10100。如果没有做互斥处理,那么total同一时刻可能会被两个线程同时操作,即会出现两个线程同时读取了寄存器中的total值,分别操作之后又写入寄存器,这样就会有一个线程的增加操作无效,会得出一个小于10100随机的错误值。

2.C++11实现原子操作

在C++11之前,使用第三方API可以实现并行编程,比如pthread多线程库,但是在使用时需要创建互斥锁,以及进行加锁、解锁等操作来保证多线程对临界资源的原子操作,这无疑增加了开发的工作量。不过从C++11开始,C++从语言层面开始支持并行编程,内容包括了管理线程、保护共享数据、线程间的同步操作、低级原子操作等各种类。新标准极大地提高了程序的可移植性,以前的多线程依赖于具体的平台,而现在有了统一的接口。

C++11通过引入原子类型帮助开发者轻松实现原子操作。

?
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
#include <atomic>
#include <thread>
#include <iostream>
using namespace std;
 
atomic_int64_t total = 0;  //atomic_int64_t相当于int64_t,但是本身就拥有原子性
 
//线程函数,用于累加
void threadFunc(int64_t endNum)
{
    for (int64_t i = 1; i <= endNum; ++i)
    {
        total += i;
    }
}
 
int main()
{
    int64_t endNum = 100;
    thread t1(threadFunc, endNum);
    thread t2(threadFunc, endNum);
 
    t1.join();
    t2.join();
 
    cout << "total=" << total << endl; //10100
}

程序正常编译并运行输出正确结果total=10100。使用C++11提供的原子类型与多线程标准接口,简洁地实现了多线程对临界资源的原子操作。原子类型C++11中通过atomic<T>类模板来定义,比如atomic_int64_t是通过typedef atomic<int64_t> atomic_int64_t实现的,使用时需包含头文件<atomic>。除了提供atomic_int64_t,还提供了其它的原子类型。常见的原子类型有

 

原子类型名称

对应内置类型

atomic_bool

bool

atomic_char

atomic_char

atomic_char

signed char

atomic_uchar

unsigned char

atomic_short

short

atomic_ushort

unsigned short

atomic_int

int

atomic_uint

unsigned int

atomic_long

long

atomic_ulong

unsigned long

atomic_llong

long long

atomic_ullong

unsigned long long

atomic_ullong

unsigned long long

atomic_char16_t

char16_t

atomic_char32_t

char32_t

atomic_wchar_t

wchar_t

 

原子操作是平台相关的,原子类型能够实现原子操作是因为C++11对原子类型的操作进行了抽象,定义了统一的接口,并要求编译器产生平台相关的原子操作的具体实现。C++11标准将原子操作定义为atomic模板类的成员函数,包括读(load)、写(store)、交换(exchange)等。对于内置类型而言,主要是通过重载一些全局操作符来完成的。比如对上文total+=i的原子加操作,是通过对operator+=重载来实现的。使用g++编译的话,在x86_64的机器上,operator+=()函数会产生一条特殊的以lock为前缀的x86_64指令,用于控制总线及实现x86_64平台上的原子性加法。

有一个比较特殊的原子类型是atomic_flag,因为atomic_flag与其他原子类型不同,它是无锁(lock_free)的,即线程对其访问不需要加锁,而其他的原子类型不一定是无锁的。因为atomic<T>并不能保证类型T是无锁的,另外不同平台的处理器处理方式不同,也不能保证必定无锁,所以其他的类型都会有is_lock_free()成员函数来判断是否是无锁的。atomic_flag只支持test_and_set()以及clear()两个成员函数,test_and_set()函数检查 std::atomic_flag 标志,如果 std::atomic_flag 之前没有被设置过,则设置 std::atomic_flag 的标志;如果之前 std::atomic_flag 已被设置,则返回 true,否则返回 false。clear()函数清除 std::atomic_flag 标志使得下一次调用 std::atomic_flag::test_and_set()返回 false。可以用atomic_flag的成员函数test_and_set()和clear()来实现一个自旋锁(spin lock):

?
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
#include <unistd.h>
#include <atomic>
#include <thread>
#include <iostream>
 
std::atomic_flag lock = ATOMIC_FLAG_INIT;
 
void func1()
{
    while (lock.test_and_set(std::memory_order_acquire)) // 在主线程中设置为true,需要等待t2线程clear
 {
  std::cout << "func1 wait" << std::endl;
 }
 std::cout << "func1 do something" << std::endl;
}
 
void func2()
{
 std::cout << "func2 start" << std::endl;
 lock.clear();
}
 
int main()
{
 lock.test_and_set();    // 设置状态
 std::thread t1(func1);
 usleep(1);                     //睡眠1us
 std::thread t2(func2);
 
 t1.join();
 t2.join();
 
 return 0;
}

以上代码中,定义了一个atomic_flag对象lock,使用初始值ATOMIC_FLAG_INIT进行初始化,即处于false的状态。线程t1调用test_and_set()一直返回true(因为在主线程中被设置过),所以一直在等待,而等待一段时间后当线程t2运行并调用了clear(),test_and_set()返回了false退出循环等待并进行相应操作。这样一来,就实现了一个线程等待另一个线程的效果。当然,可以封装成锁操作的方式,比如:

?
1
2
void Lock(atomic_flag& lock){ while ( lock.test_and_set()); }
void UnLock(atomic_flag& lock){ lock.clear(); }

这样一来,就可以通过Lock()和UnLock()的方式来互斥地访问临界区。

以上就是详解C++11原子类型与原子操作的详细内容,更多关于C++11原子类型与原子操作的资料请关注服务器之家其它相关文章!

原文链接:https://cloud.tencent.com/developer/article/1380964

标签:

相关文章

热门资讯

yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
2021年耽改剧名单 2021要播出的59部耽改剧列表
2021年耽改剧名单 2021要播出的59部耽改剧列表 2021-03-05
返回顶部