C++关键字整理

contained type

atomic type

bool

atomic_bool

char

atomic_char

signed char

atomic_schar

unsigned char

atomic_uchar

short

atomic_short

unsigned short

atomic_ushort

int

atomic_int

unsigned int

atomic_uint

long

atomic_long

unsigned long

atomic_ulong

long long

atomic_llong

unsigned long long

atomic_ullong

wchar_t

atomic_wchar_t

char16_t

atomic_char16_t

char32_t

atomic_char32_t

intmax_t

atomic_intmax_t

uintmax_t

atomic_uintmax_t

int_leastN_t

atomic_int_leastN_t

uint_leastN_t

atomic_uint_leastN_t

int_fastN_t

atomic_int_fastN_t

uint_fastN_t

atomic_uint_fastN_t

intptr_t

atomic_intptr_t

uintptr_t

atomic_uintptr_t

size_t

atomic_size_t

ptrdiff_t

atomic_ptrdiff_t

macro

relative to types

ATOMIC_BOOL_LOCK_FREE

bool

ATOMIC_CHAR_LOCK_FREE

char

signed char

unsigned char

ATOMIC_SHORT_LOCK_FREE

short

unsigned short

ATOMIC_INT_LOCK_FREE

int

unsigned int

ATOMIC_LONG_LOCK_FREE

long

unsigned long

ATOMIC_LLONG_LOCK_FREE

long long

unsigned long long

ATOMIC_WCHAR_T_LOCK_FREE

wchar_t

ATOMIC_CHAR16_T_LOCK_FREE

char16_t

ATOMIC_CHAR32_T_LOCK_FREE

char32_t

ATOMIC_POINTER_LOCK_FREE

U*

(for any type U)

序号

值

意义

1

memory_order_relaxed

宽松模型，不对执行顺序做保证

2

memory_order_consume

当前线程中,满足happens-before原则。

当前线程中该原子的所有后续操作,必须在本条操作完成之后执行

3

memory_order_acquire

当前线程中,读操作满足happens-before原则。

所有后续的读操作必须在本操作完成后执行

4

memory_order_release

当前线程中,写操作满足happens-before原则。

所有后续的写操作必须在本操作完成后执行

5

memory_order_acq_rel

当前线程中，同时满足memory_order_acquire和memory_order_release

6

memory_order_seq_cst

最强约束。全部读写都按顺序执行

std::atomic_flag：最简单的原子变量实例，是对于bool类型的变量进行原子操作，提供了标志的管理，标志有三种状态：clear、set和未初始化状态。

接口介绍：

(1)ATOMIC_FLAG_INIT：用于给atomic_flag变量赋初值，如果定义后为赋值，则状态是不确定的。被这个赋值后的状态为false。

(2)test_and_set() ：接口函数，调用后状态变为true，并返回改变状态前的状态值。

(3)clear() : 接口函数，调用后状态变为false。

#include

#include

#include

#include

std::atomic_flag lock = ATOMIC_FLAG_INIT;

int gcnt = 0;

void f(int n)

{

for (int cnt = 0; cnt < 100; ++cnt) {

while (lock.test_and_set(std::memory_order_acquire)) // 获得锁

; // 自旋

std::cout << "Output from thread " << n << '';

gcnt++;

lock.clear(std::memory_order_release); // 释放锁

}

}

int main()

{

std::vector v;

for (int n = 0; n < 10; ++n) {

v.emplace_back(f, n);

}

for (auto& t : v) {

t.join();

}

}

自旋锁的解释：当某一个线程调用‘lock.test_and_set’时，即设置lock的状态为true，当另一个线程进入时，再次调用test_and_set时返回的状态为true，则一直在while循环中不断获取，即实现了等待，直到第一个线程调用clear将状态变为false。

std::atomic：通过atomic模板类可以对更多的类型进行原子操作

(1)is_lock_free:通过这个接口判断是否需要加锁。如果是，则在多个线程访问该对象时不会导致线程阻塞(可能使用某种事务内存transactional memory方法实现lock-free的特性)。事实上该函数可以做为一个静态函数。所有指定相同类型T的atomic实例的is_lock_free函数都会返回相同值。

(2)store：赋值操作。operator=实际上内部调用了store，并返回d。

void store(T desr, memory_order m = memory_order_seq_cst) noexcept;void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;T operator=(T d) noexcept;T operator=(T d) volatile noexcept;

(3)load: 读取，加载并返回变量的值。operator T是load的简化版，内部调用的是load(memory_order_seq_cst)形式。

(4)exchange：交换，赋值后返回变量赋值前的值。exchange也称为read-modify-write操作。

T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;

T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;

(5)compare_exchange_weak：这就是有名的CAS(Compare And Swap: 比较并交换)。操作是原子的，排它的。其它线程如果想要读取或修改该原子对象时，会等待先该操作完成。

(6)compare_exchange_strong：

进行compare时，与weak版一样，都是比较的物理内容。与weak版不同的是，strong版本不会返回伪false。即：原子对象所封装的值如果与expect在物理内容上相同，strong版本一定会返回true。其所付出的代价是：在某些需要循环检测的算法，或某些平台下，其性能较compare_exchange_weak要差。但对于某些不需要采用循环检测的算法而言, 通常采用compare_exchange_strong 更好。

std::atomic特化：

(1)fetch_add：该函数将原子对象封装的值加上v，同时返回原子对象的旧值。其功能用伪代码表示为：

// T is integral

T fetch_add(T v, memory_order m = memory_order_seq_cst) volatile noexcept;

T fetch_add(T v, memory_order m = memory_order_seq_cst) noexcept;

// T is pointer

T fetch_add(ptrdiff_t v, memory_order m = memory_order_seq_cst) volatile noexcept;

T fetch_add(ptrdiff_t v, memory_order m = memory_order_seq_cst) noexcept;

(2)fetch_sub：该函数将原子对象封装的值减去v，同时返回原子对象的旧值。其功能用伪代码表示为：

// T is integral

T fetch_sub(T v, memory_order m = memory_order_seq_cst) volatile noexcept;

T fetch_sub(T v, memory_order m = memory_order_seq_cst) noexcept;

// T is pointer

T fetch_sub(ptrdiff_t v, memory_order m = memory_order_seq_cst) volatile noexcept;

T fetch_sub(ptrdiff_t v, memory_order m = memory_order_seq_cst) noexcept;

(3)++, –, +=, -=：不管是基于整数的特化，还是指针特化，atomic均支持这四种操作。其用法与未封装时一样

独属于数值型特化的原子操作 – 位操作：

(1)fetch_and，fetch_or，fetch_xor：

位操作，将contained按指定方式进行位操作，并返回contained的旧值。

integral fetch_and(integral v, memory_order m = memory_order_seq_cst) volatile noexcept;

integral fetch_and(integral v, memory_order m = memory_order_seq_cst) noexcept;

integral fetch_or(integral v, memory_order m = memory_order_seq_cst) volatile noexcept;

integral fetch_or(integral v, memory_order m = memory_order_seq_cst) noexcept;

integral fetch_xor(integral v, memory_order m = memory_order_seq_cst) volatile noexcept;

integral fetch_xor(integral v, memory_order m = memory_order_seq_cst) noexcept;

(2)perator &=，operator |=，operator ^=：与相应的fetch_*操作不同的是，operator操作返回的是新值

T operator &=(T v) volatile noexcept {return fetch_and(v) & v;}

T operator &=(T v) noexcept {return fetch_and(v) & v;}

T operator |=(T v) volatile noexcept {return fetch_or(v) | v;}

T operator |=(T v) noexcept {return fetch_or(v) | v;}

T operator ^=(T v) volatile noexcept {return fetch_xor(v) ^ v;}

T operator ^=(T v) noexcept {return fetch_xor(v) ^ v;}