[转] C++11 并发指南系列

本是古典何须时尚 2022-09-27 04:59 102阅读 0赞

## [C++11 并发指南一(C++11 多线程初探)][C_11 _C_11] ##

### **引言** ###

C++11 自2011年发布以来已经快两年了，之前一直没怎么关注，直到最近几个月才看了一些 C++11 的新特性，今后几篇博客我都会写一些关于 C++11 的特性，算是记录一下自己学到的东西吧，和大家共勉。

相信 Linux 程序员都用过 Pthread, 但有了 C++11 的 std::thread 以后，你可以在语言层面编写多线程程序了，直接的好处就是多线程程序的可移植性得到了很大的提高，所以作为一名 C++ 程序员，熟悉 C++11 的多线程编程方式还是很有益处的。

如果你对 C++11 不太熟悉，建议先看看维基百科上关于 C++11 新特性的介绍，[中文C++11介绍][C_11]，[英文C++11介绍][C_11 1] ，另外C++之父 [Bjarne Stroustrup][] 的关于 [C++11 的 FAQ][C_11 _ FAQ] 也是必看的，我也收集了一些关于C++11的资料，供大家查阅：

### **资料汇** ###

[http://www.open-std.org/jtc1/sc22/wg21/][http_www.open-std.org_jtc1_sc22_wg21]

C++0x/C++11 Support in GCC：[http://gcc.gnu.org/projects/cxx0x.html][http_gcc.gnu.org_projects_cxx0x.html]

What is C++0x：[https://www2.research.att.com/~bs/what-is-2009.pdf][https_www2.research.att.com_bs_what-is-2009.pdf]

Overview of the New C++：[http://www.artima.com/shop/overview\_of\_the\_new\_cpp][http_www.artima.com_shop_overview_of_the_new_cpp]

Overview of the New C++ (C++0x).pdf：[http://ishare.iask.sina.com.cn/f/20120005.html?from=like][http_ishare.iask.sina.com.cn_f_20120005.html_from_like]

A Brief Look at C++0x：[http://www.artima.com/cppsource/cpp0x.html][http_www.artima.com_cppsource_cpp0x.html]

Summary of C++11 Feature Availability in gcc and MSVC：[http://www.aristeia.com/C++11/C++11FeatureAvailability.htm][http_www.aristeia.com_C_11_C_11FeatureAvailability.htm]

C++ 11: Come Closer：[http://www.codeproject.com/Articles/344282/Cplusplus-11-Come-Closer][http_www.codeproject.com_Articles_344282_Cplusplus-11-Come-Closer]

C++11 threads, locks and condition variables： [http://www.codeproject.com/Articles/598695/Cplusplus11-threads-locks-and-condition-variables][http_www.codeproject.com_Articles_598695_Cplusplus11-threads-locks-and-condition-variables]

Move Semantics and Perfect Forwarding in C++11：[http://www.codeproject.com/Articles/397492/Move-Semantics-and-Perfect-Forwarding-in-Cplusplus][http_www.codeproject.com_Articles_397492_Move-Semantics-and-Perfect-Forwarding-in-Cplusplus]

[http://solarianprogrammer.com/categories/C++11/][http_solarianprogrammer.com_categories_C_11]

C++11 Concurrency：[http://www.baptiste-wicht.com/2012/03/cpp11-concurrency-part1-start-threads/][http_www.baptiste-wicht.com_2012_03_cpp11-concurrency-part1-start-threads]

[http://www.hpl.hp.com/personal/Hans\_Boehm/misc\_slides/sfacm-cleaned.pdf][http_www.hpl.hp.com_personal_Hans_Boehm_misc_slides_sfacm-cleaned.pdf]

[http://en.cppreference.com/w/cpp/thread][http_en.cppreference.com_w_cpp_thread]

[http://isocpp.org/blog/2012/12/c11-a-cheat-sheet-alex-sinyakov][http_isocpp.org_blog_2012_12_c11-a-cheat-sheet-alex-sinyakov]

The Biggest Changes in C++11：[http://blog.smartbear.com/c-plus-plus/the-biggest-changes-in-c11-and-why-you-should-care/][http_blog.smartbear.com_c-plus-plus_the-biggest-changes-in-c11-and-why-you-should-care]

Ten C++11 Features Every C++ Developer Should Use：[http://www.codeproject.com/Articles/570638/Ten-Cplusplus11-Features-Every-Cplusplus-Developer][http_www.codeproject.com_Articles_570638_Ten-Cplusplus11-Features-Every-Cplusplus-Developer]

C++11 – A Glance \[part 1 of n\]：[http://www.codeproject.com/Articles/312029/Cplusplus11-A-Glance-part-1-of-n][http_www.codeproject.com_Articles_312029_Cplusplus11-A-Glance-part-1-of-n]

C++11 – A Glance \[part 2 of n\]：[http://www.codeproject.com/Articles/314415/Cplusplus11-A-Glance-part-2-of-n][http_www.codeproject.com_Articles_314415_Cplusplus11-A-Glance-part-2-of-n]

C++11（及现代C++风格）和快速迭代式开发：[http://mindhacks.cn/2012/08/27/modern-cpp-practices/][http_mindhacks.cn_2012_08_27_modern-cpp-practices]

Lambda Functions in C++11 - the Definitive Guide：[http://www.cprogramming.com/c++11/c++11-lambda-closures.html][http_www.cprogramming.com_c_11_c_11-lambda-closures.html]

Better types in C++11 - nullptr, enum classes (strongly typed enumerations) and cstdint：[http://www.cprogramming.com/c++11/c++11-nullptr-strongly-typed-enum-class.html][http_www.cprogramming.com_c_11_c_11-nullptr-strongly-typed-enum-class.html]

Rvalue-references-and-move-semantics-in-c++11：[http://www.cprogramming.com/c++11/rvalue-references-and-move-semantics-in-c++11.html][http_www.cprogramming.com_c_11_rvalue-references-and-move-semantics-in-c_11.html]

[http://www.gotw.ca/publications/index.htm][http_www.gotw.ca_publications_index.htm]

[http://www.devx.com/SpecialReports/Door/38865][http_www.devx.com_SpecialReports_Door_38865]

Multi-threading in C++0x：[http://accu.org/index.php/journals/1584][http_accu.org_index.php_journals_1584]

C++ 0X feature summary cheat sheat：[http://www.iesensor.com/blog/2011/05/31/c-0x-feature-summary-cheat-sheat/][http_www.iesensor.com_blog_2011_05_31_c-0x-feature-summary-cheat-sheat]

Multithreading in C++0x part 1: Starting Threads：[http://www.justsoftwaresolutions.co.uk/threading/multithreading-in-c++0x-part-1-starting-threads.html][http_www.justsoftwaresolutions.co.uk_threading_multithreading-in-c_0x-part-1-starting-threads.html]

[http://en.cppreference.com/w/cpp/thread][http_en.cppreference.com_w_cpp_thread]

[http://www.cplusplus.com/reference/multithreading/][http_www.cplusplus.com_reference_multithreading]

好了，下面来说正题吧 ;-)

### **与 C++11 多线程相关的头文件** ###

C++11 新标准中引入了四个头文件来支持多线程编程，他们分别是<atomic> ,<thread>,<mutex>,<condition\_variable>和<future>。

*  <atomic>：该头文主要声明了两个类, std::atomic 和 std::atomic\_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。
 *  <thread>：该头文件主要声明了 std::thread 类，另外 std::this\_thread 命名空间也在该头文件中。
 *  <mutex>：该头文件主要声明了与互斥量(mutex)相关的类，包括 std::mutex 系列类，std::lock\_guard, std::unique\_lock, 以及其他的类型和函数。
 *  <condition\_variable>：该头文件主要声明了与条件变量相关的类，包括 std::condition\_variable 和 std::condition\_variable\_any。
 *  <future>：该头文件主要声明了 std::promise, std::package\_task 两个 Provider 类，以及 std::future 和 std::shared\_future 两个 Future 类，另外还有一些与之相关的类型和函数，std::async() 函数就声明在此头文件中。

### **std::thread "Hello world"** ###

下面是一个最简单的使用 std::thread 类的例子：

![复制代码][copycode.gif]

#include <stdio.h>
    #include <stdlib.h>
    
    #include <iostream> // std::cout
    #include <thread>   // std::thread
    
    void thread_task() {
        std::cout << "hello thread" << std::endl;
    }
    
    /*
     * ===  FUNCTION  =========================================================
     *         Name:  main
     *  Description:  program entry routine.
     * ========================================================================
     */
    int main(int argc, const char *argv[])
    {
        std::thread t(thread_task);
        t.join();
    
        return EXIT_SUCCESS;
    }  /* ----------  end of function main  ---------- */

![复制代码][copycode.gif]

Makefile 如下：

![复制代码][copycode.gif]

all:Thread
    
    CC=g++
    CPPFLAGS=-Wall -std=c++11 -ggdb
    LDFLAGS=-pthread
    
    Thread:Thread.o
        $(CC) $(LDFLAGS) -o $@ $^
    
    Thread.o:Thread.cc
        $(CC) $(CPPFLAGS) -o $@ -c $^
    
    
    .PHONY:
        clean
    
    clean:
        rm Thread.o Thread

![复制代码][copycode.gif]

注意在 Linux GCC4.6 环境下，编译时需要加 -pthread，否则执行时会出现：

$ ./Thread
    terminate called after throwing an instance of 'std::system_error'
      what():  Operation not permitted
    Aborted (core dumped)

原因是 GCC 默认没有加载 pthread 库，据说在后续的版本中可以不用在编译时添加 -pthread 选项。

更多的有关 C++11 Concurrency 的介绍将在后续的一系列博客中写出，希望自己勤快一点吧 ;-)

## [C++11 并发指南二(std::thread 详解)][C_11 _std_thread] ##

上一篇博客《[C++11 并发指南一(C++11 多线程初探)][C_11 _C_11]》中只是提到了 std::thread 的基本用法，并给出了一个最简单的例子，本文将稍微详细地介绍 std::thread 的用法。

std::thread 在 <thread> 头文件中声明，因此使用 std::thread 时需要包含 <thread> 头文件。

### std::thread 构造 ###

*  (1). 默认构造函数，创建一个空的 thread 执行对象。
 *  (2). 初始化构造函数，创建一个 thread对象，该 thread对象可被 joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。
 *  (3). 拷贝构造函数(被禁用)，意味着 thread 不可被拷贝构造。
 *  (4). move 构造函数，move 构造函数，调用成功之后 x 不代表任何 thread 执行对象。
 *  注意：可被 joinable 的 thread 对象必须在他们销毁之前被主线程 join 或者将其设置为 detached.

std::thread 各种构造函数例子如下（[参考][Link 1]）：

![复制代码][copycode.gif]

#include <iostream>
    #include <utility>
    #include <thread>
    #include <chrono>
    #include <functional>
    #include <atomic>
     
    void f1(int n)
    {
        for (int i = 0; i < 5; ++i) {
            std::cout << "Thread " << n << " executing\n";
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }
     
    void f2(int& n)
    {
        for (int i = 0; i < 5; ++i) {
            std::cout << "Thread 2 executing\n";
            ++n;
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }
     
    int main()
    {
        int n = 0;
        std::thread t1; // t1 is not a thread
        std::thread t2(f1, n + 1); // pass by value
        std::thread t3(f2, std::ref(n)); // pass by reference
        std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread
        t2.join();
        t4.join();
        std::cout << "Final value of n is " << n << '\n';
    }

![复制代码][copycode.gif]

### move 赋值操作 ###

*  (1). move 赋值操作，如果当前对象不可 joinable，需要传递一个右值引用(rhs)给 move 赋值操作；如果当前对象可被 joinable，则 terminate() 报错。
 *  (2). 拷贝赋值操作被禁用，thread 对象不可被拷贝。

请看下面的例子：

![复制代码][copycode.gif]

#include <stdio.h>
    #include <stdlib.h>
    
    #include <chrono>    // std::chrono::seconds
    #include <iostream>  // std::cout
    #include <thread>    // std::thread, std::this_thread::sleep_for
    
    void thread_task(int n) {
        std::this_thread::sleep_for(std::chrono::seconds(n));
        std::cout << "hello thread "
            << std::this_thread::get_id()
            << " paused " << n << " seconds" << std::endl;
    }
    
    /*
     * ===  FUNCTION  =========================================================
     *         Name:  main
     *  Description:  program entry routine.
     * ========================================================================
     */
    int main(int argc, const char *argv[])
    {
        std::thread threads[5];
        std::cout << "Spawning 5 threads...\n";
        for (int i = 0; i < 5; i++) {
            threads[i] = std::thread(thread_task, i + 1);
        }
        std::cout << "Done spawning threads! Now wait for them to join\n";
        for (auto& t: threads) {
            t.join();
        }
        std::cout << "All threads joined.\n";
    
        return EXIT_SUCCESS;
    }  /* ----------  end of function main  ---------- */

![复制代码][copycode.gif]

### 其他成员函数 ###

*  [**get\_id**][get_id]

获取线程 ID。

*  [**joinable**][joinable]

检查线程是否可被 join。

*  [**join**][join]

Join 线程。

*  [**detach**][detach]

Detach 线程

*  [**swap**][swap]

Swap 线程 。

*  [**native\_handle**][native_handle]

返回 native handle。

*  [**hardware\_concurrency \[static\]**][hardware_concurrency _static]

检测硬件并发特性。

## [C++11 并发指南三(std::mutex 详解)][C_11 _std_mutex] ##

上一篇《[C++11 并发指南二(std::thread 详解)][C_11 _std_thread]》中主要讲到了 std::thread 的一些用法，并给出了两个小例子，本文将介绍 std::mutex 的用法。

Mutex 又称互斥量，C++ 11中与 Mutex 相关的类（包括锁类型）和函数都声明在 <mutex> 头文件中，所以如果你需要使用 std::mutex，就必须包含 <mutex> 头文件。

### <mutex> 头文件介绍 ###

#### Mutex 系列类(四种) ####

*  std::mutex，最基本的 Mutex 类。
 *  std::recursive\_mutex，递归 Mutex 类。
 *  std::time\_mutex，定时 Mutex 类。
 *  std::recursive\_timed\_mutex，定时递归 Mutex 类。

#### Lock 类（两种） ####

*  std::lock\_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。
 *  std::unique\_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

#### 其他类型 ####

*  std::once\_flag
 *  std::adopt\_lock\_t
 *  std::defer\_lock\_t
 *  std::try\_to\_lock\_t

#### 函数 ####

*  std::try\_lock，尝试同时对多个互斥量上锁。
 *  std::lock，可以同时对多个互斥量上锁。
 *  std::call\_once，如果多个线程需要同时调用某个函数，call\_once 可以保证多个线程对该函数只调用一次。

### std::mutex 介绍 ###

下面以 std::mutex 为例介绍 C++11 中的互斥量用法。

std::mutex 是C++11 中最基本的互斥量，std::mutex 对象提供了独占所有权的特性——即不支持递归地对 std::mutex 对象上锁，而 std::recursive\_lock 则可以递归地对互斥量对象上锁。

#### std::mutex 的成员函数 ####

*  构造函数，std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。
 *  lock()，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：(1). 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。(2). 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。
 *  unlock()， 解锁，释放对互斥量的所有权。
 *  try\_lock()，尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况，(1). 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。(2). 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

下面给出一个与 std::mutex 的小例子（[参考][Link 2]）

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex
    
    volatile int counter(0); // non-atomic counter
    std::mutex mtx;           // locks access to counter
    
    void attempt_10k_increases() {
        for (int i=0; i<10000; ++i) {
            if (mtx.try_lock()) {   // only increase if currently not locked:
                ++counter;
                mtx.unlock();
            }
        }
    }
    
    int main (int argc, const char* argv[]) {
        std::thread threads[10];
        for (int i=0; i<10; ++i)
            threads[i] = std::thread(attempt_10k_increases);
    
        for (auto& th : threads) th.join();
        std::cout << counter << " successful increases of the counter.\n";
    
        return 0;
    }

![复制代码][copycode.gif]

### std::recursive\_mutex 介绍 ###

std::recursive\_mutex 与 std::mutex 一样，也是一种可以被上锁的对象，但是和 std::mutex 不同的是，std::recursive\_mutex 允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，std::recursive\_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同，除此之外，std::recursive\_mutex 的特性和 std::mutex 大致相同。

### std::time\_mutex 介绍 ###

std::time\_mutex 比 std::mutex 多了两个成员函数，try\_lock\_for()，try\_lock\_until()。

try\_lock\_for 函数接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与 std::mutex 的 try\_lock() 不同，try\_lock 如果被调用时没有获得锁则直接返回 false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

try\_lock\_until 函数则接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

下面的小例子说明了 std::time\_mutex 的用法（[参考][Link 3]）。

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <chrono>         // std::chrono::milliseconds
    #include <thread>         // std::thread
    #include <mutex>          // std::timed_mutex
    
    std::timed_mutex mtx;
    
    void fireworks() {
      // waiting to get a lock: each thread prints "-" every 200ms:
      while (!mtx.try_lock_for(std::chrono::milliseconds(200))) {
        std::cout << "-";
      }
      // got a lock! - wait for 1s, then this thread prints "*"
      std::this_thread::sleep_for(std::chrono::milliseconds(1000));
      std::cout << "*\n";
      mtx.unlock();
    }
    
    int main ()
    {
      std::thread threads[10];
      // spawn 10 threads:
      for (int i=0; i<10; ++i)
        threads[i] = std::thread(fireworks);
    
      for (auto& th : threads) th.join();
    
      return 0;
    }

![复制代码][copycode.gif]

### std::recursive\_timed\_mutex 介绍 ###

和 std:recursive\_mutex 与 std::mutex 的关系一样，std::recursive\_timed\_mutex 的特性也可以从 std::timed\_mutex 推导出来，感兴趣的同鞋可以自行查阅。 ;-)

### std::lock\_guard 介绍 ###

与 Mutex RAII 相关，方便线程对互斥量上锁。例子（[参考][Link 4]）:

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::lock_guard
    #include <stdexcept>      // std::logic_error
    
    std::mutex mtx;
    
    void print_even (int x) {
        if (x%2==0) std::cout << x << " is even\n";
        else throw (std::logic_error("not even"));
    }
    
    void print_thread_id (int id) {
        try {
            // using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:
            std::lock_guard<std::mutex> lck (mtx);
            print_even(id);
        }
        catch (std::logic_error&) {
            std::cout << "[exception caught]\n";
        }
    }
    
    int main ()
    {
        std::thread threads[10];
        // spawn 10 threads:
        for (int i=0; i<10; ++i)
            threads[i] = std::thread(print_thread_id,i+1);
    
        for (auto& th : threads) th.join();
    
        return 0;
    }

![复制代码][copycode.gif]

### std::unique\_lock 介绍 ###

与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。例子（[参考][Link 5]）：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock
    
    std::mutex mtx;           // mutex for critical section
    
    void print_block (int n, char c) {
        // critical section (exclusive access to std::cout signaled by lifetime of lck):
        std::unique_lock<std::mutex> lck (mtx);
        for (int i=0; i<n; ++i) {
            std::cout << c;
        }
        std::cout << '\n';
    }
    
    int main ()
    {
        std::thread th1 (print_block,50,'*');
        std::thread th2 (print_block,50,'$');
    
        th1.join();
        th2.join();
    
        return 0;
    }

![复制代码][copycode.gif]

好了，本文暂时讲到这里，还剩下 std::try\_lock，std::lock，std::call\_once 三个函数没有讲到，留在下一篇博客中讲吧 ;-)

## [C++11 并发指南三(Lock 详解)][C_11 _Lock] ##

在 《[C++11 并发指南三(std::mutex 详解)][C_11 _std_mutex]》一文中我们主要介绍了 C++11 标准中的互斥量(Mutex)，并简单介绍了一下两种锁类型。本节将详细介绍一下 C++11 标准的锁类型。

C++11 标准为我们提供了两种基本的锁类型，分别如下：

另外还提供了几个与锁类型相关的 Tag 类，分别如下:

*  `std::adopt_lock_t，一个空的标记类，定义如下：`

`该类型的常量对象adopt_lock（adopt_lock 是一个常量对象，定义如下：`

`通常作为参数传入给 unique_lock 或 lock_guard 的构造函数。`

*  `std::defer_lock_t，一个空的标记类，定义如下：```

`该类型的常量对象 defer_lock（defer_lock 是一个常量对象，定义如下：`

`通常作为参数传入给 unique_lock 或 lock_guard 的构造函数。`

*  `std::try_to_lock_t，一个空的标记类，定义如下：`

`该类型的常量对象 try_to_lock（try_to_lock 是一个常量对象，定义如下：`

`通常作为参数传入给 unique_lock 或 lock_guard 的构造函数。`后面我们会详细介绍以上三种 Tag 类型在配合 lock\_gurad 与 unique\_lock 使用时的区别。

### std::lock\_guard 介绍 ###

std::lock\_gurad 是 C++11 中定义的模板类。定义如下：

lock\_guard 对象通常用于管理某个锁(Lock)对象，因此与 Mutex RAII 相关，方便线程对互斥量上锁，即在某个 lock\_guard 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 lock\_guard 的生命周期结束之后，它所管理的锁对象会被解锁(注：类似 shared\_ptr 等智能指针管理动态分配的内存资源 )。

模板参数 Mutex 代表互斥量类型，例如 std::mutex 类型，它应该是一个基本的 BasicLockable 类型，标准库中定义几种基本的 BasicLockable 类型，分别 std::mutex, std::recursive\_mutex, std::timed\_mutex，std::recursive\_timed\_mutex (以上四种类型均已在上一篇博客中介绍)以及 std::unique\_lock(本文后续会介绍 std::unique\_lock)。(注：BasicLockable 类型的对象只需满足两种操作，lock 和 unlock，另外还有 Lockable 类型，在 BasicLockable 类型的基础上新增了 try\_lock 操作，因此一个满足 Lockable 的对象应支持三种操作：lock，unlock 和 try\_lock；最后还有一种 TimedLockable 对象，在 Lockable 类型的基础上又新增了 try\_lock\_for 和 try\_lock\_until 两种操作，因此一个满足 TimedLockable 的对象应支持五种操作：lock, unlock, try\_lock, try\_lock\_for, try\_lock\_until)。

在 lock\_guard 对象构造时，传入的 Mutex 对象(即它所管理的 Mutex 对象)会被当前线程锁住。在lock\_guard 对象被析构时，它所管理的 Mutex 对象会自动解锁，由于不需要程序员手动调用 lock 和 unlock 对 Mutex 进行上锁和解锁操作，因此这也是最简单安全的上锁和解锁方式，尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作，极大地简化了程序员编写与 Mutex 相关的异常处理代码。  
  
值得注意的是，lock\_guard 对象并不负责管理 Mutex 对象的生命周期，lock\_guard 对象只是简化了 Mutex 对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个 lock\_guard 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 lock\_guard 的生命周期结束之后，它所管理的锁对象会被解锁。

### std::lock\_guard 构造函数 ###

lock\_guard 构造函数如下表所示：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">locking (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">explicit lock_guard (mutex_type&amp; m);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">adopting (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">lock_guard (mutex_type&amp; m, adopt_lock_t tag);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy [deleted](3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">lock_guard (const lock_guard&amp;) = delete;</pre></td> 
  </tr> 
 </tbody> 
</table>

1.  locking 初始化
    
     *  lock\_guard 对象管理 Mutex 对象 m，并在构造时对 m 进行上锁（调用 m.lock()）。
2.  adopting初始化
    
     *  lock\_guard 对象管理 Mutex 对象 m，与 locking 初始化(1) 不同的是， Mutex 对象 m 已被当前线程锁住。
3.  拷贝构造
    
     *  lock\_guard 对象的拷贝构造和移动构造(move construction)均被禁用，因此 lock\_guard 对象不可被拷贝构造或移动构造。

我们来看一个简单的例子([参考][Link 6])：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::lock_guard, std::adopt_lock
    
    std::mutex mtx;           // mutex for critical section
    
    void print_thread_id (int id) {
      mtx.lock();
      std::lock_guard<std::mutex> lck(mtx, std::adopt_lock);
      std::cout << "thread #" << id << '\n';
    }
    
    int main ()
    {
      std::thread threads[10];
      // spawn 10 threads:
      for (int i=0; i<10; ++i)
        threads[i] = std::thread(print_thread_id,i+1);
    
      for (auto& th : threads) th.join();
    
      return 0;
    }

![复制代码][copycode.gif]

在 print\_thread\_id 中，我们首先对 mtx 进行上锁操作(mtx.lock();)，然后用 mtx 对象构造一个 lock\_guard 对象(std::lock\_guard<std::mutex> lck(mtx, std::adopt\_lock);)，注意此时 Tag 参数为 std::adopt\_lock，表明当前线程已经获得了锁，此后 mtx 对象的解锁操作交由 lock\_guard 对象 lck 来管理，在 lck 的生命周期结束之后，mtx 对象会自动解锁。

lock\_guard 最大的特点就是安全易于使用，请看下面例子([参考][Link 4])，在异常抛出的时候通过 lock\_guard 对象管理的 Mutex 可以得到正确地解锁。

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::lock_guard
    #include <stdexcept>      // std::logic_error
    
    std::mutex mtx;
    
    void print_even (int x) {
      if (x%2==0) std::cout << x << " is even\n";
      else throw (std::logic_error("not even"));
    }
    
    void print_thread_id (int id) {
      try {
        // using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:
        std::lock_guard<std::mutex> lck (mtx);
        print_even(id);
      }
      catch (std::logic_error&) {
        std::cout << "[exception caught]\n";
      }
    }
    
    int main ()
    {
      std::thread threads[10];
      // spawn 10 threads:
      for (int i=0; i<10; ++i)
        threads[i] = std::thread(print_thread_id,i+1);
    
      for (auto& th : threads) th.join();
    
      return 0;
    }

![复制代码][copycode.gif]

### std::unique\_lock 介绍 ###

但是 lock\_guard 最大的缺点也是简单，没有给程序员提供足够的灵活度，因此，C++11 标准中定义了另外一个与 Mutex RAII 相关类 unique\_lock，该类与 lock\_guard 类相似，也很方便线程对互斥量上锁，但它提供了更好的上锁和解锁控制。

顾名思义，unique\_lock 对象以独占所有权的方式（ unique owership）管理 mutex 对象的上锁和解锁操作，所谓独占所有权，就是没有其他的 unique\_lock 对象同时拥有某个 mutex 对象的所有权。

在构造(或移动(move)赋值)时，unique\_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的 unique\_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。  
  
std::unique\_lock 对象也能保证在其自身析构时它所管理的 Mutex 对象能够被正确地解锁（即使没有显式地调用 unlock 函数）。因此，和 lock\_guard 一样，这也是一种简单而又安全的上锁和解锁方式，尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作，极大地简化了程序员编写与 Mutex 相关的异常处理代码。  
  
值得注意的是，unique\_lock 对象同样也不负责管理 Mutex 对象的生命周期，unique\_lock 对象只是简化了 Mutex 对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个 unique\_lock 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 unique\_lock 的生命周期结束之后，它所管理的锁对象会被解锁，这一点和 lock\_guard 类似，但 unique\_lock 给程序员提供了更多的自由，我会在下面的内容中给大家介绍 unique\_lock 的用法。

另外，与 lock\_guard 一样，模板参数 Mutex 代表互斥量类型，例如 std::mutex 类型，它应该是一个基本的 BasicLockable 类型，标准库中定义几种基本的 BasicLockable 类型，分别 std::mutex, std::recursive\_mutex, std::timed\_mutex，std::recursive\_timed\_mutex (以上四种类型均已在上一篇博客中介绍)以及 std::unique\_lock(本文后续会介绍 std::unique\_lock)。(注：BasicLockable 类型的对象只需满足两种操作，lock 和 unlock，另外还有 Lockable 类型，在 BasicLockable 类型的基础上新增了 try\_lock 操作，因此一个满足 Lockable 的对象应支持三种操作：lock，unlock 和 try\_lock；最后还有一种 TimedLockable 对象，在 Lockable 类型的基础上又新增了 try\_lock\_for 和 try\_lock\_until 两种操作，因此一个满足 TimedLockable 的对象应支持五种操作：lock, unlock, try\_lock, try\_lock\_for, try\_lock\_until)。

### std::unique\_lock 构造函数 ###

std::unique\_lock 的构造函数的数目相对来说比 std::lock\_guard 多，其中一方面也是因为 std::unique\_lock 更加灵活，从而在构造 std::unique\_lock 对象时可以接受额外的参数。总地来说，std::unique\_lock 构造函数如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">default (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">unique_lock() noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">locking (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">explicit unique_lock(mutex_type&amp; m);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">try-locking (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">unique_lock(mutex_type&amp; m, try_to_lock_t tag);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">deferred (4)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">unique_lock(mutex_type&amp; m, defer_lock_t tag) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">adopting (5)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">unique_lock(mutex_type&amp; m, adopt_lock_t tag);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">locking for (6)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Rep, class Period&gt;
unique_lock(mutex_type&amp; m, const chrono::duration&lt;Rep,Period&gt;&amp; rel_time);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">locking until (7)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Clock, class Duration&gt;
unique_lock(mutex_type&amp; m, const chrono::time_point&lt;Clock,Duration&gt;&amp; abs_time);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy [deleted] (8)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">unique_lock(const unique_lock&amp;) = delete;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">move (9)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">unique_lock(unique_lock&amp;&amp; x);</pre></td> 
  </tr> 
 </tbody> 
</table>

下面我们来分别介绍以上各个构造函数：

(1) 默认构造函数

新创建的 unique\_lock 对象不管理任何 Mutex 对象。

(2) locking 初始化

新创建的 unique\_lock 对象管理 Mutex 对象 m，并尝试调用 m.lock() 对 Mutex 对象进行上锁，如果此时另外某个 unique\_lock 对象已经管理了该 Mutex 对象 m，则当前线程将会被阻塞。

(3) try-locking 初始化

新创建的 unique\_lock 对象管理 Mutex 对象 m，并尝试调用 m.try\_lock() 对 Mutex 对象进行上锁，但如果上锁不成功，并不会阻塞当前线程。

(4) deferred 初始化

新创建的 unique\_lock 对象管理 Mutex 对象 m，但是在初始化的时候并不锁住 Mutex 对象。  m 应该是一个没有当前线程锁住的 Mutex 对象。

(5) adopting 初始化

新创建的 unique\_lock 对象管理 Mutex 对象 m，  m 应该是一个已经被当前线程锁住的 Mutex 对象。(并且当前新创建的 unique\_lock 对象拥有对锁(Lock)的所有权)。

(6) locking 一段时间(duration)

新创建的 unique\_lock 对象管理 Mutex 对象 m，并试图通过调用 m.try\_lock\_for(rel\_time) 来锁住 Mutex 对象一段时间(rel\_time)。

(7) locking 直到某个时间点(time point)

新创建的 unique\_lock 对象管理 Mutex 对象m，并试图通过调用 m.try\_lock\_until(abs\_time) 来在某个时间点(abs\_time)之前锁住 Mutex 对象。

(8) 拷贝构造 \[被禁用\]

unique\_lock 对象不能被拷贝构造。

(9) 移动(move)构造

新创建的 unique\_lock 对象获得了由 x 所管理的 Mutex 对象的所有权(包括当前 Mutex 的状态)。调用 move 构造之后，  x 对象如同通过默认构造函数所创建的，就不再管理任何 Mutex 对象了。

综上所述，由 (2) 和 (5) 创建的 unique\_lock 对象通常拥有 Mutex 对象的锁。而通过 (1) 和 (4) 创建的则不会拥有锁。通过 (3)，(6) 和 (7) 创建的 unique\_lock 对象，则在 lock 成功时获得锁。

关于unique\_lock 的构造函数，请看下面例子([参考][Link 7])：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::lock, std::unique_lock
                              // std::adopt_lock, std::defer_lock
    std::mutex foo,bar;
    
    void task_a () {
      std::lock (foo,bar);         // simultaneous lock (prevents deadlock)
      std::unique_lock<std::mutex> lck1 (foo,std::adopt_lock);
      std::unique_lock<std::mutex> lck2 (bar,std::adopt_lock);
      std::cout << "task a\n";
      // (unlocked automatically on destruction of lck1 and lck2)
    }
    
    void task_b () {
      // foo.lock(); bar.lock(); // replaced by:
      std::unique_lock<std::mutex> lck1, lck2;
      lck1 = std::unique_lock<std::mutex>(bar,std::defer_lock);
      lck2 = std::unique_lock<std::mutex>(foo,std::defer_lock);
      std::lock (lck1,lck2);       // simultaneous lock (prevents deadlock)
      std::cout << "task b\n";
      // (unlocked automatically on destruction of lck1 and lck2)
    }
    
    
    int main ()
    {
      std::thread th1 (task_a);
      std::thread th2 (task_b);
    
      th1.join();
      th2.join();
    
      return 0;
    }

![复制代码][copycode.gif]

### std::unique\_lock 移动(move assign)赋值操作 ###

std::unique\_lock 支持移动赋值(move assignment)，但是普通的赋值被禁用了，

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">move (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">unique_lock&amp; operator= (unique_lock&amp;&amp; x) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy [deleted] (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">unique_lock&amp; operator= (const unique_lock&amp;) = delete;</pre></td> 
  </tr> 
 </tbody> 
</table>

移动赋值(move assignment)之后，由 x 所管理的 Mutex 对象及其状态将会被新的 std::unique\_lock 对象取代。  
  
如果被赋值的对象之前已经获得了它所管理的 Mutex 对象的锁，则在移动赋值(move assignment)之前会调用 unlock 函数释放它所占有的锁。  
  
调用移动赋值(move assignment)之后， x 对象如同通过默认构造函数所创建的，也就不再管理任何 Mutex 对象了。请看下面例子([参考][Link 8])：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock
    
    std::mutex mtx;           // mutex for critical section
    
    void print_fifty (char c) {
      std::unique_lock<std::mutex> lck;         // default-constructed
      lck = std::unique_lock<std::mutex>(mtx);  // move-assigned
      for (int i=0; i<50; ++i) { std::cout << c; }
      std::cout << '\n';
    }
    
    int main ()
    {
      std::thread th1 (print_fifty,'*');
      std::thread th2 (print_fifty,'$');
    
      th1.join();
      th2.join();
    
      return 0;
    }

![复制代码][copycode.gif]

### std::unique\_lock 主要成员函数 ###

本节我们来看看 std::unique\_lock 的主要成员函数。由于 std::unique\_lock 比 std::lock\_guard 操作灵活，因此它提供了更多成员函数。具体分类如下：

1.  上锁/解锁操作：**lock，try\_lock，try\_lock\_for，try\_lock\_until **和** unlock**
2.  修改操作：移动赋值(move assignment)(前面已经介绍过了)，交换(swap)（与另一个 std::unique\_lock 对象交换它们所管理的 Mutex 对象的所有权），释放(release)（返回指向它所管理的 Mutex 对象的指针，并释放所有权）
3.  获取属性操作：owns\_lock（返回当前 std::unique\_lock 对象是否获得了锁）、operator bool()（与 owns\_lock 功能相同，返回当前 std::unique\_lock 对象是否获得了锁）、mutex（返回当前 std::unique\_lock 对象所管理的 Mutex 对象的指针）。

**std::unique\_lock::lock**请看下面例子([参考][Link 9])：

上锁操作，调用它所管理的 Mutex 对象的 lock 函数。如果在调用  Mutex 对象的 lock 函数时该 Mutex 对象已被另一线程锁住，则当前线程会被阻塞，直到它获得了锁。

该函数返回时，当前的 unique\_lock 对象便拥有了它所管理的 Mutex 对象的锁。如果上锁操作失败，则抛出 system\_error 异常。

![复制代码][copycode.gif]

// unique_lock::lock/unlock
    #include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock, std::defer_lock
    
    std::mutex mtx;           // mutex for critical section
    
    void print_thread_id (int id) {
      std::unique_lock<std::mutex> lck (mtx,std::defer_lock);
      // critical section (exclusive access to std::cout signaled by locking lck):
      lck.lock();
      std::cout << "thread #" << id << '\n';
      lck.unlock();
    }
    
    int main ()
    {
      std::thread threads[10];
      // spawn 10 threads:
      for (int i=0; i<10; ++i)
        threads[i] = std::thread(print_thread_id,i+1);
    
      for (auto& th : threads) th.join();
    
      return 0;
    }

![复制代码][copycode.gif]

**std::unique\_lock::try\_lock**

上锁操作，调用它所管理的 Mutex 对象的 try\_lock 函数，如果上锁成功，则返回 true，否则返回 false。

请看下面例子([参考][Link 10])：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <vector>         // std::vector
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock, std::defer_lock
    
    std::mutex mtx;           // mutex for critical section
    
    void print_star () {
      std::unique_lock<std::mutex> lck(mtx,std::defer_lock);
      // print '*' if successfully locked, 'x' otherwise: 
      if (lck.try_lock())
        std::cout << '*';
      else                    
        std::cout << 'x';
    }
    
    int main ()
    {
      std::vector<std::thread> threads;
      for (int i=0; i<500; ++i)
        threads.emplace_back(print_star);
    
      for (auto& x: threads) x.join();
    
      return 0;
    }

![复制代码][copycode.gif]

**std::unique\_lock::try\_lock\_for**

上锁操作，调用它所管理的 Mutex 对象的 try\_lock\_for 函数，如果上锁成功，则返回 true，否则返回 false。

请看下面例子([参考][Link 11])：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <chrono>         // std::chrono::milliseconds
    #include <thread>         // std::thread
    #include <mutex>          // std::timed_mutex, std::unique_lock, std::defer_lock
    
    std::timed_mutex mtx;
    
    void fireworks () {
      std::unique_lock<std::timed_mutex> lck(mtx,std::defer_lock);
      // waiting to get a lock: each thread prints "-" every 200ms:
      while (!lck.try_lock_for(std::chrono::milliseconds(200))) {
        std::cout << "-";
      }
      // got a lock! - wait for 1s, then this thread prints "*"
      std::this_thread::sleep_for(std::chrono::milliseconds(1000));
      std::cout << "*\n";
    }
    
    int main ()
    {
      std::thread threads[10];
      // spawn 10 threads:
      for (int i=0; i<10; ++i)
        threads[i] = std::thread(fireworks);
    
      for (auto& th : threads) th.join();
    
      return 0;
    }

![复制代码][copycode.gif]

**std::unique\_lock::try\_lock\_until**

上锁操作，调用它所管理的 Mutex 对象的 try\_lock\_for 函数，如果上锁成功，则返回 true，否则返回 false。

请看下面例子([参考][Link 12])：

![复制代码][copycode.gif]

**std::unique\_lock::unlock**

解锁操作，调用它所管理的 Mutex 对象的 unlock 函数。

请看下面例子(参考)：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock, std::defer_lock
    
    std::mutex mtx;           // mutex for critical section
    
    void print_thread_id (int id) {
      std::unique_lock<std::mutex> lck (mtx,std::defer_lock);
      // critical section (exclusive access to std::cout signaled by locking lck):
      lck.lock();
      std::cout << "thread #" << id << '\n';
      lck.unlock();
    }
    
    int main ()
    {
      std::thread threads[10];
      // spawn 10 threads:
      for (int i=0; i<10; ++i)
        threads[i] = std::thread(print_thread_id,i+1);
    
      for (auto& th : threads) th.join();
    
      return 0;
    }

![复制代码][copycode.gif]

**std::unique\_lock::release**

返回指向它所管理的 Mutex 对象的指针，并释放所有权。

请看下面例子([参考][Link 13])：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <vector>         // std::vector
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock
    
    std::mutex mtx;
    int count = 0;
    
    void print_count_and_unlock (std::mutex* p_mtx) {
      std::cout << "count: " << count << '\n';
      p_mtx->unlock();
    }
    
    void task() {
      std::unique_lock<std::mutex> lck(mtx);
      ++count;
      print_count_and_unlock(lck.release());
    }
    
    int main ()
    {
      std::vector<std::thread> threads;
      for (int i=0; i<10; ++i)
        threads.emplace_back(task);
    
      for (auto& x: threads) x.join();
    
      return 0;
    }

![复制代码][copycode.gif]

**std::unique\_lock::owns\_lock**

返回当前 std::unique\_lock 对象是否获得了锁。

请看下面例子(参考)：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <vector>         // std::vector
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock, std::try_to_lock
    
    std::mutex mtx;           // mutex for critical section
    
    void print_star () {
      std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);
      // print '*' if successfully locked, 'x' otherwise: 
      if (lck.owns_lock())
        std::cout << '*';
      else                    
        std::cout << 'x';
    }
    
    int main ()
    {
      std::vector<std::thread> threads;
      for (int i=0; i<500; ++i)
        threads.emplace_back(print_star);
    
      for (auto& x: threads) x.join();
    
      return 0;
    }

![复制代码][copycode.gif]

**std::unique\_lock::operator bool()**

与 owns\_lock 功能相同，返回当前 std::unique\_lock 对象是否获得了锁。

请看下面例子([参考][Link 14])：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <vector>         // std::vector
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock, std::try_to_lock
    
    std::mutex mtx;           // mutex for critical section
    
    void print_star () {
      std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);
      // print '*' if successfully locked, 'x' otherwise: 
      if (lck)
        std::cout << '*';
      else                    
        std::cout << 'x';
    }
    
    int main ()
    {
      std::vector<std::thread> threads;
      for (int i=0; i<500; ++i)
        threads.emplace_back(print_star);
    
      for (auto& x: threads) x.join();
    
      return 0;
    }

![复制代码][copycode.gif]

**std::unique\_lock::mutex**

返回当前 std::unique\_lock 对象所管理的 Mutex 对象的指针。

请看下面例子([参考][Link 15])：

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <mutex>          // std::mutex, std::unique_lock, std::defer_lock
    
    class MyMutex : public std::mutex {
      int _id;
    public:
      MyMutex (int id) : _id(id) {}
      int id() {
       return _id;}
    };
    
    MyMutex mtx (101);
    
    void print_ids (int id) {
      std::unique_lock<MyMutex> lck (mtx);
      std::cout << "thread #" << id << " locked mutex " << lck.mutex()->id() << '\n';
    }
    
    int main ()
    {
      std::thread threads[10];
      // spawn 10 threads:
      for (int i=0; i<10; ++i)
        threads[i] = std::thread(print_ids,i+1);
    
      for (auto& th : threads) th.join();
    
      return 0;
    }

![复制代码][copycode.gif]

好了，本文先介绍到这里，我们基本上介绍完了 C++11 多线程编程中两种最基本的锁类型，后面我会继续更新有关 C++11 并发编程的博客，希望感兴趣的同学继续关注 ;-)

## [C++11 并发指南四(<future> 详解一 std::promise 介绍)][C_11 _future_ _ std_promise] ##

前面两讲《[C++11 并发指南二(std::thread 详解)][C_11 _std_thread]》，《[C++11 并发指南三(std::mutex 详解)][C_11 _std_mutex]》分别介绍了 std::thread 和 std::mutex，相信读者对 C++11 中的多线程编程有了一个最基本的认识，本文将介绍 C++11 标准中 <future> 头文件里面的类和相关函数。

<future> 头文件中包含了以下几个类和函数：

*  Providers 类：std::promise, std::package\_task
 *  Futures 类：std::future, shared\_future.
 *  Providers 函数：std::async()
 *  其他类型：std::future\_error, std::future\_errc, std::future\_status, std::launch.

### std::promise 类介绍 ###

promise 对象可以保存某一类型 T 的值，该值可被 future 对象读取（可能在另外一个线程中），因此 promise 也提供了一种线程同步的手段。在 promise 对象构造时可以和一个共享状态（通常是std::future）相关联，并可以在相关联的共享状态(std::future)上保存一个类型为 T 的值。

可以通过 get\_future 来获取与该 promise 对象相关联的 future 对象，调用该函数之后，两个对象共享相同的共享状态(shared state)

*  promise 对象是异步 Provider，它可以在某一时刻设置共享状态的值。
 *  future 对象可以异步返回共享状态的值，或者在必要的情况下阻塞调用者并等待共享状态标志变为 ready，然后才能获取共享状态的值。

下面以一个简单的例子来说明上述关系

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <functional>     // std::ref
    #include <thread>         // std::thread
    #include <future>         // std::promise, std::future
    
    void print_int(std::future<int>& fut) {
        int x = fut.get(); // 获取共享状态的值.
        std::cout << "value: " << x << '\n'; // 打印 value: 10.
    }
    
    int main ()
    {
        std::promise<int> prom; // 生成一个 std::promise<int> 对象.
        std::future<int> fut = prom.get_future(); // 和 future 关联.
        std::thread t(print_int, std::ref(fut)); // 将 future 交给另外一个线程t.
        prom.set_value(10); // 设置共享状态的值, 此处和线程t保持同步.
        t.join();
        return 0;
    }

![复制代码][copycode.gif]

#### std::promise 构造函数 ####

1.  默认构造函数，初始化一个空的共享状态。
2.  带自定义内存分配器的构造函数，与默认构造函数类似，但是使用自定义分配器来分配共享状态。
3.  拷贝构造函数，被禁用。
4.  移动构造函数。

另外，std::promise 的 operator= 没有拷贝语义，即 std::promise 普通的赋值操作被禁用，operator= 只有 move 语义，所以 std::promise 对象是禁止拷贝的。

例子:

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <thread>         // std::thread
    #include <future>         // std::promise, std::future
    
    std::promise<int> prom;
    
    void print_global_promise () {
        std::future<int> fut = prom.get_future();
        int x = fut.get();
        std::cout << "value: " << x << '\n';
    }
    
    int main ()
    {
        std::thread th1(print_global_promise);
        prom.set_value(10);
        th1.join();
    
        prom = std::promise<int>();    // prom 被move赋值为一个新的 promise 对象.
    
        std::thread th2 (print_global_promise);
        prom.set_value (20);
        th2.join();
    
      return 0;
    }

![复制代码][copycode.gif]

####  std::promise::get\_future 介绍 ####

该函数返回一个与 promise 共享状态相关联的 future *。*返回的 future 对象可以访问由 promise 对象设置在共享状态上的值或者某个异常对象。只能从 promise 共享状态获取一个 future 对象。在调用该函数之后，promise 对象通常会在某个时间点准备好(设置一个值或者一个异常对象)，如果不设置值或者异常，promise 对象在析构时会自动地设置一个 future\_error 异常(broken\_promise)来设置其自身的准备状态。上面的例子中已经提到了 get\_future，此处不再重复。

#### std::promise::set\_value 介绍 ####

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">generic template (1)</span></th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;"><span style="font-size: 14px;">void set_value (const T&amp; val);
void set_value (T&amp;&amp; val);
</span></pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">specializations (2)</span></th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;"><span style="font-size: 14px;">void promise&lt;R&amp;&gt;::set_value (R&amp; val);   // when T is a reference type (R&amp;)
void promise&lt;void&gt;::set_value (void);   // when T is void</span></pre></td> 
  </tr> 
 </tbody> 
</table>

设置共享状态的值，此后 promise 的共享状态标志变为 ready.

####  std::promise::set\_exception 介绍 ####

为 promise 设置异常，此后 promise 的共享状态变标志变为 ready，例子如下，线程1从终端接收一个整数，线程2将该整数打印出来，如果线程1接收一个非整数，则为 promise 设置一个异常(failbit) ，线程2 在std::future::get 是抛出该异常。

![复制代码][copycode.gif]

#include <iostream>       // std::cin, std::cout, std::ios
    #include <functional>     // std::ref
    #include <thread>         // std::thread
    #include <future>         // std::promise, std::future
    #include <exception>      // std::exception, std::current_exception
    
    void get_int(std::promise<int>& prom) {
        int x;
        std::cout << "Please, enter an integer value: ";
        std::cin.exceptions (std::ios::failbit);   // throw on failbit
        try {
            std::cin >> x;                         // sets failbit if input is not int
            prom.set_value(x);
        } catch (std::exception&) {
            prom.set_exception(std::current_exception());
        }
    }
    
    void print_int(std::future<int>& fut) {
        try {
            int x = fut.get();
            std::cout << "value: " << x << '\n';
        } catch (std::exception& e) {
            std::cout << "[exception caught: " << e.what() << "]\n";
        }
    }
    
    int main ()
    {
        std::promise<int> prom;
        std::future<int> fut = prom.get_future();
    
        std::thread th1(get_int, std::ref(prom));
        std::thread th2(print_int, std::ref(fut));
    
        th1.join();
        th2.join();
        return 0;
    }

![复制代码][copycode.gif]

#### std::promise::set\_value\_at\_thread\_exit 介绍 ####

设置共享状态的值，但是不将共享状态的标志设置为 ready，当线程退出时该 promise 对象会自动设置为 ready。如果某个 std::future 对象与该 promise 对象的共享状态相关联，并且该 future 正在调用 get，则调用 get 的线程会被阻塞，当线程退出时，调用 future::get 的线程解除阻塞，同时 get 返回 set\_value\_at\_thread\_exit 所设置的值。注意，该函数已经设置了 promise 共享状态的值，如果在线程结束之前有其他设置或者修改共享状态的值的操作，则会抛出 future\_error( promise\_already\_satisfied )。

#### std::promise::swap 介绍 ####

交换 promise 的共享状态。

## [C++11 并发指南四(<future> 详解二 std::packaged\_task 介绍)][C_11 _future_ _ std_packaged_task] ##

上一讲《[C++11 并发指南四(<future> 详解一 std::promise 介绍)][C_11 _future_ _ std_promise]》主要介绍了 <future> 头文件中的 std::promise 类，本文主要介绍std::packaged\_task。

std::packaged\_task 包装一个可调用的对象，并且允许异步获取该可调用对象产生的结果，从包装可调用对象意义上来讲，std::packaged\_task 与 std::function 类似，只不过 std::packaged\_task 将其包装的可调用对象的执行结果传递给一个 std::future 对象（该对象通常在另外一个线程中获取 std::packaged\_task 任务的执行结果）。

std::packaged\_task 对象内部包含了两个最基本元素，一、被包装的任务(stored task)，任务(task)是一个可调用的对象，如函数指针、成员函数指针或者函数对象，二、共享状态(shared state)，用于保存任务的返回值，可以通过 std::future 对象来达到异步访问共享状态的效果。

可以通过 std::packged\_task::get\_future 来获取与共享状态相关联的 std::future 对象。在调用该函数之后，两个对象共享相同的共享状态，具体解释如下：

*  std::packaged\_task 对象是异步 Provider，它在某一时刻通过调用被包装的任务来设置共享状态的值。
 *  std::future 对象是一个异步返回对象，通过它可以获得共享状态的值，当然在必要的时候需要等待共享状态标志变为 ready.

std::packaged\_task 的共享状态的生命周期一直持续到最后一个与之相关联的对象被释放或者销毁为止。下面一个小例子大致讲了 std::packaged\_task 的用法：

![复制代码][copycode.gif]

#include <iostream>     // std::cout
    #include <future>       // std::packaged_task, std::future
    #include <chrono>       // std::chrono::seconds
    #include <thread>       // std::thread, std::this_thread::sleep_for
    
    // count down taking a second for each value:
    int countdown (int from, int to) {
        for (int i=from; i!=to; --i) {
            std::cout << i << '\n';
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        std::cout << "Finished!\n";
        return from - to;
    }
    
    int main ()
    {
        std::packaged_task<int(int,int)> task(countdown); // 设置 packaged_task
        std::future<int> ret = task.get_future(); // 获得与 packaged_task 共享状态相关联的 future 对象.
    
        std::thread th(std::move(task), 10, 0);   //创建一个新线程完成计数任务.
    
        int value = ret.get();                    // 等待任务完成并获取结果.
    
        std::cout << "The countdown lasted for " << value << " seconds.\n";
    
        th.join();
        return 0;
    }

![复制代码][copycode.gif]

执行结果为：

![复制代码][copycode.gif]

concurrency ) ./Packaged_Task1 
    10
    9
    8
    7
    6
    5
    4
    3
    2
    1
    Finished!
    The countdown lasted for 10 seconds.

![复制代码][copycode.gif]

**std::packaged\_task 构造函数**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">default (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">packaged_task() noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">initialization (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Fn&gt;
  explicit packaged_task (Fn&amp;&amp; fn);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">with allocator (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Fn, class Alloc&gt;
  explicit packaged_task (allocator_arg_t aa, const Alloc&amp; alloc, Fn&amp;&amp; fn);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy [deleted] (4)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">packaged_task (const packaged_task&amp;) = delete;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">move (5)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">packaged_task (packaged_task&amp;&amp; x) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

std::packaged\_task 构造函数共有 5 中形式，不过拷贝构造已经被禁用了。下面简单地介绍一下上述几种构造函数的语义：

1.  默认构造函数，初始化一个空的共享状态，并且该 packaged\_task 对象无包装任务。
2.  初始化一个共享状态，并且被包装任务由参数 fn 指定。
3.  带自定义内存分配器的构造函数，与默认构造函数类似，但是使用自定义分配器来分配共享状态。
4.  拷贝构造函数，被禁用。
5.  移动构造函数。

下面例子介绍了各类构造函数的用法：

![复制代码][copycode.gif]

#include <iostream>     // std::cout
    #include <utility>      // std::move
    #include <future>       // std::packaged_task, std::future
    #include <thread>       // std::thread
    
    int main ()
    {
        std::packaged_task<int(int)> foo; // 默认构造函数.
    
        // 使用 lambda 表达式初始化一个 packaged_task 对象.
        std::packaged_task<int(int)> bar([](int x){
       return x*2;});
    
        foo = std::move(bar); // move-赋值操作，也是 C++11 中的新特性.
    
        // 获取与 packaged_task 共享状态相关联的 future 对象.
        std::future<int> ret = foo.get_future();
    
        std::thread(std::move(foo), 10).detach(); // 产生线程，调用被包装的任务.
    
        int value = ret.get(); // 等待任务完成并获取结果.
        std::cout << "The double of 10 is " << value << ".\n";
    
    return 0;
    }

![复制代码][copycode.gif]

与 std::promise 类似， std::packaged\_task 也禁用了普通的赋值操作运算，只允许 move 赋值运算。

**std::packaged\_task::valid 介绍**

检查当前 packaged\_task 是否和一个有效的共享状态相关联，对于由默认构造函数生成的 packaged\_task 对象，该函数返回 false，除非中间进行了 move 赋值操作或者 swap 操作。

请看下例：

![复制代码][copycode.gif]

#include <iostream>     // std::cout
    #include <utility>      // std::move
    #include <future>       // std::packaged_task, std::future
    #include <thread>       // std::thread
    
    // 在新线程中启动一个 int(int) packaged_task.
    std::future<int> launcher(std::packaged_task<int(int)>& tsk, int arg)
    {
        if (tsk.valid()) {
            std::future<int> ret = tsk.get_future();
            std::thread (std::move(tsk),arg).detach();
            return ret;
        }
        else return std::future<int>();
    }
    
    int main ()
    {
        std::packaged_task<int(int)> tsk([](int x){
       return x*2;});
    
        std::future<int> fut = launcher(tsk,25);
    
        std::cout << "The double of 25 is " << fut.get() << ".\n";
    
        return 0;
    }

![复制代码][copycode.gif]

**std::packaged\_task::get\_future 介绍**

返回一个与 packaged\_task 对象共享状态相关的 future 对象。返回的 future 对象可以获得由另外一个线程在该 packaged\_task 对象的共享状态上设置的某个值或者异常。

请看例子(其实前面已经讲了 get\_future 的例子)：

![复制代码][copycode.gif]

#include <iostream>     // std::cout
    #include <utility>      // std::move
    #include <future>       // std::packaged_task, std::future
    #include <thread>       // std::thread
    
    int main ()
    {
        std::packaged_task<int(int)> tsk([](int x) { return x * 3; })); // package task
    
        std::future<int> fut = tsk.get_future();   // 获取 future 对象.
    
        std::thread(std::move(tsk), 100).detach();   // 生成新线程并调用packaged_task.
    
        int value = fut.get();                     // 等待任务完成, 并获取结果.
    
        std::cout << "The triple of 100 is " << value << ".\n";
    
        return 0;
    }

![复制代码][copycode.gif]

**std::packaged\_task::operator()(Args... args) 介绍**

调用该 packaged\_task 对象所包装的对象(通常为函数指针，函数对象，lambda 表达式等)，传入的参数为 args. 调用该函数一般会发生两种情况：

*  如果成功调用 packaged\_task 所包装的对象，则返回值（如果被包装的对象有返回值的话）被保存在 packaged\_task 的共享状态中。
 *  如果调用 packaged\_task 所包装的对象失败，并且抛出了异常，则异常也会被保存在 packaged\_task 的共享状态中。

以上两种情况都使共享状态的标志变为 ready，因此其他等待该共享状态的线程可以获取共享状态的值或者异常并继续执行下去。

共享状态的值可以通过在 future 对象(由 get\_future获得)上调用 get 来获得。

由于被包装的任务在 packaged\_task 构造时指定，因此调用 operator() 的效果由 packaged\_task 对象构造时所指定的可调用对象来决定：

*  如果被包装的任务是函数指针或者函数对象，调用 std::packaged\_task::operator() 只是将参数传递给被包装的对象。
 *  如果被包装的任务是指向类的非静态成员函数的指针，那么 std::packaged\_task::operator() 的第一个参数应该指定为成员函数被调用的那个对象，剩余的参数作为该成员函数的参数。
 *  如果被包装的任务是指向类的非静态成员变量，那么 std::packaged\_task::operator() 只允许单个参数。

**std::packaged\_task::make\_ready\_at\_thread\_exit 介绍**

该函数会调用被包装的任务，并向任务传递参数，类似 std::packaged\_task 的 operator() 成员函数。但是与 operator() 函数不同的是，make\_ready\_at\_thread\_exit 并不会立即设置共享状态的标志为 ready，而是在线程退出时设置共享状态的标志。

如果与该 packaged\_task 共享状态相关联的 future 对象在 future::get 处等待，则当前的 future::get 调用会被阻塞，直到线程退出。而一旦线程退出，future::get 调用继续执行，或者抛出异常。  
  
注意，该函数已经设置了 promise 共享状态的值，如果在线程结束之前有其他设置或者修改共享状态的值的操作，则会抛出 future\_error( promise\_already\_satisfied )。

**std::packaged\_task::reset() 介绍**

重置 packaged\_task 的共享状态，但是保留之前的被包装的任务。请看例子，该例子中，packaged\_task 被重用了多次：

![复制代码][copycode.gif]

#include <iostream>     // std::cout
    #include <utility>      // std::move
    #include <future>       // std::packaged_task, std::future
    #include <thread>       // std::thread
    
    // a simple task:
    int triple (int x) { return x*3; }
    
    int main ()
    {
        std::packaged_task<int(int)> tsk (triple); // package task
    
    
        std::future<int> fut = tsk.get_future();
        std::thread (std::move(tsk), 100).detach();
        std::cout << "The triple of 100 is " << fut.get() << ".\n";
    
    
        // re-use same task object:
        tsk.reset();
        fut = tsk.get_future();
        std::thread(std::move(tsk), 200).detach();
        std::cout << "Thre triple of 200 is " << fut.get() << ".\n";
    
        return 0;
    }

![复制代码][copycode.gif]

**std::packaged\_task::swap() 介绍**

交换 packaged\_task 的共享状态。

好了，std::packaged\_task 介绍到这里，本文参考了 [http://www.cplusplus.com/reference/future/packaged\_task/][http_www.cplusplus.com_reference_future_packaged_task] 相关的内容。后一篇文章我将向大家介绍 std::future，std::shared\_future 以及 std::future\_error，另外还会介绍 <future> 头文件中的 std::async，std::future\_category 函数以及相关枚举类型。

## [C++11 并发指南四(<future> 详解三 std::future & std::shared\_future)][C_11 _future_ _ std_future _ std_shared_future] ##

上一讲《[C++11 并发指南四(<future> 详解二 std::packaged\_task 介绍)][C_11 _future_ _ std_packaged_task]》主要介绍了 <future> 头文件中的 std::packaged\_task 类，本文主要介绍 std::future，std::shared\_future 以及 std::future\_error，另外还会介绍 <future> 头文件中的 std::async，std::future\_category 函数以及相关枚举类型。

### std::future 介绍 ###

前面已经多次提到过 std::future，那么 std::future 究竟是什么呢？简单地说，std::future 可以用来获取异步任务的结果，因此可以把它当成一种简单的线程间同步的手段。std::future 通常由某个 Provider 创建，你可以把 Provider 想象成一个异步任务的提供者，Provider 在某个线程中设置共享状态的值，与该共享状态相关联的 std::future 对象调用 get（通常在另外一个线程中） 获取该值，如果共享状态的标志不为 ready，则调用 std::future::get 会阻塞当前的调用者，直到 Provider 设置了共享状态的值（此时共享状态的标志变为 ready），std::future::get 返回异步任务的值或异常（如果发生了异常）。

一个有效(valid)的 std::future 对象通常由以下三种 Provider 创建，并和某个共享状态相关联。Provider 可以是函数或者类，其实我们前面都已经提到了，他们分别是：

*  std::async 函数，本文后面会介绍 std::async() 函数。
 *  std::promise::get\_future，get\_future 为 promise 类的成员函数，详见 [C++11 并发指南四(<future> 详解一 std::promise 介绍)][C_11 _future_ _ std_promise]。
 *  std::packaged\_task::get\_future，此时 get\_future为 packaged\_task 的成员函数，详见[C++11 并发指南四(<future> 详解二 std::packaged\_task 介绍)][C_11 _future_ _ std_packaged_task]。

一个 std::future 对象只有在有效(valid)的情况下才有用(useful)，由 std::future 默认构造函数创建的 future 对象不是有效的（除非当前非有效的 future 对象被 move 赋值另一个有效的 future 对象）。

在一个有效的 future 对象上调用 get 会阻塞当前的调用者，直到 Provider 设置了共享状态的值或异常（此时共享状态的标志变为 ready），std::future::get 将返回异步任务的值或异常（如果发生了异常）。

下面以一个[简单的例子][Link 16]说明上面一段文字吧（[参考][Link 16]）：

![复制代码][copycode.gif]

// future example
    #include <iostream>             // std::cout
    #include <future>               // std::async, std::future
    #include <chrono>               // std::chrono::milliseconds
    
    // a non-optimized way of checking for prime numbers:
    bool
    is_prime(int x)
    {
        for (int i = 2; i < x; ++i)
            if (x % i == 0)
                return false;
        return true;
    }
    
    int
    main()
    {
        // call function asynchronously:
        std::future < bool > fut = std::async(is_prime, 444444443);
    
        // do something while waiting for function to set future:
        std::cout << "checking, please wait";
        std::chrono::milliseconds span(100);
        while (fut.wait_for(span) == std::future_status::timeout)
            std::cout << '.';
    
        bool x = fut.get();         // retrieve return value
    
        std::cout << "\n444444443 " << (x ? "is" : "is not") << " prime.\n";
    
        return 0;
    }

![复制代码][copycode.gif]

####  std::future 成员函数 ####

**std::future 构造函数**

std::future 一般由 std::async, std::promise::get\_future, std::packaged\_task::get\_future 创建，不过也提供了构造函数，如下表所示：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">default (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">future() noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy [deleted] (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">future (const future&amp;) = delete;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">move (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">future (future&amp;&amp; x) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

不过 std::future 的拷贝构造函数是被禁用的，只提供了默认的构造函数和 move 构造函数（注：C++ 新特新）。另外，std::future 的普通赋值操作也被禁用，只提供了 move 赋值操作。如下代码所示：

std::future<int> fut;           // 默认构造函数
      fut = std::async(do_some_task);   // move-赋值操作。

**std::future::share()**

返回一个 std::shared\_future 对象（本文后续内容将介绍 std::shared\_future ），调用该函数之后，该 std::future 对象本身已经不和任何共享状态相关联，因此该 std::future 的状态不再是 valid 的了。

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <future>         // std::async, std::future, std::shared_future
    
    int do_get_value() { return 10; }
    
    int main ()
    {
        std::future<int> fut = std::async(do_get_value);
        std::shared_future<int> shared_fut = fut.share();
    
        // 共享的 future 对象可以被多次访问.
        std::cout << "value: " << shared_fut.get() << '\n';
        std::cout << "its double: " << shared_fut.get()*2 << '\n';
    
        return 0;
    }

![复制代码][copycode.gif]

**std::future::get()**

std::future::get 一共有三种形式，如下表所示（[参考][Link 17]）：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">generic template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T get();
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">reference specialization (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">R&amp; future&lt;R&amp;&gt;::get();       // when T is a reference type (R&amp;)
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">void specialization (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">void future&lt;void&gt;::get();   // when T is void</pre></td> 
  </tr> 
 </tbody> 
</table>

当与该 std::future 对象相关联的共享状态标志变为 ready 后，调用该函数将返回保存在共享状态中的值，如果共享状态的标志不为 ready，则调用该函数会阻塞当前的调用者，而此后一旦共享状态的标志变为 ready，get 返回 Provider 所设置的共享状态的值或者异常（如果抛出了异常）。

请看下面的程序：

![复制代码][copycode.gif]

**std::future::valid()**

检查当前的 std::future 对象是否有效，即释放与某个共享状态相关联。一个有效的 std::future 对象只能通过 std::async(), std::future::get\_future 或者 std::packaged\_task::get\_future 来初始化。另外由 std::future 默认构造函数创建的 std::future 对象是无效(invalid)的，当然通过 std::future 的 move 赋值后该 std::future 对象也可以变为 valid。

![复制代码][copycode.gif]

#include <iostream>       // std::cout
    #include <future>         // std::async, std::future
    #include <utility>        // std::move
    
    int do_get_value() { return 11; }
    
    int main ()
    {
        // 由默认构造函数创建的 std::future 对象,
        // 初始化时该 std::future 对象处于为 invalid 状态.
        std::future<int> foo, bar;
        foo = std::async(do_get_value); // move 赋值, foo 变为 valid.
        bar = std::move(foo); // move 赋值, bar 变为 valid, 而 move 赋值以后 foo 变为 invalid.
    
        if (foo.valid())
            std::cout << "foo's value: " << foo.get() << '\n';
        else
            std::cout << "foo is not valid\n";
    
        if (bar.valid())
            std::cout << "bar's value: " << bar.get() << '\n';
        else
            std::cout << "bar is not valid\n";
    
        return 0;
    }

![复制代码][copycode.gif]

**std::future::wait()**

等待与当前std::future 对象相关联的共享状态的标志变为 ready.

如果共享状态的标志不是 ready（此时 Provider 没有在共享状态上设置值（或者异常）），调用该函数会被阻塞当前线程，直到共享状态的标志变为 ready。  
一旦共享状态的标志变为 ready，wait() 函数返回，当前线程被解除阻塞，但是 wait() 并不读取共享状态的值或者异常。下面的代码说明了 std::future::wait() 的用法（[参考][Link 18]）

![复制代码][copycode.gif]

#include <iostream>                // std::cout
    #include <future>                // std::async, std::future
    #include <chrono>                // std::chrono::milliseconds
    
    // a non-optimized way of checking for prime numbers:
    bool do_check_prime(int x) // 为了体现效果, 该函数故意没有优化.
    {
        for (int i = 2; i < x; ++i)
            if (x % i == 0)
                return false;
        return true;
    }
    
    int main()
    {
        // call function asynchronously:
        std::future < bool > fut = std::async(do_check_prime, 194232491);
    
        std::cout << "Checking...\n";
        fut.wait();
    
        std::cout << "\n194232491 ";
        if (fut.get()) // guaranteed to be ready (and not block) after wait returns
            std::cout << "is prime.\n";
        else
            std::cout << "is not prime.\n";
    
        return 0;
    }

![复制代码][copycode.gif]

执行结果如下：

concurrency ) ./Future-wait 
    Checking...
    
    194232491 is prime.
    concurrency )

**std::future::wait\_for()**

与 std::future::wait() 的功能类似，即等待与该 std::future 对象相关联的共享状态的标志变为 ready，该函数原型如下：

template <class Rep, class Period>
      future_status wait_for (const chrono::duration<Rep,Period>& rel_time) const;

而与 std::future::wait() 不同的是，wait\_for() 可以设置一个时间段 rel\_time，如果共享状态的标志在该时间段结束之前没有被 Provider 设置为 ready，则调用 wait\_for 的线程被阻塞，在等待了 rel\_time 的时间长度后 wait\_until() 返回，返回值如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">返回值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">描述</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::ready</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">共享状态的标志已经变为 ready，即 Provider 在共享状态上设置了值或者异常。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::timeout</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">超时，即在规定的时间内共享状态的标志没有变为 ready。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::deferred</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">共享状态包含一个&nbsp;<em>deferred</em>&nbsp;函数。</span></td> 
  </tr> 
 </tbody> 
</table>

请看下面的例子：

![复制代码][copycode.gif]

#include <iostream>                // std::cout
    #include <future>                // std::async, std::future
    #include <chrono>                // std::chrono::milliseconds
    
    // a non-optimized way of checking for prime numbers:
    bool do_check_prime(int x) // 为了体现效果, 该函数故意没有优化.
    {
        for (int i = 2; i < x; ++i)
            if (x % i == 0)
                return false;
        return true;
    }
    
    int main()
    {
        // call function asynchronously:
        std::future < bool > fut = std::async(do_check_prime, 194232491);
    
        std::cout << "Checking...\n";
        std::chrono::milliseconds span(1000); // 设置超时间隔.
    
        // 如果超时，则输出"."，继续等待
        while (fut.wait_for(span) == std::future_status::timeout)
            std::cout << '.';
    
        std::cout << "\n194232491 ";
        if (fut.get()) // guaranteed to be ready (and not block) after wait returns
            std::cout << "is prime.\n";
        else
            std::cout << "is not prime.\n";
    
        return 0;
    }

![复制代码][copycode.gif]

**std::future::wait\_until()**

与 std::future::wait() 的功能类似，即等待与该 std::future 对象相关联的共享状态的标志变为 ready，该函数原型如下：

template <class Rep, class Period>
      future_status wait_until (const chrono::time_point<Clock,Duration>& abs_time) const;

而 与 std::future::wait() 不同的是，wait\_until() 可以设置一个系统绝对时间点 abs\_time，如果共享状态的标志在该时间点到来之前没有被 Provider 设置为 ready，则调用 wait\_until 的线程被阻塞，在 abs\_time 这一时刻到来之后 wait\_for() 返回，返回值如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">返回值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">描述</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::ready</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">共享状态的标志已经变为 ready，即 Provider 在共享状态上设置了值或者异常。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::timeout</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">超时，即在规定的时间内共享状态的标志没有变为 ready。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::deferred</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">共享状态包含一个&nbsp;<em>deferred</em>&nbsp;函数。</span></td> 
  </tr> 
 </tbody> 
</table>

## ##

### std::shared\_future 介绍 ###

std::shared\_future 与 std::future 类似，但是 std::shared\_future 可以拷贝、多个 std::shared\_future 可以共享某个共享状态的最终结果(即共享状态的某个值或者异常)。shared\_future 可以通过某个 std::future 对象隐式转换（参见 std::shared\_future 的构造函数），或者通过 std::future::share() 显示转换，无论哪种转换，被转换的那个 std::future 对象都会变为 not-valid.

**std::shared\_future 构造函数**

std::shared\_future 共有四种构造函数，如下表所示：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">default (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">shared_future() noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">shared_future (const shared_future&amp; x);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">move (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">shared_future (shared_future&amp;&amp; x) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">move from future (4)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">shared_future (future&lt;T&gt;&amp;&amp; x) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

最后 move from future(4) 即从一个有效的 std::future 对象构造一个 std::shared\_future，构造之后 std::future 对象 x 变为无效(not-valid)。

**std::shared\_future 其他成员函数**

std::shared\_future 的成员函数和 std::future 大部分相同，如下（每个成员函数都给出了连接）：

[**operator=**][operator]

赋值操作符，与 std::future 的赋值操作不同，std::shared\_future 除了支持 move 赋值操作外，还支持普通的赋值操作。

[**get**][get]

获取与该 std::shared\_future 对象相关联的共享状态的值（或者异常） 。

[**valid**][valid]

有效性检查 。

[**wait**][wait]

等待与该 std::shared\_future 对象相关联的共享状态的标志变为 ready 。

[**wait\_for**][wait_for]

等待与该 std::shared\_future 对象相关联的共享状态的标志变为 ready 。 （等待一段时间，超过该时间段wait\_for 返回。）

[**wait\_until**][wait_until]

等待与该 std::shared\_future 对象相关联的共享状态的标志变为 ready。（在某一时刻前等待，超过该时刻 wait\_until 返回。）

### std::future\_error 介绍 ###

class future_error : public logic_error;

std::future\_error 继承子 C++ 标准异常体系中的 logic\_error，有关 C++ 异常的继承体系，请参考相关的C++教程 ;-)。

### 其他与 std::future 相关的函数介绍 ###

与 std::future 相关的函数主要是 std::async()，原型如下：

上面两组 std::async() 的不同之处是第一类 std::async 没有指定异步任务（即执行某一函数）的启动策略(launch policy)，而第二类函数指定了启动策略，详见 std::launch 枚举类型，指定启动策略的函数的 policy 参数可以是launch::async，launch::deferred，以及两者的按位或( | )。

std::async() 的 fn 和 args 参数用来指定异步任务及其参数。另外，std::async() 返回一个 std::future 对象，通过该对象可以获取异步任务的值或异常（如果异步任务抛出了异常）。

下面介绍一下 std::async 的用法。

![复制代码][copycode.gif]

#include <stdio.h>
    #include <stdlib.h>
    
    #include <cmath>
    #include <chrono>
    #include <future>
    #include <iostream>
    
    double ThreadTask(int n) {
        std::cout << std::this_thread::get_id()
            << " start computing..." << std::endl;
    
        double ret = 0;
        for (int i = 0; i <= n; i++) {
            ret += std::sin(i);
        }
    
        std::cout << std::this_thread::get_id()
            << " finished computing..." << std::endl;
        return ret;
    }
    
    int main(int argc, const char *argv[])
    {
        std::future<double> f(std::async(std::launch::async, ThreadTask, 100000000));
    
    #if 0
        while(f.wait_until(std::chrono::system_clock::now() + std::chrono::seconds(1))
                != std::future_status::ready) {
            std::cout << "task is running...\n";
        }
    #else
        while(f.wait_for(std::chrono::seconds(1))
                != std::future_status::ready) {
            std::cout << "task is running...\n";
        }
    #endif
    
        std::cout << f.get() << std::endl;
    
        return EXIT_SUCCESS;
    }

![复制代码][copycode.gif]

### 其他与 std::future 相关的枚举类介绍 ###

下面介绍与 std::future 相关的枚举类型。与 std::future 相关的枚举类型包括：

enum class future_errc;

enum class future_status;

enum class launch;

下面分别介绍以上三种枚举类型：

**std::future\_errc 类型**

std::future\_errc 类型描述如下（[参考][Link 19]）：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">类型<br></span></th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>取值</code><br></span></th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">描述</span></th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">broken_promise</span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>0</code></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">与该 std::future 共享状态相关联的 std::promise 对象在设置值或者异常之前一被销毁。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">future_already_retrieved</span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>1</code></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">与该 std::future 对象相关联的共享状态的值已经被当前 Provider 获取了，即调用了 std::future::get 函数。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">promise_already_satisfied</span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>2</code></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">std::promise 对象已经对共享状态设置了某一值或者异常。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">no_state</span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>3</code></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">无共享状态。</span></td> 
  </tr> 
 </tbody> 
</table>

**std::future\_status 类型（[参考][Link 20]）**

std::future\_status 类型主要用在 std::future(或std::shared\_future)中的 wait\_for 和 wait\_until 两个函数中的。

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">类型</span></th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>取值<br></code></span></th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">描述</span></th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::ready</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>0</code></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">wait_for(或wait_until) 因为共享状态的标志变为 ready 而返回。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::timeout</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>1</code></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">超时，即&nbsp;wait_for(或wait_until) 因为在指定的时间段（或时刻）内共享状态的标志依然没有变为 ready而返回。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><a href="http://www.cplusplus.com/future_status" style="outline: none; text-decoration: none; color: rgb(61, 129, 238);" rel="nofollow">future_status::deferred</a></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;"><code>2</code></span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">共享状态包含了&nbsp;<em>deferred</em>&nbsp;函数。</span></td> 
  </tr> 
 </tbody> 
</table>

**std::launch 类型**

该枚举类型主要是在调用 std::async 设置异步任务的启动策略的。

请看下例（[参考][Link 21]）：

![复制代码][copycode.gif]

#include <iostream>                // std::cout
    #include <future>                // std::async, std::future, std::launch
    #include <chrono>                // std::chrono::milliseconds
    #include <thread>                // std::this_thread::sleep_for
    
    void
    do_print_ten(char c, int ms)
    {
        for (int i = 0; i < 10; ++i) {
            std::this_thread::sleep_for(std::chrono::milliseconds(ms));
            std::cout << c;
        }
    }
    
    int
    main()
    {
        std::cout << "with launch::async:\n";
        std::future < void >foo =
            std::async(std::launch::async, do_print_ten, '*', 100);
        std::future < void >bar =
            std::async(std::launch::async, do_print_ten, '@', 200);
        // async "get" (wait for foo and bar to be ready):
        foo.get();
        bar.get();
        std::cout << "\n\n";
    
        std::cout << "with launch::deferred:\n";
        foo = std::async(std::launch::deferred, do_print_ten, '*', 100);
        bar = std::async(std::launch::deferred, do_print_ten, '@', 200);
        // deferred "get" (perform the actual calls):
        foo.get();
        bar.get();
        std::cout << '\n';
    
        return 0;
    }

![复制代码][copycode.gif]

在我的机器上执行结果：

with launch::async:
    *@**@**@**@**@*@@@@@
    
    with launch::deferred:
    **********@@@@@@@@@@

## [C++11 并发指南五(std::condition\_variable 详解)][C_11 _std_condition_variable] ##

前面三讲《[C++11 并发指南二(std::thread 详解)][C_11 _std_thread]》，《[C++11 并发指南三(std::mutex 详解)][C_11 _std_mutex]》分别介绍了 std::thread，std::mutex，std::future 等相关内容，相信读者对 C++11 中的多线程编程有了一个最基本的认识，本文将介绍 C++11 标准中 <condition\_variable> 头文件里面的类和相关函数。

<condition\_variable > 头文件主要包含了与条件变量相关的类和函数。相关的类包括 std::condition\_variable 和 std::condition\_variable\_any，还有枚举类型std::cv\_status。另外还包括函数 std::notify\_all\_at\_thread\_exit()，下面分别介绍一下以上几种类型。

### std::condition\_variable 类介绍 ###

std::condition\_variable 是条件变量，更多有关条件变量的定义参考[维基百科][Link 22]。Linux 下使用 Pthread 库中的 pthread\_cond\_\*() 函数提供了与条件变量相关的功能， Windows 则参考 [MSDN][]。

当 std::condition\_variable 对象的某个 wait 函数被调用的时候，它使用 std::unique\_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞，直到另外一个线程在相同的 std::condition\_variable 对象上调用了 notification 函数来唤醒当前线程。

std::condition\_variable 对象通常使用 std::unique\_lock<std::mutex> 来等待，如果需要使用另外的 lockable 类型，可以使用 std::condition\_variable\_any 类，本文后面会讲到 std::condition\_variable\_any 的用法。

首先我们来看一个简单的[例子][Link 23]

![复制代码][copycode.gif]

#include <iostream>                // std::cout
    #include <thread>                // std::thread
    #include <mutex>                // std::mutex, std::unique_lock
    #include <condition_variable>    // std::condition_variable
    
    std::mutex mtx; // 全局互斥锁.
    std::condition_variable cv; // 全局条件变量.
    bool ready = false; // 全局标志位.
    
    void do_print_id(int id)
    {
        std::unique_lock <std::mutex> lck(mtx);
        while (!ready) // 如果标志位不为 true, 则等待...
            cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,
        // 线程被唤醒, 继续往下执行打印线程编号id.
        std::cout << "thread " << id << '\n';
    }
    
    void go()
    {
        std::unique_lock <std::mutex> lck(mtx);
        ready = true; // 设置全局标志位为 true.
        cv.notify_all(); // 唤醒所有线程.
    }
    
    int main()
    {
        std::thread threads[10];
        // spawn 10 threads:
        for (int i = 0; i < 10; ++i)
            threads[i] = std::thread(do_print_id, i);
    
        std::cout << "10 threads ready to race...\n";
        go(); // go!
    
      for (auto & th:threads)
            th.join();
    
        return 0;
    }

![复制代码][copycode.gif]

执行结果如下：

![复制代码][copycode.gif]

concurrency ) ./ConditionVariable-basic1 
    10 threads ready to race...
    thread 1
    thread 0
    thread 2
    thread 3
    thread 4
    thread 5
    thread 6
    thread 7
    thread 8
    thread 9

![复制代码][copycode.gif]

好了，对条件变量有了一个基本的了解之后，我们来看看 std::condition\_variable 的各个成员函数。

**std::condition\_variable 构造函数**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">default (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">condition_variable();
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy [deleted] (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">condition_variable (const condition_variable&amp;) = delete;</pre></td> 
  </tr> 
 </tbody> 
</table>

std::condition\_variable 的拷贝构造函数被禁用，只提供了默认构造函数。

**std::condition\_variable::wait() 介绍**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">unconditional (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">void wait (unique_lock&lt;mutex&gt;&amp; lck);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">predicate (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Predicate&gt;
  void wait (unique_lock&lt;mutex&gt;&amp; lck, Predicate pred);</pre></td> 
  </tr> 
 </tbody> 
</table>

std::condition\_variable 提供了两种 wait() 函数。当前线程调用 wait() 后将被阻塞(此时当前线程应该获得了锁（mutex），不妨设获得锁 lck)，直到另外某个线程调用 notify\_\* 唤醒了当前线程。

在线程被阻塞时，该函数会自动调用 `lck.unlock() 释放锁，使得其他被阻塞在锁竞争上的线程得以继续执行。`另外，一旦当前线程获得通知(notified，通常是另外某个线程调用 notify\_\* 唤醒了当前线程)，wait() 函数也是自动调用 lck.lock()，使得 lck 的状态和 wait 函数被调用时相同。  
  
在第二种情况下（即设置了 Predicate），只有当 pred 条件为 false 时调用 wait() 才会阻塞当前线程，并且在收到其他线程的通知后只有当 pred 为 true 时才会被解除阻塞。因此第二种情况类似以下代码：

while (!pred()) wait(lck);

请看下面例子（[参考][Link 24]）：

![复制代码][copycode.gif]

#include <iostream>                // std::cout
    #include <thread>                // std::thread, std::this_thread::yield
    #include <mutex>                // std::mutex, std::unique_lock
    #include <condition_variable>    // std::condition_variable
    
    std::mutex mtx;
    std::condition_variable cv;
    
    int cargo = 0;
    bool shipment_available()
    {
        return cargo != 0;
    }
    
    // 消费者线程.
    void consume(int n)
    {
        for (int i = 0; i < n; ++i) {
            std::unique_lock <std::mutex> lck(mtx);
            cv.wait(lck, shipment_available);
            std::cout << cargo << '\n';
            cargo = 0;
        }
    }
    
    int main()
    {
        std::thread consumer_thread(consume, 10); // 消费者线程.
    
        // 主线程为生产者线程, 生产 10 个物品.
        for (int i = 0; i < 10; ++i) {
            while (shipment_available())
                std::this_thread::yield();
            std::unique_lock <std::mutex> lck(mtx);
            cargo = i + 1;
            cv.notify_one();
        }
    
        consumer_thread.join();
    
        return 0;
    }

![复制代码][copycode.gif]

程序执行结果如下：

![复制代码][copycode.gif]

concurrency ) ./ConditionVariable-wait 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

![复制代码][copycode.gif]

**std::condition\_variable::wait\_for() 介绍**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">unconditional (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Rep, class Period&gt;
  cv_status wait_for (unique_lock&lt;mutex&gt;&amp; lck,
                      const chrono::duration&lt;Rep,Period&gt;&amp; rel_time);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">predicate (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Rep, class Period, class Predicate&gt;
       bool wait_for (unique_lock&lt;mutex&gt;&amp; lck,
                      const chrono::duration&lt;Rep,Period&gt;&amp; rel_time, Predicate pred);</pre></td> 
  </tr> 
 </tbody> 
</table>

与 **std::condition\_variable::wait()** 类似，不过 wait\_for 可以指定一个时间段，在当前线程收到通知或者指定的时间 rel\_time 超时之前，该线程都会处于阻塞状态。而一旦超时或者收到了其他线程的通知，wait\_for 返回，剩下的处理步骤和 wait() 类似。

另外，wait\_for 的重载版本（**predicte(2)**）的最后一个参数 pred 表示 wait\_for 的预测条件，只有当 pred 条件为 false 时调用 wait() 才会阻塞当前线程，并且在收到其他线程的通知后只有当 pred 为 true 时才会被解除阻塞，因此相当于如下代码：

return wait_until (lck, chrono::steady_clock::now() + rel_time, std::move(pred));

请看下面的例子（[参考][Link 25]），下面的例子中，主线程等待 th 线程输入一个值，然后将 th 线程从终端接收的值打印出来，在 th 线程接受到值之前，主线程一直等待，每个一秒超时一次，并打印一个 "."：

![复制代码][copycode.gif]

#include <iostream>           // std::cout
    #include <thread>             // std::thread
    #include <chrono>             // std::chrono::seconds
    #include <mutex>              // std::mutex, std::unique_lock
    #include <condition_variable> // std::condition_variable, std::cv_status
    
    std::condition_variable cv;
    
    int value;
    
    void do_read_value()
    {
        std::cin >> value;
        cv.notify_one();
    }
    
    int main ()
    {
        std::cout << "Please, enter an integer (I'll be printing dots): \n";
        std::thread th(do_read_value);
    
        std::mutex mtx;
        std::unique_lock<std::mutex> lck(mtx);
        while (cv.wait_for(lck,std::chrono::seconds(1)) == std::cv_status::timeout) {
            std::cout << '.';
            std::cout.flush();
        }
    
        std::cout << "You entered: " << value << '\n';
    
        th.join();
        return 0;
    }

![复制代码][copycode.gif]

**std::condition\_variable::wait\_until 介绍**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">unconditional (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Clock, class Duration&gt;
  cv_status wait_until (unique_lock&lt;mutex&gt;&amp; lck,
                        const chrono::time_point&lt;Clock,Duration&gt;&amp; abs_time);
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">predicate (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class Clock, class Duration, class Predicate&gt;
       bool wait_until (unique_lock&lt;mutex&gt;&amp; lck,
                        const chrono::time_point&lt;Clock,Duration&gt;&amp; abs_time,
                        Predicate pred);</pre></td> 
  </tr> 
 </tbody> 
</table>

与 **std::condition\_variable::wait\_for **类似，但是 wait\_until 可以指定一个时间点，在当前线程收到通知或者指定的时间点 abs\_time 超时之前，该线程都会处于阻塞状态。而一旦超时或者收到了其他线程的通知，wait\_until 返回，剩下的处理步骤和 wait\_until() 类似。

另外，wait\_until 的重载版本（**predicte(2)**）的最后一个参数 pred 表示 wait\_until 的预测条件，只有当 pred 条件为 false 时调用 wait() 才会阻塞当前线程，并且在收到其他线程的通知后只有当 pred 为 true 时才会被解除阻塞，因此相当于如下代码：

while (!pred())
      if ( wait_until(lck,abs_time) == cv_status::timeout)
        return pred();
    return true;

**std::condition\_variable::notify\_one() 介绍**

唤醒某个等待(wait)线程。如果当前没有等待线程，则该函数什么也不做，如果同时存在多个等待线程，则唤醒某个线程是不确定的(unspecified)。

请看下例（[参考][Link 26]）：

![复制代码][copycode.gif]

#include <iostream>                // std::cout
    #include <thread>                // std::thread
    #include <mutex>                // std::mutex, std::unique_lock
    #include <condition_variable>    // std::condition_variable
    
    std::mutex mtx;
    std::condition_variable cv;
    
    int cargo = 0; // shared value by producers and consumers
    
    void consumer()
    {
        std::unique_lock < std::mutex > lck(mtx);
        while (cargo == 0)
            cv.wait(lck);
        std::cout << cargo << '\n';
        cargo = 0;
    }
    
    void producer(int id)
    {
        std::unique_lock < std::mutex > lck(mtx);
        cargo = id;
        cv.notify_one();
    }
    
    int main()
    {
        std::thread consumers[10], producers[10];
    
        // spawn 10 consumers and 10 producers:
        for (int i = 0; i < 10; ++i) {
            consumers[i] = std::thread(consumer);
            producers[i] = std::thread(producer, i + 1);
        }
    
        // join them back:
        for (int i = 0; i < 10; ++i) {
            producers[i].join();
            consumers[i].join();
        }
    
        return 0;
    }

![复制代码][copycode.gif]

**std::condition\_variable::notify\_all() 介绍**

唤醒所有的等待(wait)线程。如果当前没有等待线程，则该函数什么也不做。请看下面的例子：

![复制代码][copycode.gif]

###  std::condition\_variable\_any 介绍 ###

与 std::condition\_variable 类似，只不过 std::condition\_variable\_any 的 wait 函数可以接受任何 lockable 参数，而 std::condition\_variable 只能接受 std::unique\_lock<std::mutex> 类型的参数，除此以外，和 std::condition\_variable 几乎完全一样。

### std::cv\_status 枚举类型介绍 ###

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">cv_status::no_timeout</span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">wait_for 或者 wait_until 没有超时，即在规定的时间段内线程收到了通知。</span></td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">cv_status::timeout</span></td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><span style="font-size: 14px;">wait_for 或者 wait_until 超时。</span></td> 
  </tr> 
 </tbody> 
</table>

### std::notify\_all\_at\_thread\_exit ###

函数原型为：

void notify_all_at_thread_exit (condition_variable& cond, unique_lock<mutex> lck);

当调用该函数的线程退出时，所有在 cond 条件变量上等待的线程都会收到通知。请看下例（[参考][Link 27]）：

![复制代码][copycode.gif]

#include <iostream>           // std::cout
    #include <thread>             // std::thread
    #include <mutex>              // std::mutex, std::unique_lock
    #include <condition_variable> // std::condition_variable
    
    std::mutex mtx;
    std::condition_variable cv;
    bool ready = false;
    
    void print_id (int id) {
      std::unique_lock<std::mutex> lck(mtx);
      while (!ready) cv.wait(lck);
      // ...
      std::cout << "thread " << id << '\n';
    }
    
    void go() {
      std::unique_lock<std::mutex> lck(mtx);
      std::notify_all_at_thread_exit(cv,std::move(lck));
      ready = true;
    }
    
    int main ()
    {
      std::thread threads[10];
      // spawn 10 threads:
      for (int i=0; i<10; ++i)
        threads[i] = std::thread(print_id,i);
      std::cout << "10 threads ready to race...\n";
    
      std::thread(go).detach();   // go!
    
      for (auto& th : threads) th.join();
    
      return 0;
    }

![复制代码][copycode.gif]

好了，到此为止，<condition\_variable> 头文件中的两个条件变量类（std::condition\_variable 和 std::condition\_variable\_any）、枚举类型（std::cv\_status）、以及辅助函数（std::notify\_all\_at\_thread\_exit()）都已经介绍完了。从下一章开始我会逐步开始介绍 <atomic> 头文件中的内容，后续的文章还会介绍 C++11 的内存模型，涉及内容稍微底层一些，希望大家能够保持兴趣，学完 C++11 并发编程，如果你发现本文中的错误，也请给我反馈 ;-)。

## [C++11 并发指南六(atomic 类型详解一 atomic\_flag 介绍)][C_11 _atomic _ atomic_flag] ##

C++11 并发指南已经写了 5 章，前五章重点介绍了多线程编程方面的内容，但大部分内容只涉及多线程、互斥量、条件变量和异步编程相关的 API，C++11 程序员完全可以不必知道这些 API 在底层是如何实现的，只需要清楚 C++11 多线程和异步编程相关 API 的语义，然后熟加练习即可应付大部分多线程编码需求。但是在很多极端的场合下为了性能和效率，我们需要开发一些 lock-free 的算法和数据结构，前面几章的内容可能就派不上用场了，因此从本文开始介绍 C++11 标准中 <atomic> 头文件里面的类和相关函数。

本文介绍 <atomic> 头文件中最简单的原子类型: atomic\_flag。atomic\_flag 一种简单的原子布尔类型，只支持两种操作，test-and-set 和 clear。

### std::atomic\_flag 构造函数 ###

std::atomic\_flag 构造函数如下：

*  atomic\_flag() noexcept = default;
 *  atomic\_flag (const atomic\_flag&T) = delete;

std::atomic\_flag 只有默认构造函数，拷贝构造函数已被禁用，因此不能从其他的 std::atomic\_flag 对象构造一个新的 std::atomic\_flag 对象。

如果在初始化时没有明确使用 ATOMIC\_FLAG\_INIT初始化，那么新创建的 std::atomic\_flag 对象的状态是未指定的（*unspecified*）（既没有被 set 也没有被 clear。）另外，atomic\_flag不能被拷贝，也不能 move 赋值。

ATOMIC\_FLAG\_INIT: 如果某个 std::atomic\_flag 对象使用该宏初始化，那么可以保证该 std::atomic\_flag 对象在创建时处于 clear 状态。

下面先看一个简单的例子，main() 函数中创建了 10 个线程进行计数，率先完成计数任务的线程输出自己的 ID，后续完成计数任务的线程不会输出自身 ID：

![复制代码][copycode.gif]

#include <iostream>              // std::cout
    #include <atomic>                // std::atomic, std::atomic_flag, ATOMIC_FLAG_INIT
    #include <thread>                // std::thread, std::this_thread::yield
    #include <vector>                // std::vector
    
    std::atomic<bool> ready(false);    // can be checked without being set
    std::atomic_flag winner = ATOMIC_FLAG_INIT;    // always set when checked
    
    void count1m(int id)
    {
        while (!ready) {
            std::this_thread::yield();
        } // 等待主线程中设置 ready 为 true.
    
        for (int i = 0; i < 1000000; ++i) {
        } // 计数.
    
        // 如果某个线程率先执行完上面的计数过程，则输出自己的 ID.
        // 此后其他线程执行 test_and_set 是 if 语句判断为 false，
        // 因此不会输出自身 ID.
        if (!winner.test_and_set()) {
            std::cout << "thread #" << id << " won!\n";
        }
    };
    
    int main()
    {
        std::vector<std::thread> threads;
        std::cout << "spawning 10 threads that count to 1 million...\n";
        for (int i = 1; i <= 10; ++i)
            threads.push_back(std::thread(count1m, i));
        ready = true;
    
        for (auto & th:threads)
            th.join();
    
        return 0;
    }

![复制代码][copycode.gif]

多次执行结果如下：

![复制代码][copycode.gif]

atomic ) ./Atomic-Flag1 
    spawning 10 threads that count to 1 million...
    thread #6 won!
    atomic ) ./Atomic-Flag1 
    spawning 10 threads that count to 1 million...
    thread #1 won!
    atomic ) ./Atomic-Flag1 
    spawning 10 threads that count to 1 million...
    thread #5 won!
    atomic ) ./Atomic-Flag1 
    spawning 10 threads that count to 1 million...
    thread #1 won!
    atomic ) ./Atomic-Flag1 
    spawning 10 threads that count to 1 million...
    thread #1 won!
    atomic ) ./Atomic-Flag1 
    spawning 10 threads that count to 1 million...
    thread #10 won!

![复制代码][copycode.gif]

### std::atomic\_flag::test\_and\_set 介绍 ###

std::atomic\_flag 的 test\_and\_set 函数原型如下：

bool test_and_set (memory_order sync = memory_order_seq_cst) volatile noexcept;
    bool test_and_set (memory_order sync = memory_order_seq_cst) noexcept;

test\_and\_set() 函数检查 std::atomic\_flag 标志，如果 std::atomic\_flag 之前没有被设置过，则设置 std::atomic\_flag 的标志，并返回先前该 std::atomic\_flag 对象是否被设置过，如果之前 std::atomic\_flag 对象已被设置，则返回 true，否则返回 false。

test-and-set 操作是原子的（因此 test-and-set 是原子 *read-modify-write* （RMW）操作）。

test\_and\_set 可以指定 Memory Order(后续的文章会详细介绍 C++11 的 Memory Order，此处为了完整性列出 test\_and\_set 参数 sync 的取值)，取值如下：

一个简单的例子：

![复制代码][copycode.gif]

#include <iostream>                // std::cout
    #include <atomic>                // std::atomic_flag
    #include <thread>                // std::thread
    #include <vector>                // std::vector
    #include <sstream>                // std::stringstream
    
    std::atomic_flag lock_stream = ATOMIC_FLAG_INIT;
    std::stringstream stream;
    
    void append_number(int x)
    {
        while (lock_stream.test_and_set()) {
        }
        stream << "thread #" << x << '\n';
        lock_stream.clear();
    }
    
    int main()
    {
        std::vector < std::thread > threads;
        for (int i = 1; i <= 10; ++i)
            threads.push_back(std::thread(append_number, i));
        for (auto & th:threads)
            th.join();
    
        std::cout << stream.str() << std::endl;;
        return 0;
    }

![复制代码][copycode.gif]

执行结果如下：

![复制代码][copycode.gif]

thread #1
    thread #2
    thread #3
    thread #4
    thread #5
    thread #6
    thread #7
    thread #8
    thread #9
    thread #10

![复制代码][copycode.gif]

### std::atomic\_flag::clear() 介绍 ###

清除 std::atomic\_flag 对象的标志位，即设置 atomic\_flag 的值为 false。clear 函数原型如下：

void clear (memory_order sync = memory_order_seq_cst) volatile noexcept;
    void clear (memory_order sync = memory_order_seq_cst) noexcept;

清除 std::atomic\_flag 标志使得下一次调用 std::atomic\_flag::test\_and\_set 返回 false。

std::atomic\_flag::clear() 可以指定 Memory Order(后续的文章会详细介绍 C++11 的 Memory Order，此处为了完整性列出 clear 参数 sync 的取值)，取值如下：

结合 std::atomic\_flag::test\_and\_set() 和 std::atomic\_flag::clear()，std::atomic\_flag 对象可以当作一个简单的自旋锁使用，请看下例：

![复制代码][copycode.gif]

#include <thread>
    #include <vector>
    #include <iostream>
    #include <atomic>
    
    std::atomic_flag lock = ATOMIC_FLAG_INIT;
    
    void f(int n)
    {
        for (int cnt = 0; cnt < 100; ++cnt) {
            while (lock.test_and_set(std::memory_order_acquire))  // acquire lock
                 ; // spin
            std::cout << "Output from thread " << n << '\n';
            lock.clear(std::memory_order_release);               // release lock
        }
    }
    
    int main()
    {
        std::vector<std::thread> v;
        for (int n = 0; n < 10; ++n) {
            v.emplace_back(f, n);
        }
        for (auto& t : v) {
            t.join();
        }
    }

![复制代码][copycode.gif]

在上面的程序中，std::atomic\_flag 对象 lock 的上锁操作可以理解为 lock.test\_and\_set(std::memory\_order\_acquire); (此处指定了 Memory Order，更多有关 Memory Order 的概念，我会在后续的文章中介绍)，解锁操作相当与 lock.clear(std::memory\_order\_release)。

在上锁的时候，如果 lock.test\_and\_set 返回 false，则表示上锁成功（此时 while 不会进入自旋状态），因为此前 lock 的标志位为 false(即没有线程对 lock 进行上锁操作)，但调用 test\_and\_set 后 lock 的标志位为 true，说明某一线程已经成功获得了 lock 锁。

如果在该线程解锁（即调用 lock.clear(std::memory\_order\_release)） 之前，另外一个线程也调用 lock.test\_and\_set(std::memory\_order\_acquire) 试图获得锁，则 test\_and\_set(std::memory\_order\_acquire) 返回 true，则 while 进入自旋状态。如果获得锁的线程解锁（即调用了 lock.clear(std::memory\_order\_release)）之后，某个线程试图调用 lock.test\_and\_set(std::memory\_order\_acquire) 并且返回 false，则 while 不会进入自旋，此时表明该线程成功地获得了锁。

按照上面的分析，我们知道在某种情况下 std::atomic\_flag 对象可以当作一个简单的自旋锁使用。

## [C++11 并发指南六( <atomic> 类型详解二 std::atomic )][C_11 _ _atomic_ _ std_atomic] ##

[C++11 并发指南六(atomic 类型详解一 atomic\_flag 介绍)][C_11 _atomic _ atomic_flag]  一文介绍了 C++11 中最简单的原子类型 std::atomic\_flag，但是 std::atomic\_flag 过于简单，只提供了 test\_and\_set 和 clear 两个 API，不能满足其他需求(如 store, load, exchange, compare\_exchange 等)，因此本文将介绍功能更加完善的 std::atomic 类。

### std::atomic 基本介绍 ###

std::atomic 是模板类，一个模板类型为 T 的原子对象中封装了一个类型为 T 的值。

template <class T> struct atomic;

原子类型对象的主要特点就是从不同线程访问不会导致数据竞争(data race)。因此从不同线程访问某个原子对象是良性 (*well-defined*) 行为，而通常对于非原子类型而言，并发访问某个对象（如果不做任何同步操作）会导致未定义 (*undifined*) 行为发生。

C++11 标准中的基本 std::atomic 模板定义如下：

![复制代码][copycode.gif]

template < class T > struct atomic {
        bool is_lock_free() const volatile;
        bool is_lock_free() const;
        void store(T, memory_order = memory_order_seq_cst) volatile;
        void store(T, memory_order = memory_order_seq_cst);
        T load(memory_order = memory_order_seq_cst) const volatile;
        T load(memory_order = memory_order_seq_cst) const;
        operator  T() const volatile;
        operator  T() const;
        T exchange(T, memory_order = memory_order_seq_cst) volatile;
        T exchange(T, memory_order = memory_order_seq_cst);
        bool compare_exchange_weak(T &, T, memory_order, memory_order) volatile;
        bool compare_exchange_weak(T &, T, memory_order, memory_order);
        bool compare_exchange_strong(T &, T, memory_order, memory_order) volatile;
        bool compare_exchange_strong(T &, T, memory_order, memory_order);
        bool compare_exchange_weak(T &, T, memory_order = memory_order_seq_cst) volatile;
        bool compare_exchange_weak(T &, T, memory_order = memory_order_seq_cst);
        bool compare_exchange_strong(T &, T, memory_order = memory_order_seq_cst) volatile;
        bool compare_exchange_strong(T &, T, memory_order = memory_order_seq_cst);
        atomic() = default;
        constexpr atomic(T);
        atomic(const atomic &) = delete;
        atomic & operator=(const atomic &) = delete;
        atomic & operator=(const atomic &) volatile = delete;
        T operator=(T) volatile;
        T operator=(T);
    };

![复制代码][copycode.gif]

另外，C++11 标准库 std::atomic 提供了针对整形(integral)和指针类型的特化实现，分别定义如下：

针对整形(integal)的特化，其中 integal 代表了如下类型char, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, char16\_t, char32\_t, wchar\_t：

<table style="border: 1px solid silver; width: 844px; border-collapse: collapse; word-break: break-word; border-radius: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-size: 12px !important; min-height: auto !important; background: none !important;"> 
 <tbody style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none !important;"> 
  <tr style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none !important;"> 
   <td style="border: 1px solid silver; padding: 3px; border-collapse: collapse; border-radius: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;"> 
    <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: relative !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none !important;"> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">template</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&lt;&gt; </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">struct</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&lt;integral&gt; { </code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">is_lock_free() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">is_lock_free() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">void</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">store(integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">void</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">store(integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral load(memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral load(memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">operator integral() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">operator integral() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral exchange(integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral exchange(integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_weak(integral&amp;, integral, memory_order, memory_order) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_weak(integral&amp;, integral, memory_order, memory_order);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_strong(integral&amp;, integral, memory_order, memory_order) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_strong(integral&amp;, integral, memory_order, memory_order);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_weak(integral&amp;, integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_weak(integral&amp;, integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_strong(integral&amp;, integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_strong(integral&amp;, integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_add(integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_add(integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_sub(integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_sub(integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_and(integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_and(integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_or(integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_or(integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_xor(integral, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral fetch_xor(integral, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code>&nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic() = </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">default</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">constexpr</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic(integral);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp;) = </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">delete</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp; operator=(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp;) = </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">delete</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp; operator=(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp;) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">= </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">delete</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code>&nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator=(integral) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator=(integral);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code>&nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator++(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">int</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator++(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">int</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator--(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">int</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator--(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">int</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator++() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator++();</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator--() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator--();</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator+=(integral) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator+=(integral);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator-=(integral) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator-=(integral);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator&amp;=(integral) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator&amp;=(integral);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator|=(integral) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator|=(integral);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator^=(integral) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">integral operator^=(integral);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">};</code> 
     </div> 
    </div></td> 
  </tr> 
 </tbody> 
</table>

针对指针的特化：

<table style="border: 1px solid silver; width: 844px; border-collapse: collapse; word-break: break-word; border-radius: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-size: 12px !important; min-height: auto !important; background: none !important;"> 
 <tbody style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none !important;"> 
  <tr style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none !important;"> 
   <td style="border: 1px solid silver; padding: 3px; border-collapse: collapse; border-radius: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;"> 
    <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.1em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: relative !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none !important;"> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">template</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&lt;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">class</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T&gt; </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">struct</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&lt;T*&gt; { </code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">is_lock_free() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">is_lock_free() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">void</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">store(T*, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">void</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">store(T*, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* load(memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* load(memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">operator T*() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">operator T*() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* exchange(T*, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* exchange(T*, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_weak(T*&amp;, T*, memory_order, memory_order) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_weak(T*&amp;, T*, memory_order, memory_order);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_strong(T*&amp;, T*, memory_order, memory_order) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_strong(T*&amp;, T*, memory_order, memory_order);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_weak(T*&amp;, T*, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_weak(T*&amp;, T*, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_strong(T*&amp;, T*, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">bool</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">compare_exchange_strong(T*&amp;, T*, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* fetch_add(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">ptrdiff_t</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* fetch_add(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">ptrdiff_t</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* fetch_sub(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">ptrdiff_t</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">, memory_order = memory_order_seq_cst) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* fetch_sub(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">ptrdiff_t</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">, memory_order = memory_order_seq_cst);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic() = </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">default</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">constexpr</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic(T*);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp;) = </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">delete</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp; operator=(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp;) = </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">delete</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp; operator=(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">const</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">atomic&amp;) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code>&nbsp; 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">= </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">delete</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;">
       &nbsp; 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator=(T*) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator=(T*);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator++(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">int</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator++(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">int</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator--(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">int</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator--(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">int</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator++() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator++();</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator--() </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator--();</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator+=(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">ptrdiff_t</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator+=(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">ptrdiff_t</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator-=(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">ptrdiff_t</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">) </code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; color: rgb(0, 0, 255) !important; background: none !important;">volatile</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">;</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background: none rgb(244, 244, 244) !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">&nbsp;&nbsp;&nbsp;&nbsp;</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">T* operator-=(</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; font-weight: bold !important; min-height: auto !important; color: gray !important; background: none !important;">ptrdiff_t</code> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">);</code> 
     </div> 
     <div style="border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px 1em 0px 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important; background-image: none !important; background-attachment: initial !important; background-size: initial !important; background-origin: initial !important; background-clip: initial !important; background-position: initial !important; background-repeat: initial !important;"> 
      <code style="white-space: pre-wrap; border-radius: 0px !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 1.8em !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace !important; min-height: auto !important; background: none !important;">};</code> 
     </div> 
    </div></td> 
  </tr> 
 </tbody> 
</table>

### std::atomic 成员函数 ###

好了，对 std::atomic 有了一个最基本认识之后我们来看 std::atomic 的成员函数吧。

#### std::atomic 构造函数 ####

std::atomic 的构造函数如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">default (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">          atomic() noexcept = default;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">initialization (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">constexpr atomic (T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy [deleted] (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">          atomic (const atomic&amp;) = delete;</pre></td> 
  </tr> 
 </tbody> 
</table>

1.  默认构造函数，由默认构造函数创建的 std::atomic 对象处于未初始化(uninitialized)状态，对处于未初始化(uninitialized)状态 std::atomic对象可以由 atomic\_init 函数进行初始化。
2.  初始化构造函数，由类型 T初始化一个 std::atomic对象。
3.  拷贝构造函数被禁用。

请看下例：

#### std::atomic::operator=() 函数 ####

std::atomic 的赋值操作函数定义如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">set value (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T operator= (T val) noexcept;
T operator= (T val) volatile noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">copy [deleted] (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">atomic&amp; operator= (const atomic&amp;) = delete;
atomic&amp; operator= (const atomic&amp;) volatile = delete;</pre></td> 
  </tr> 
 </tbody> 
</table>

可以看出，普通的赋值拷贝操作已经被禁用。但是一个类型为 T 的变量可以赋值给相应的原子类型变量（相当与隐式转换），该操作是原子的，内存序(Memory Order) 默认为顺序一致性(std::memory\_order\_seq\_cst)，如果需要指定其他的内存序，需使用 std::atomic::store()。

#### 基本 std::atomic 类型操作 ####

本节主要介绍基本 std::atomic 类型所具备的操作（即成员函数）。我们知道 std::atomic 是模板类，一个模板类型为 T 的原子对象中封装了一个类型为 T 的值。本文<**std::atomic 基本介绍**>一节中也提到了 std::atomic 类模板除了基本类型以外，还针对整形和指针类型做了特化。 特化的 std::atomic 类型支持更多的操作，如 fetch\_add, fetch\_sub, fetch\_and 等。本小节介绍基本 std::atomic 类型所具备的操作：

**is\_lock\_free**

判断该 std::atomic 对象是否具备 lock-free 的特性。如果某个对象满足  *lock-free* 特性，在多个线程访问该对象时不会导致线程阻塞。(可能使用某种事务内存 *transactional memory *方法实现 lock-free 的特性)。

**store**

修改被封装的值，std::atomic::store 函数将类型为 T 的参数 val 复制给原子对象所封装的值。T 是 std::atomic 类模板参数。另外参数 sync 指定内存序(Memory Order)，可能的取值如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

请看下面例子：

**load**

读取被封装的值，参数 sync 设置内存序(Memory Order)，可能的取值如下：

请看下面例子：

**operator T**

与 load 功能类似，也是 读取被封装的值，operator T() 是类型转换( type-cast) 操作，默认的内存序是 std::memory\_order\_seq\_cst，如果需要指定其他的内存序，你应该使用 load() 函数。请看下面例子：

**exchange**

T exchange (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
    T exchange (T val, memory_order sync = memory_order_seq_cst) noexcept;

读取并修改被封装的值，exchange 会将 val 指定的值替换掉之前该原子对象封装的值，并返回之前该原子对象封装的值，整个过程是原子的(因此exchange 操作也称为  *read-modify-write* 操作)。sync参数指定内存序(Memory Order)，可能的取值如下：

请看下面例子，各个线程计数至 1M，首先完成计数任务的线程打印自己的 ID，

**compare\_exchange\_weak**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">(1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool compare_exchange_weak (T&amp; expected, T val,
           memory_order sync = memory_order_seq_cst) volatile noexcept;
bool compare_exchange_weak (T&amp; expected, T val,
           memory_order sync = memory_order_seq_cst) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">(2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool compare_exchange_weak (T&amp; expected, T val,
           memory_order success, memory_order failure) volatile noexcept;
bool compare_exchange_weak (T&amp; expected, T val,
           memory_order success, memory_order failure) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

比较并交换被封装的值(weak)与参数  expected 所指定的值是否相等，如果：

*  相等，则用 val 替换原子对象的旧值。
 *  不相等，则用原子对象的旧值替换 *expected* ，因此调用该函数之后，如果被该原子对象封装的值与参数 expected 所指定的值不相等，*expected* 中的内容就是原子对象的旧值。

该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于  *expected*)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。  
  
在第 **(2)**种情况下，内存序（Memory Order）的选择取决于比较操作结果，如果比较结果为 true(即原子对象的值等于  *expected*)，则选择参数  success 指定的内存序，否则选择参数  failure 所指定的内存序。  
注意，该函数直接比较原子对象所封装的值与参数  *expected* 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 compare\_exchange\_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。  
与 compare\_exchange\_strong 不同,  *weak *版本的 compare-and-exchange 操作允许( *spuriously 地*)返回 false(即原子对象所封装的值与参数  *expected* 的物理内容相同，但却仍然返回 false)，不过在某些需要循环操作的算法下这是可以接受的，并且在一些平台下 compare\_exchange\_weak 的性能更好 。如果 compare\_exchange\_weak 的判断确实发生了伪失败( *spurious failures)——*即使原子对象所封装的值与参数  *expected* 的物理内容相同，但判断操作的结果却为 false，compare\_exchange\_weak函数返回 false，并且参数 `` expected 的值不会改变。  
对于某些不需要采用循环操作的算法而言, 通常采用 compare\_exchange\_strong 更好。另外，该函数的内存序由  sync 参数指定，可选条件如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

请看下面的例子（ [参考][Link 28]）：

可能的执行结果如下：

**compare\_exchange\_strong**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">(1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool compare_exchange_strong (T&amp; expected, T val,
           memory_order sync = memory_order_seq_cst) volatile noexcept;
bool compare_exchange_strong (T&amp; expected, T val,
           memory_order sync = memory_order_seq_cst) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">(2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool compare_exchange_strong (T&amp; expected, T val,
           memory_order success, memory_order failure) volatile noexcept;
bool compare_exchange_strong (T&amp; expected, T val,
           memory_order success, memory_order failure) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

比较并交换被封装的值(strong)与参数  expected 所指定的值是否相等，如果：

与 compare\_exchange\_weak 不同, strong版本的 compare-and-exchange 操作不允许( *spuriously 地*)返回 false，即原子对象所封装的值与参数  *expected* 的物理内容相同，比较操作一定会为 true。不过在某些平台下，如果算法本身需要循环操作来做检查， compare\_exchange\_weak 的性能会更好。  
因此对于某些不需要采用循环操作的算法而言, 通常采用 compare\_exchange\_strong 更好。另外，该函数的内存序由  sync 参数指定，可选条件如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

请看下面的例子：

好了，本文花了大量的篇幅介绍 std::atomic 基本类型，下一篇博客我会给大家介绍 C++11 的标准库中std::atomic 针对整形(integral)和指针类型的特化版本做了哪些改进。

## [C++11 并发指南六(atomic 类型详解三 std::atomic (续))][C_11 _atomic _ std_atomic] ##

[C++11 并发指南六( <atomic> 类型详解二 std::atomic )][C_11 _ _atomic_ _ std_atomic] 介绍了基本的原子类型 std::atomic 的用法，本节我会给大家介绍C++11 标准库中的 std::atomic 针对整形(integral)和指针类型的特化版本做了哪些改进。

总地来说，C++11 标准库中的 std::atomic 针对整形(integral)和指针类型的特化版本新增了一些算术运算和逻辑运算操作。具体如下：

下面我们来简单介绍以上的 std::atomic 特化版本的成员函数。

**fetch\_add**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">if T is integral (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T fetch_add (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_add (T val, memory_order sync = memory_order_seq_cst) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">if T is pointer (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T fetch_add (ptrdiff_t val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_add (ptrdiff_t val, memory_order sync = memory_order_seq_cst) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值加 val，并返回原子对象的旧值（适用于整形和指针类型的 std::atomic 特化版本），整个过程是原子的。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

另外，如果第二个参数不指定（取默认参数 memory\_order\_seq\_cst），则 fetch\_add 相当与 std::atomic::operator+=。

**fetch\_sub**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">if T is integral (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T fetch_sub (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_sub (T val, memory_order sync = memory_order_seq_cst) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">if T is pointer (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T fetch_sub (ptrdiff_t val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_sub (ptrdiff_t val, memory_order sync = memory_order_seq_cst) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值减 val，并返回原子对象的旧值（适用于整形和指针类型的 std::atomic 特化版本），整个过程是原子的。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

另外，如果第二个参数不指定（取默认参数 memory\_order\_seq\_cst），则 fetch\_sub 相当与 std::atomic::operator-=。

**fetch\_and**

将原子对象的封装值按位与 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

另外，如果第二个参数不指定（取默认参数 memory\_order\_seq\_cst），则 fetch\_add 相当与 std::atomic::operator&=。

**fetch\_or**

将原子对象的封装值按位或 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

另外，如果第二个参数不指定（取默认参数 memory\_order\_seq\_cst），则 fetch\_or 相当与 std::atomic::operator|=。

**fetch\_xor**

将原子对象的封装值按位异或 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

另外，如果第二个参数不指定（取默认参数 memory\_order\_seq\_cst），则 fetch\_xor 相当与 std::atomic::operator^=。

**operator++**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">pre-increment (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T operator++() volatile noexcept;
T operator++() noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">post-increment (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T operator++ (int) volatile noexcept;
T operator++ (int) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

自增运算符重载， 第一种形式 (1) 返回自增后的值（即前缀++），第二种形式(2) 返回自增前的值（即后缀++），适用于整形和指针类型的 std::atomic 特化版本。

**operator--** 自减运算符重载， 第一种形式 (1) 返回自减后的值（即前缀--），第二种形式(2) 返回自减前的值（即后缀--），适用于整形和指针类型的 std::atomic 特化版本。

**atomic::operator (comp. assign.)** 复合赋值运算符重载，主要包含以下形式：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">if T is integral (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T operator+= (T val) volatile noexcept;
T operator+= (T val) noexcept;
T operator-= (T val) volatile noexcept;
T operator-= (T val) noexcept;
T operator&amp;= (T val) volatile noexcept;
T operator&amp;= (T val) noexcept;
T operator|= (T val) volatile noexcept;
T operator|= (T val) noexcept;
T operator^= (T val) volatile noexcept;
T operator^= (T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">if T is pointer (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T operator+= (ptrdiff_t val) volatile noexcept;
T operator+= (ptrdiff_t val) noexcept;
T operator-= (ptrdiff_t val) volatile noexcept;
T operator-= (ptrdiff_t val) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

以上各个 operator 都会有对应的 **fetch\_\*** 操作，详细见下表：

好了，本节先介绍这里，下一节我会介绍 C++11 中 C 风格的原子操作 API。

## [C++11 并发指南六(atomic 类型详解四 C 风格原子操作介绍)][C_11 _atomic _ C] ##

前面三篇文章《[C++11 并发指南六(atomic 类型详解一 atomic\_flag 介绍)][C_11 _atomic _ atomic_flag]》、《[C++11 并发指南六( <atomic> 类型详解二 std::atomic )][C_11 _ _atomic_ _ std_atomic]》、《[C++11 并发指南六(atomic 类型详解三 std::atomic (续))][C_11 _atomic _ std_atomic]》都是采用 C++ 的方式介绍原子对象，本节我会给大家介绍 C++11 原子操作中 C 风格的 API。

总地来说，C++11 标准中规定了两大类原子对象，std::atomic\_flag 和 std::atomic，前者 std::atomic\_flag 一种最简单的原子布尔类型，只支持两种操作，test-and-set 和 clear。而 std::atomic 是模板类，一个模板类型为 T 的原子对象中封装了一个类型为 T 的值，并且C++11 标准中除了定义基本 std::atomic 模板类型外，还提供了针对整形(integral)和指针类型的特化实现，提供了大量的 API，极大地方便了开发者使用。下面我分别介绍基于 std::atomic\_flag 和 std::atomic 的 C 风格 API。

### 基于 std::atomic\_flag 类型的 C 风格 API ###

**atomic\_flag\_test\_and\_set**

bool atomic_flag_test_and_set (volatile atomic_flag* obj) noexcept;
    bool atomic_flag_test_and_set (atomic_flag* obj) noexcept;

检测并设置 std::atomic\_flag 的值，并返回 std::atomic\_flag 的旧值，和 std::atomic::test\_and\_set() 成员函数的功能相同，整个过程也是原子的，默认的内存序为 memory\_order\_seq\_cst。

**atomic\_flag\_test\_and\_set\_explicit**

bool atomic_flag_test_and_set (volatile atomic_flag* obj, memory_order sync) noexcept;
    bool atomic_flag_test_and_set (atomic_flag* obj, memory_order sync) noexcept;

检测并设置 std::atomic\_flag 的值，并返回 std::atomic\_flag 的旧值，和 std::atomic::test\_and\_set() 成员函数的功能相同，整个过程也是原子的。sync 参数指定了内存序（Memory Order），可能的取值如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

**atomic\_flag\_clear**

void atomic_flag_clear (volatile atomic_flag* obj) noexcept;
    void atomic_flag_clear (atomic_flag* obj) noexcept;

清除 std::atomic\_flag 对象，并设置它的值为 false，和 std::atomic::clear() 成员函数的功能相同，整个过程也是原子的，默认的内存序为 memory\_order\_seq\_cst。

**atomic\_flag\_clear\_explicit**

void atomic_flag_clear (volatile atomic_flag* obj, memory_order sync) noexcept;
    void atomic_flag_clear (atomic_flag* obj, memory_order sync) noexcept;

清除 std::atomic\_flag 对象，并设置它的值为 false，和 std::atomic::clear() 成员函数的功能相同，整个过程也是原子的，sync 参数指定了内存序（Memory Order），可能的取值如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

### 基于 std::atomic 模板类型的 C 风格 API ###

**atomic\_is\_lock\_free**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; bool atomic_is_lock_free (const volatile atomic&lt;T&gt;* obj) noexcept;
template &lt;class T&gt; bool atomic_is_lock_free (const atomic&lt;T&gt;* obj) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool atomic_is_lock_free (const volatile A* obj) noexcept;
bool atomic_is_lock_free (const A* obj) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

**atomic\_init**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; void atomic_init (volatile atomic&lt;T&gt;* obj, T val) noexcept;
template &lt;class T&gt; void atomic_init (atomic&lt;T&gt;* obj, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">void atomic_init (volatile A* obj, T val) noexcept;
void atomic_init (A* obj, T val) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

初始化原子对象。 val 指定原子对象的初始值。如果对一个已初始化的原子对象再次调用 atomic\_init()，则会导致未定义行为(*undefined behavior*)，如果你想修改原子对象的值，应该使用 std::atomic\_store();

**atomic\_store**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; void atomic_store (volatile atomic&lt;T&gt;* obj, T val) noexcept;
template &lt;class T&gt; void atomic_store (atomic&lt;T&gt;* obj, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">void atomic_store (volatile A* obj, T val) noexcept;
void atomic_store (A* obj, T val) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

修改原子对象的值，默认的内存序为memory\_order\_seq\_cst。该函数相当于 std::atomic 对象的 store 或者operator=() 成员函数，如果你需要显式指定内存序，应该使用atomic\_store\_explicit。

**atomic\_store\_explicit** 修改原子对象的值。该函数相当于 std::atomic 对象的 store 或者operator=() 成员函数 ，sync 指定了内存序，可取的参数为：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

**atomic\_load**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; T atomic_load (const volatile atomic&lt;T&gt;* obj) noexcept;
template &lt;class T&gt; T atomic_load (const atomic&lt;T&gt;* obj) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_load (const volatile A* obj) noexcept;
T atomic_load (const A* obj) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

读取被封装的值， 默认的内存序为memory\_order\_seq\_cst。该函数与 std::atomic 对象的atomic::load()和atomic::operator T() 成员函数等价。

**atomic\_load\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
T atomic_load_explicit (const volatile atomic&lt;T&gt;* obj, memory_order sync) noexcept;
template &lt;class T&gt;
T atomic_load_explicit (const atomic&lt;T&gt;* obj, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_load_explicit (const volatile A* obj, memory_order sync) noexcept;
T atomic_load_explicit (const A* obj, memory_order sync) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

读取被封装的值，参数 sync 设置内存序(Memory Order)，可能的取值如下：

该函数与 std::atomic 对象的atomic::load() 成员函数等价。

**atomic\_exchange**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; T atomic_exchange (volatile atomic&lt;T&gt;* obj, T val) noexcept;
template &lt;class T&gt; T atomic_exchange (atomic&lt;T&gt;* obj, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_exchange (volatile A* obj, T val) noexcept;
T atomic_exchange (A* obj, T val) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

读取并修改被封装的值，exchange 会将 val 指定的值替换掉之前该原子对象封装的值，并返回之前该原子对象封装的值，整个过程是原子的(因此exchange 操作也称为  *read-modify-write* 操作)。 该函数与 std::atomic 对象的atomic::exchange() 成员函数等价。

**atomic\_exchange\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
T atomic_store_explicit (volatile atomic&lt;T&gt;* obj, T val, memory_order sync) noexcept;
template &lt;class T&gt;
T atomic_store_explicit (atomic&lt;T&gt;* obj, T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_store_explicit (volatile A* obj, T val, memory_order sync) noexcept;
T atomic_store_explicit (A* obj, T val, memory_order sync) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

**atomic\_compare\_exchange\_weak**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
bool atomic_compare_exchange_weak (volatile atomic&lt;T&gt;* obj, T* expected, T val) noexcept;
template &lt;class T&gt;
bool atomic_compare_exchange_weak (atomic&lt;T&gt;* obj, T* expected, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool atomic_compare_exchange_weak (volatile A* obj, T* expected, T val) noexcept;
bool atomic_compare_exchange_weak (A* obj, T* expected, T val) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

比较并交换被封装的值(weak)与参数  expected 所指定的值是否相等，如果：

该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于  *expected*)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。  
注意，该函数直接比较原子对象所封装的值与参数  *expected* 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 atomic\_compare\_exchange\_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。  
与  atomic\_compare\_exchange\_strong 不同,  *weak *版本的 compare-and-exchange 操作允许( *spuriously 地*)返回 false(即原子对象所封装的值与参数  *expected* 的物理内容相同，但却仍然返回 false)，不过在某些需要循环操作的算法下这是可以接受的，并且在一些平台下 compare\_exchange\_weak 的性能更好 。如果 atomic\_compare\_exchange\_weak 的判断确实发生了伪失败( *spurious failures)——*即使原子对象所封装的值与参数  *expected* 的物理内容相同，但判断操作的结果却为 false，atomic\_compare\_exchange\_weak 函数返回 false，并且参数  `` expected 的值不会改变。

**atomic\_compare\_exchange\_weak\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
bool atomic_compare_exchange_weak_explicit (volatile atomic&lt;T&gt;* obj,
        T* expected, T val, memory_order success, memory_order failure) noexcept;
template &lt;class T&gt;
bool atomic_compare_exchange_weak_explicit (atomic&lt;T&gt;* obj,
        T* expected, T val, memory_order success, memory_order failure) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool atomic_compare_exchange_weak_explicit (volatile A* obj,
        T* expected, T val, memory_order success, memory_order failure) noexcept;
bool atomic_compare_exchange_weak_explicit (A* obj,
        T* expected, T val, memory_order success, memory_order failure) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

比较并交换被封装的值(weak)与参数  expected 所指定的值是否相等，如果：

该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于  *expected*)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。  
  
内存序（Memory Order）的选择取决于比较操作结果，如果比较结果为 true(即原子对象的值等于  *expected*)，则选择参数  success 指定的内存序，否则选择参数  failure 所指定的内存序。  
注意，该函数直接比较原子对象所封装的值与参数  *expected* 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 compare\_exchange\_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。  
与  atomic\_compare\_exchange\_strong 不同,  *weak *版本的 compare-and-exchange 操作允许( *spuriously 地*)返回 false(即原子对象所封装的值与参数  *expected* 的物理内容相同，但却仍然返回 false)，不过在某些需要循环操作的算法下这是可以接受的，并且在一些平台下 compare\_exchange\_weak 的性能更好 。如果 atomic\_compare\_exchange\_weak 的判断确实发生了伪失败( *spurious failures)——*即使原子对象所封装的值与参数  *expected* 的物理内容相同，但判断操作的结果却为 false，atomic\_compare\_exchange\_weak函数返回 false，并且参数  `` expected 的值不会改变。

对于某些不需要采用循环操作的算法而言, 通常采用  atomic\_compare\_exchange\_strong 更好。另外，该函数的内存序由  sync 参数指定，可选条件如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

**atomic\_compare\_exchange\_strong**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
bool atomic_compare_exchange_strong (volatile atomic&lt;T&gt;* obj, T* expected, T val) noexcept;
template &lt;class T&gt;
bool atomic_compare_exchange_strong (atomic&lt;T&gt;* obj, T* expected, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool atomic_compare_exchange_strong (volatile A* obj, T* expected, T val) noexcept;
bool atomic_compare_exchange_strong (A* obj, T* expected, T val) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

比较并交换被封装的值(strong)与参数  expected 所指定的值是否相等，如果：

与 atomic\_ compare\_exchange\_weak 不同, strong版本的 compare-and-exchange 操作不允许( *spuriously 地*)返回 false，即原子对象所封装的值与参数  *expected* 的物理内容相同，比较操作一定会为 true。不过在某些平台下，如果算法本身需要循环操作来做检查， atomic\_compare\_exchange\_weak 的性能会更好。  
因此对于某些不需要采用循环操作的算法而言, 通常采用 atomic\_ compare\_exchange\_strong 更好。

**atomic\_compare\_exchange\_strong\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
bool atomic_compare_exchange_strong_explicit (volatile atomic&lt;T&gt;* obj,
        T* expected, T val, memory_order success, memory_order failure) noexcept;
template &lt;class T&gt;
bool atomic_compare_exchange_strong_explicit (atomic&lt;T&gt;* obj,
        T* expected, T val, memory_order success, memory_order failure) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">bool atomic_compare_exchange_strong_explicit (volatile A* obj,
        T* expected, T val, memory_order success, memory_order failure) noexcept;
bool atomic_compare_exchange_strong_explicit (A* obj,
        T* expected, T val, memory_order success, memory_order failure) noexcept;</pre></td> 
  </tr> 
 </tbody> 
</table>

比较并交换被封装的值(strong)与参数  expected 所指定的值是否相等，如果：

与atomic\_ compare\_exchange\_weak 不同, strong版本的 compare-and-exchange 操作不允许( *spuriously 地*)返回 false，即原子对象所封装的值与参数  *expected* 的物理内容相同，比较操作一定会为 true。不过在某些平台下，如果算法本身需要循环操作来做检查， atomic\_compare\_exchange\_weak 的性能会更好。  
因此对于某些不需要采用循环操作的算法而言, 通常采用 atomic\_ compare\_exchange\_strong 更好。另外，该函数的内存序由  sync 参数指定，可选条件如下：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

**atomic\_fetch\_add**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; T atomic_fetch_add (volatile atomic&lt;T&gt;* obj, T val) noexcept;
template &lt;class T&gt; T atomic_fetch_add (atomic&lt;T&gt;* obj, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (pointer) (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class U&gt; U* atomic_fetch_add (volatile atomic&lt;U*&gt;* obj, ptrdiff_t val) noexcept;
template &lt;class U&gt; U* atomic_fetch_add (atomic&lt;U*&gt;* obj, ptrdiff_t val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_add (volatile A* obj, M val) noexcept;
T atomic_fetch_add (A* obj, M val) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值加 val，并返回原子对象的旧值（适用于整形和指针类型的 std::atomic 特化版本），整个过程是原子的。该函数默认内存序为 memory\_order\_seq\_cst。 该函数等价于 std::atomic 对象的atomic::fetch\_add和 atomic::operator+= 成员函数。

**atomic\_fetch\_add\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
T atomic_fetch_add_explicit (volatile atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
template &lt;class T&gt;
T atomic_fetch_add_explicit (atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (pointer) (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class U&gt;
U* atomic_fetch_add_explicit (volatile atomic&lt;U*&gt;* obj,
                              ptrdiff_t val, memory_order sync) noexcept;
template &lt;class U&gt;
U* atomic_fetch_add_explicit (atomic&lt;U*&gt;* obj,
                              ptrdiff_t val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_add_explicit (volatile A* obj, M val, memory_order sync) noexcept;
T atomic_fetch_add_explicit (A* obj, M val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值加 val，并返回原子对象的旧值（适用于整形和指针类型的 std::atomic 特化版本），整个过程是原子的。 该函数等价于 std::atomic 对象的atomic::fetch\_add成员函数。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

**atomic\_fetch\_sub**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; T atomic_fetch_sub (volatile atomic&lt;T&gt;* obj, T val) noexcept;
template &lt;class T&gt; T atomic_fetch_sub (atomic&lt;T&gt;* obj, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (pointer) (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class U&gt; U* atomic_fetch_sub (volatile atomic&lt;U*&gt;* obj, ptrdiff_t val) noexcept;
template &lt;class U&gt; U* atomic_fetch_sub (atomic&lt;U*&gt;* obj, ptrdiff_t val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_sub (volatile A* obj, M val) noexcept;
T atomic_fetch_sub (A* obj, M val) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值减 val，并返回原子对象的旧值（适用于整形和指针类型的 std::atomic 特化版本），整个过程是原子的。

**atomic\_fetch\_sub\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
T atomic_fetch_sub_explicit (volatile atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
template &lt;class T&gt;
T atomic_fetch_sub_explicit (atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (pointer) (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class U&gt;
U* atomic_fetch_sub_explicit (volatile atomic&lt;U*&gt;* obj,
                              ptrdiff_t val, memory_order sync) noexcept;
template &lt;class U&gt;
U* atomic_fetch_sub_explicit (atomic&lt;U*&gt;* obj,
                              ptrdiff_t val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (3)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_sub_explicit (volatile A* obj, M val, memory_order sync) noexcept;
T atomic_fetch_sub_explicit (A* obj, M val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值减 val，并返回原子对象的旧值（适用于整形和指针类型的 std::atomic 特化版本），整个过程是原子的。

该函数等价于 std::atomic 对象的atomic::fetch\_sub成员函数。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

**atomic\_fetch\_and**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">emplate (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; T atomic_fetch_and (volatile atomic&lt;T&gt;* obj, T val) noexcept;
template &lt;class T&gt; T atomic_fetch_and (atomic&lt;T&gt;* obj, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_and (volatile A* obj, T val) noexcept;
T atomic_fetch_and (A* obj, T val) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值按位与 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。

**atomic\_fetch\_and\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
T atomic_fetch_and_explicit (volatile atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
template &lt;class T&gt;
T atomic_fetch_and_explicit (atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_and_explicit (volatile A* obj, T val, memory_order sync) noexcept;
T atomic_fetch_and_explicit (A* obj, T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值按位与 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。

该函数等价于 std::atomic 对象的atomic::fetch\_and成员函数。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

**atomic\_fetch\_or**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; T atomic_fetch_or (volatile atomic&lt;T&gt;* obj, T val) noexcept;
template &lt;class T&gt; T atomic_fetch_or (atomic&lt;T&gt;* obj, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_or (volatile A* obj, T val) noexcept;
T atomic_fetch_or (A* obj, T val) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值按位或 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。

**atomic\_fetch\_or\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
T atomic_fetch_or_explicit (volatile atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
template &lt;class T&gt;
T atomic_fetch_or_explicit (atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_or_explicit (volatile A* obj, T val, memory_order sync) noexcept;
T atomic_fetch_or_explicit (A* obj, T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

A 将原子对象的封装值按位或 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。

该函数等价于 std::atomic 对象的atomic::fetch\_or成员函数。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

**atomic\_fetch\_xor**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt; T atomic_fetch_xor (volatile atomic&lt;T&gt;* obj, T val) noexcept;
template &lt;class T&gt; T atomic_fetch_xor (atomic&lt;T&gt;* obj, T val) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_xor (volatile A* obj, T val) noexcept;
T atomic_fetch_xor (A* obj, T val) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值按位异或 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。

**atomic\_fetch\_xor\_explicit**

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">template (integral) (1)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">template &lt;class T&gt;
T atomic_fetch_xor_explicit (volatile atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
template &lt;class T&gt;
T atomic_fetch_xor_explicit (atomic&lt;T&gt;* obj,
                             T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px;">overloads (2)</th> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px;"><pre style="margin-top: 0px; margin-bottom: 0px; white-space: pre-wrap; word-wrap: break-word;">T atomic_fetch_xor_explicit (volatile A* obj, T val, memory_order sync) noexcept;
T atomic_fetch_xor_explicit (A* obj, T val, memory_order sync) noexcept;
</pre></td> 
  </tr> 
 </tbody> 
</table>

将原子对象的封装值按位异或 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。

该函数等价于 std::atomic 对象的atomic::fetch\_xor成员函数。sync 参数指定内存序：

<table style="border: 1px solid silver; border-collapse: collapse; word-break: break-word; color: rgb(51, 51, 51); font-family: Georgia, 'Times New Roman', Times, sans-serif; font-size: 14px; line-height: 25.2px;"> 
 <tbody> 
  <tr> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 值</th> 
   <th style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Memory Order 类型</th> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_relaxed</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Relaxed</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_consume</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Consume</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acquire</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_release</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_acq_rel</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Acquire/Release</td> 
  </tr> 
  <tr> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">memory_order_seq_cst</td> 
   <td style="border: 1px solid silver; border-collapse: collapse; padding: 3px; text-align: center;">Sequentially consistent</td> 
  </tr> 
 </tbody> 
</table>

### 与原子对象初始化相关的宏 ###

此外，还有两个宏值得关注，他们分别是：

**ATOMIC\_VAR\_INIT(val)** 初始化 std::atomic 对象。

**ATOMIC\_FLAG\_INIT** 初始化 std::atomic\_flag 对象。

## [C++11 并发指南七(C++11 内存模型一：介绍)][C_11 _C_11 1] ##

第六章主要介绍了 C++11 中的原子类型及其相关的API，原子类型的大多数 API 都需要程序员提供一个 std::memory\_order（可译为内存序，访存顺序） 的枚举类型值作为参数，比如：[atomic\_store][atomic_store]，[atomic\_load][atomic_load]，[atomic\_exchange][atomic_exchange]，[atomic\_compare\_exchange][atomic_compare_exchange] 等 API 的最后一个形参为 std::memory\_order order，默认值是 std::memory\_order\_seq\_cst（顺序一致性）。那么究竟什么是 std::memory\_order 呢，为了解答这个问题，我们先来讨论 C++11 的内存模型。

一般来讲，内存模型可分为静态内存模型和动态内存模型，静态内存模型主要涉及类的对象在内存中是如何存放的，即从结构(structural)方面来看一个对象在内存中的布局，以一个简单的例子为例（截图参考《C++  Concurrency In Action》 P105 ）：

![07162105-85c403b5f8ae4ea882af842d6d178273.png][]

上面是一个简单的 C++ 类(又称POD: Plain Old Data，它没有虚函数，没有继承)，它在内存中的布局如图右边所示（对于复杂类对象的内存布局，请参考《深度探索C++对象模型》一书）。

动态内存模型可理解为存储一致性模型，主要是从行为(behavioral)方面来看多个线程对同一个对象同时(读写)操作时(concurrency)所做的约束，动态内存模型理解起来稍微复杂一些，涉及了内存，Cache，CPU 各个层次的交互，尤其是在共享存储系统中，为了保证程序执行的正确性，就需要对访存事件施加严格的限制。

文献中常见的存储一致性模型包括顺序一致性模型，处理器一致性模型，弱一致性模型，释放一致性模型，急切更新释放一致性模型、懒惰更新释放一致性模型，域一致性模型以及单项一致性模型。不同的存储一致性模型对访存事件次序的限制不同，因而对程序员的要求和所得到的的性能也不一样。存储一致性模型对访存事件次序施加的限制越弱，我们就越有利于提高程序的性能，但编程实现上更困难。

顺序一致性模型由 Lamport 于 1979 年提出。顺序一致性模型最好理解但代价太大，原文指出：

*... the result of any execution is the same as if the operations of all the processors were executed in some sequential order, and the operations of each individual processor appear in this sequence in the order specified by its program.*

该模型指出：如果在共享存储系统中多机并行执行的结果等于把每一个处理器所执行的指令流按照某种方式顺序地交织在一起在单机上执行的结果，则该共享存储系统是顺序一致性的。

顺序一致性不仅在共享存储系统上适用，在多处理器和多线程环境下也同样适用。而在多处理器和多线程环境下理解顺序一致性包括两个方面，(1). 从多个线程平行角度来看，程序最终的执行结果相当于多个线程某种交织执行的结果，(2)从单个线程内部执行顺序来看，该线程中的指令是按照程序事先已规定的顺序执行的(即不考虑运行时 CPU 乱序执行和 Memory Reorder)。

我们以一个具体的例子来理解顺序一致性：

假设存在两个共享变量a, b，初始值均为 0，两个线程运行不同的指令，如下表格所示，线程 1 设置 a 的值为 1，然后设置 R1 的值为 b，线程 2 设置 b 的值为 2，并设置 R2 的值为 a，请问在不加任何锁或者其他同步措施的情况下，R1，R2 的最终结果会是多少？

由于没有施加任何同步限制，两个线程将会交织执行，但交织执行时指令不发生重排，即线程 1 中的 a = 1 始终在 R1 = b 之前执行，而线程 2 中的 b = 2 始终在 R2 = a 之前执行 ，因此可能的执行序列共有 4!/(2!\*2!) = 6 种：

上面的表格列举了两个线程交织执行时所有可能的执行序列，我们发现，R1,R2 最终结果只有 3 种情况，分别是 R1 == 0, R2 == 1(情况 1)，R1 == 2, R2 == 0(情况2) 和 R1 == 2， R2 == 1(情况 3， 4， 5，6)。结合上面的例子，我想大家应该理解了什么是顺序一致性。

因此，多线程环境下顺序一致性包括两个方面，(1). 从多个线程平行角度来看，程序最终的执行结果相当于多个线程某种交织执行的结果，(2)从单个线程内部执行顺序来看，该线程中的指令是按照程序事先已规定的顺序执行的(即不考虑运行时 CPU 乱序执行和 Memory Reorder)。

当然，顺序一致性代价太大，不利于程序的优化，现在的编译器在编译程序时通常将指令重新排序（当然前提是保证程序的执行结果是正确的），例如，如果两个变量读写互不相关，编译器有可能将读操作提前（暂且称为预读prefetch 吧），或者尽可能延迟写操作，假设如下面的代码段：

![复制代码][copycode.gif]

int a = 1, b = 2;
    
    void func()
    {
        a = b + 22;
        b = 22;
    }

![复制代码][copycode.gif]

在GCC 4.4 (X86-64)编译条件下，优化选项为 -O0 时，汇编后关键代码如下：

movl    b(%rip), %eax ; 将 b 读入 %eax
    addl    $22, %eax ; %eax 加 22, 即 b + 22
    movl    %eax, a(%rip) ; % 将 %eax 写回至 a, 即 a = b + 22
    movl    $22, b(%rip) ; 设置 b = 22

而在设置 -O2 选项时，汇编后的关键代码如下：

movl    b(%rip), %eax ; 将 b 读入 %eax
    movl    $22, b(%rip) ; b = 22
    addl    $22, %eax ; %eax 加 22
    movl    %eax, a(%rip) ; 将 b + 22 的值写入 a,即 a = b + 2

由上面的例子可以看出，编译器在不同的优化级别下确实对指令进行了不同程度重排，在 -O0(不作优化)的情况下，汇编指令和 C 源代码的逻辑相同，但是在 -O2 优化级别下，汇编指令和原始代码的执行逻辑不同，由汇编代码可以观察出，b = 22 首先执行，最后才是 a = b + 2， 由此看出，编译器会根据不同的优化等级来适当地对指令进行重排。在单线程条件下上述指令重排不会对执行结果带来任何影响，但是在多线程环境下就不一定了。如果另外一个线程依赖 a，b的值来选择它的执行逻辑，那么上述重排将会产生严重问题。编译器优化是一门深奥的技术，但是无论编译器怎么优化，都需要对优化条件作出约束，尤其是在多线程条件下，不能无理由地优化，更不能错误地优化。

另外，现代的 CPU 大都支持多发射和乱序执行，在乱序执行时，指令被执行的逻辑可能和程序汇编指令的逻辑不一致，在单线程条件下，CPU 的乱序执行不会带来大问题，但是在多核多线程时代，当多线程共享某一变量时，不同线程对共享变量的读写就应该格外小心，不适当的乱序执行可能导致程序运行错误。因此，CPU 的乱序执行也需要作出适当的约束。

综上所述，我们必须对编译器和 CPU 作出一定的约束才能合理正确地优化你的程序，那么这个约束是什么呢？答曰：**内存模型**。C++程序员要想写出高性能的多线程程序必须理解内存模型，编译器会给你的程序做优化(静态)，CPU为了提升性能也有乱序执行(动态)，总之，程序在最终执行时并不会按照你之前的原始代码顺序来执行，因此内存模型是程序员、编译器，CPU 之间的契约，遵守契约后大家就各自做优化，从而尽可能提高程序的性能。

C++11 中规定了 6 中访存次序(Memory Order)，如下：

![复制代码][copycode.gif]

enum memory_order {
        memory_order_relaxed,
        memory_order_consume,
        memory_order_acquire,
        memory_order_release,
        memory_order_acq_rel,
        memory_order_seq_cst
    };

![复制代码][copycode.gif]

`std::memory_order` 规定了普通访存操作和相邻的原子访存操作之间的次序是如何安排的，在多核系统中，当多个线程同时读写多个变量时，其中的某个线程所看到的变量值的改变顺序可能和其他线程写入变量值的次序不相同。同时，不同的线程所观察到的某变量被修改次序也可能不相同。然而，如果保证所有对原子变量的操作都是顺序的话，可能对程序的性能影响很大，因此，我们可以通过`std::memory_order` 来指定编译器对访存次序所做的限制。因此，在原子类型的 API 中，我们可以通过额外的参数指定该原子操作的访存次序(内存序)，默认的内存序是 **std::memory\_order\_seq\_cst**。

我们可以把上述 6 中访存次序(内存序)分为 3 类，顺序一致性模型(std::memory\_order\_seq\_cst)，Acquire-Release 模型(std::memory\_order\_consume, std::memory\_order\_acquire, std::memory\_order\_release, std::memory\_order\_acq\_rel,) 和 Relax 模型(std::memory\_order\_relaxed)。三种不同的内存模型在不同类型的 CPU上(如 X86，ARM，PowerPC等)所带来的代价也不一样。例如，在 X86 或者 X86-64平台下，Acquire-Release 类型的访存序不需要额外的指令来保证原子性，即使顺序一致性类型操作也只需要在写操作(Store)时施加少量的限制，而在读操作(Load)则不需要花费额外的代价来保证原子性。

===================================== TL;DR =====================================

附：本文剩余部分将介绍其他的存储器一致模型中的其他几种较常见的模型：处理器一致性(Processor Consistency)模型，弱一致性(Weak Consistency)模型，释放一致性(Release Consistency)模型。\[注：以下内容来自中国科学院计算技术研究所胡伟武老师写的《计算机体系结构》(清华大学出版社)，该书是胡伟武老师给研究生讲课所用的教材，本文略有删改\]

**处理器一致性(Processor Consistency)模型**：处理器一致性(Processor Consistency)模型比顺序一致性模型弱，因此对于某些在顺序一致性模型下能够正确执行的程序在处理器一致性条件下执行时可能会导致错误的结果，处理器一致性模型对访存事件发生次序施加的限制是：(1). 在任意读操作(Load)被允许执行之前，所有在同一处理器中先于这一 Load 的读操作都已完成；(2). 在任意写操作(Store)被允许执行之前，所有在同一处理器中先于这一 Store 的访存操作(包括 Load 和 Store操作)都已完成。上述条件允许 Store 之后的 Load 越过 Store 操作而有限执行。

**弱一致性(Weak Consistency)模型**：弱一致性(Weak Consistency)模型的主要思想是将同步操作和普通的访存操作区分开来，程序员必须用硬件可识别的同步操作把对可写共享单元的访存保护起来，以保证多个处理器对可写单元的访问是互斥的。弱一致性对访存事件发生次序的限制如下：(1). 同步操作的执行满足顺序一致性条件; (2). 在任一普通访存操作被允许执行之前，所有在同一处理器中先于这一访存操作的同步操作都已完成; (3). 在任一同步操作被允许执行之前，所有在同一处理器中先于这一同步操作的普通操作都已完成。上述条件允许在同步操作之间的普通访存操作执行时不用考虑进程之间的相关，虽然弱一致性增加了程序员的负担，但是它能有效地提高系统的性能。

**释放一致性(Release Consistency)模型**：释放一致性(Release Consistency)模型是对弱一致性(Weak Consistency)模型的改进，它把同步操作进一步分成了获取操作(Acquire)和释放操作(Release)。Acquire 用于获取对某些共享变量的独占访问权，而 Release 则用于释放这种访问权，释放一致性(Release Consistency)模型访存事件发生次序的限制如下：(1). 同步操作的执行满足顺序一致性条件; (2). 在任一普通访存操作被允许执行之前，所有在同一处理器中先于这一访存操作的 Acquire 操作都已完成; (3). 在任一 Release 操作被允许执行之前，所有在同一处理器中先于这一 Release 操作的普通操作都已完成。

在硬件实现的释放一致性模型中，对共享单元的访存是及时进行的，并在执行获取操作(Acquire)和释放操作(Release)时对齐。在共享虚拟存储系统或者在由软件维护的数据一致性的共享存储系统中，由于通信和数据交换的开销很大，有必要减少通信和数据交换的次数。为此，人们在释放一致性(Release Consistency)模型的基础上提出了急切更新释放一致性模型(Eager Release Consistency)和懒惰更新释放一致性模型(Lazy Release Consistency)。在急切更新释放一致性模型中，在临界区内的多个存数操作对共享内存的更新不是及时进行的，而是在执行 Release 操作之前(即退出临界区之前)集中进行，把多个存数操作合并在一起统一执行，从而减少了通信次数。而在懒惰更新释放一致性模型中，由一个处理器对某单元的存数操作并不是由此处理器主动传播到所有共享该单元的其他处理器，而是在其他处理器要用到此处理器所写的数据时(即其他处理器执行 Acquire 操作时)再向此处理器索取该单元的最新备份，这样可以进一步减少通信量。

===============================================================================

好了，本文主要介绍了内存模型的相关概念，并重点介绍了顺序一致性模型（附带介绍了几种常见的存储一致性模型），并以一个实际的小例子向大家介绍了为什么程序员需要理解内存模型，总之，C++ 程序员要想写出高性能的多线程程序必须理解内存模型，因为编译器会给你的程序做优化(如指令重排等)，CPU 为了提升性能也有多发射和乱序执行，因此程序在最终执行时并不会按照你之前的原始代码顺序来执行，所以内存模型是程序员、编译器，CPU 之间的契约，遵守契约后大家就各自做优化，从而尽可能提高程序的性能。

下一节我将给大家介绍 C++11 内存模型中的 6 种访存次序(或内存序)(std::memory\_order\_relaxed, std::memory\_order\_consume, std::memory\_order\_acquire, std::memory\_order\_release, std::memory\_order\_acq\_rel, std::memory\_order\_seq\_cst)各自的意义以及常见的用法，希望感兴趣的同学继续关注，如果您发现文中的错误，一定尽快告诉我 ;-)

另外，后续的几篇博客我会给大家介绍更多的与内存模型相关的知识，我在 Github 上维护了一个[页面][Link 29]，主要是与内存模型相关资料的链接，感兴趣的同学可以参考里面的资料自己阅读。

## [C++11 并发指南九(综合运用: C++11 多线程下生产者消费者模型详解)][C_11 _ C_11] ##

前面八章介绍了 C++11 并发编程的基础(抱歉哈，第五章-第八章还在草稿中)，本文将综合运用 C++11 中的新的基础设施(主要是多线程、锁、条件变量)来阐述一个经典问题——[生产者消费者模型][Link 30]，并给出完整的解决方案。

生产者消费者问题是多线程并发中一个非常经典的问题，相信学过操作系统课程的同学都清楚这个问题的根源。本文将就四种情况分析并介绍生产者和消费者问题，它们分别是：单生产者-单消费者模型，单生产者-多消费者模型，多生产者-单消费者模型，多生产者-多消费者模型，我会给出四种情况下的 C++11 并发解决方案，如果文中出现了错误或者你对代码有异议，欢迎交流 ;-)。

### 单生产者-单消费者模型 ###

顾名思义，单生产者-单消费者模型中只有一个生产者和一个消费者，生产者不停地往产品库中放入产品，消费者则从产品库中取走产品，产品库容积有限制，只能容纳一定数目的产品，如果生产者生产产品的速度过快，则需要等待消费者取走产品之后，产品库不为空才能继续往产品库中放置新的产品，相反，如果消费者取走产品的速度过快，则可能面临产品库中没有产品可使用的情况，此时需要等待生产者放入一个产品后，消费者才能继续工作。C++11实现单生产者单消费者模型的代码如下：

![复制代码][copycode.gif]

#include <unistd.h>
    
    #include <cstdlib>
    #include <condition_variable>
    #include <iostream>
    #include <mutex>
    #include <thread>
    
    static const int kItemRepositorySize  = 10; // Item buffer size.
    static const int kItemsToProduce  = 1000;   // How many items we plan to produce.
    
    struct ItemRepository {
        int item_buffer[kItemRepositorySize]; // 产品缓冲区, 配合 read_position 和 write_position 模型环形队列.
        size_t read_position; // 消费者读取产品位置.
        size_t write_position; // 生产者写入产品位置.
        std::mutex mtx; // 互斥量,保护产品缓冲区
        std::condition_variable repo_not_full; // 条件变量, 指示产品缓冲区不为满.
        std::condition_variable repo_not_empty; // 条件变量, 指示产品缓冲区不为空.
    } gItemRepository; // 产品库全局变量, 生产者和消费者操作该变量.
    
    typedef struct ItemRepository ItemRepository;
    
    
    void ProduceItem(ItemRepository *ir, int item)
    {
        std::unique_lock<std::mutex> lock(ir->mtx);
        while(((ir->write_position + 1) % kItemRepositorySize)
            == ir->read_position) { // item buffer is full, just wait here.
            std::cout << "Producer is waiting for an empty slot...\n";
            (ir->repo_not_full).wait(lock); // 生产者等待"产品库缓冲区不为满"这一条件发生.
        }
    
        (ir->item_buffer)[ir->write_position] = item; // 写入产品.
        (ir->write_position)++; // 写入位置后移.
    
        if (ir->write_position == kItemRepositorySize) // 写入位置若是在队列最后则重新设置为初始位置.
            ir->write_position = 0;
    
        (ir->repo_not_empty).notify_all(); // 通知消费者产品库不为空.
        lock.unlock(); // 解锁.
    }
    
    int ConsumeItem(ItemRepository *ir)
    {
        int data;
        std::unique_lock<std::mutex> lock(ir->mtx);
        // item buffer is empty, just wait here.
        while(ir->write_position == ir->read_position) {
            std::cout << "Consumer is waiting for items...\n";
            (ir->repo_not_empty).wait(lock); // 消费者等待"产品库缓冲区不为空"这一条件发生.
        }
    
        data = (ir->item_buffer)[ir->read_position]; // 读取某一产品
        (ir->read_position)++; // 读取位置后移
    
        if (ir->read_position >= kItemRepositorySize) // 读取位置若移到最后，则重新置位.
            ir->read_position = 0;
    
        (ir->repo_not_full).notify_all(); // 通知消费者产品库不为满.
        lock.unlock(); // 解锁.
    
        return data; // 返回产品.
    }
    
    
    void ProducerTask() // 生产者任务
    {
        for (int i = 1; i <= kItemsToProduce; ++i) {
            // sleep(1);
            std::cout << "Produce the " << i << "^th item..." << std::endl;
            ProduceItem(&gItemRepository, i); // 循环生产 kItemsToProduce 个产品.
        }
    }
    
    void ConsumerTask() // 消费者任务
    {
        static int cnt = 0;
        while(1) {
            sleep(1);
            int item = ConsumeItem(&gItemRepository); // 消费一个产品.
            std::cout << "Consume the " << item << "^th item" << std::endl;
            if (++cnt == kItemsToProduce) break; // 如果产品消费个数为 kItemsToProduce, 则退出.
        }
    }
    
    void InitItemRepository(ItemRepository *ir)
    {
        ir->write_position = 0; // 初始化产品写入位置.
        ir->read_position = 0; // 初始化产品读取位置.
    }
    
    int main()
    {
        InitItemRepository(&gItemRepository);
        std::thread producer(ProducerTask); // 创建生产者线程.
        std::thread consumer(ConsumerTask); // 创建消费之线程.
        producer.join();
        consumer.join();
    }

![复制代码][copycode.gif]

###  单生产者-多消费者模型 ###

与单生产者和单消费者模型不同的是，单生产者-多消费者模型中可以允许多个消费者同时从产品库中取走产品。所以除了保护产品库在多个读写线程下互斥之外，还需要维护消费者取走产品的计数器，代码如下:

![复制代码][copycode.gif]

#include <unistd.h>
    
    #include <cstdlib>
    #include <condition_variable>
    #include <iostream>
    #include <mutex>
    #include <thread>
    
    static const int kItemRepositorySize  = 4; // Item buffer size.
    static const int kItemsToProduce  = 10;   // How many items we plan to produce.
    
    struct ItemRepository {
        int item_buffer[kItemRepositorySize];
        size_t read_position;
        size_t write_position;
        size_t item_counter;
        std::mutex mtx;
        std::mutex item_counter_mtx;
        std::condition_variable repo_not_full;
        std::condition_variable repo_not_empty;
    } gItemRepository;
    
    typedef struct ItemRepository ItemRepository;
    
    
    void ProduceItem(ItemRepository *ir, int item)
    {
        std::unique_lock<std::mutex> lock(ir->mtx);
        while(((ir->write_position + 1) % kItemRepositorySize)
            == ir->read_position) { // item buffer is full, just wait here.
            std::cout << "Producer is waiting for an empty slot...\n";
            (ir->repo_not_full).wait(lock);
        }
    
        (ir->item_buffer)[ir->write_position] = item;
        (ir->write_position)++;
    
        if (ir->write_position == kItemRepositorySize)
            ir->write_position = 0;
    
        (ir->repo_not_empty).notify_all();
        lock.unlock();
    }
    
    int ConsumeItem(ItemRepository *ir)
    {
        int data;
        std::unique_lock<std::mutex> lock(ir->mtx);
        // item buffer is empty, just wait here.
        while(ir->write_position == ir->read_position) {
            std::cout << "Consumer is waiting for items...\n";
            (ir->repo_not_empty).wait(lock);
        }
    
        data = (ir->item_buffer)[ir->read_position];
        (ir->read_position)++;
    
        if (ir->read_position >= kItemRepositorySize)
            ir->read_position = 0;
    
        (ir->repo_not_full).notify_all();
        lock.unlock();
    
        return data;
    }
    
    
    void ProducerTask()
    {
        for (int i = 1; i <= kItemsToProduce; ++i) {
            // sleep(1);
            std::cout << "Producer thread " << std::this_thread::get_id()
                << " producing the " << i << "^th item..." << std::endl;
            ProduceItem(&gItemRepository, i);
        }
        std::cout << "Producer thread " << std::this_thread::get_id()
                    << " is exiting..." << std::endl;
    }
    
    void ConsumerTask()
    {
        bool ready_to_exit = false;
        while(1) {
            sleep(1);
            std::unique_lock<std::mutex> lock(gItemRepository.item_counter_mtx);
            if (gItemRepository.item_counter < kItemsToProduce) {
                int item = ConsumeItem(&gItemRepository);
                ++(gItemRepository.item_counter);
                std::cout << "Consumer thread " << std::this_thread::get_id()
                    << " is consuming the " << item << "^th item" << std::endl;
            } else ready_to_exit = true;
            lock.unlock();
            if (ready_to_exit == true) break;
        }
        std::cout << "Consumer thread " << std::this_thread::get_id()
                    << " is exiting..." << std::endl;
    }
    
    void InitItemRepository(ItemRepository *ir)
    {
        ir->write_position = 0;
        ir->read_position = 0;
        ir->item_counter = 0;
    }
    
    int main()
    {
        InitItemRepository(&gItemRepository);
        std::thread producer(ProducerTask);
        std::thread consumer1(ConsumerTask);
        std::thread consumer2(ConsumerTask);
        std::thread consumer3(ConsumerTask);
        std::thread consumer4(ConsumerTask);
    
        producer.join();
        consumer1.join();
        consumer2.join();
        consumer3.join();
        consumer4.join();
    }

![复制代码][copycode.gif]

###  多生产者-单消费者模型 ###

与单生产者和单消费者模型不同的是，多生产者-单消费者模型中可以允许多个生产者同时向产品库中放入产品。所以除了保护产品库在多个读写线程下互斥之外，还需要维护生产者放入产品的计数器，代码如下:

![复制代码][copycode.gif]

#include <unistd.h>
    
    #include <cstdlib>
    #include <condition_variable>
    #include <iostream>
    #include <mutex>
    #include <thread>
    
    static const int kItemRepositorySize  = 4; // Item buffer size.
    static const int kItemsToProduce  = 10;   // How many items we plan to produce.
    
    struct ItemRepository {
        int item_buffer[kItemRepositorySize];
        size_t read_position;
        size_t write_position;
        size_t item_counter;
        std::mutex mtx;
        std::mutex item_counter_mtx;
        std::condition_variable repo_not_full;
        std::condition_variable repo_not_empty;
    } gItemRepository;
    
    typedef struct ItemRepository ItemRepository;
    
    
    void ProduceItem(ItemRepository *ir, int item)
    {
        std::unique_lock<std::mutex> lock(ir->mtx);
        while(((ir->write_position + 1) % kItemRepositorySize)
            == ir->read_position) { // item buffer is full, just wait here.
            std::cout << "Producer is waiting for an empty slot...\n";
            (ir->repo_not_full).wait(lock);
        }
    
        (ir->item_buffer)[ir->write_position] = item;
        (ir->write_position)++;
    
        if (ir->write_position == kItemRepositorySize)
            ir->write_position = 0;
    
        (ir->repo_not_empty).notify_all();
        lock.unlock();
    }
    
    int ConsumeItem(ItemRepository *ir)
    {
        int data;
        std::unique_lock<std::mutex> lock(ir->mtx);
        // item buffer is empty, just wait here.
        while(ir->write_position == ir->read_position) {
            std::cout << "Consumer is waiting for items...\n";
            (ir->repo_not_empty).wait(lock);
        }
    
        data = (ir->item_buffer)[ir->read_position];
        (ir->read_position)++;
    
        if (ir->read_position >= kItemRepositorySize)
            ir->read_position = 0;
    
        (ir->repo_not_full).notify_all();
        lock.unlock();
    
        return data;
    }
    
    void ProducerTask()
    {
        bool ready_to_exit = false;
        while(1) {
            sleep(1);
            std::unique_lock<std::mutex> lock(gItemRepository.item_counter_mtx);
            if (gItemRepository.item_counter < kItemsToProduce) {
                ++(gItemRepository.item_counter);
                ProduceItem(&gItemRepository, gItemRepository.item_counter);
                std::cout << "Producer thread " << std::this_thread::get_id()
                    << " is producing the " << gItemRepository.item_counter
                    << "^th item" << std::endl;
            } else ready_to_exit = true;
            lock.unlock();
            if (ready_to_exit == true) break;
        }
        std::cout << "Producer thread " << std::this_thread::get_id()
                    << " is exiting..." << std::endl;
    }
    
    void ConsumerTask()
    {
        static int item_consumed = 0;
        while(1) {
            sleep(1);
            ++item_consumed;
            if (item_consumed <= kItemsToProduce) {
                int item = ConsumeItem(&gItemRepository);
                std::cout << "Consumer thread " << std::this_thread::get_id()
                    << " is consuming the " << item << "^th item" << std::endl;
            } else break;
        }
        std::cout << "Consumer thread " << std::this_thread::get_id()
                    << " is exiting..." << std::endl;
    }
    
    void InitItemRepository(ItemRepository *ir)
    {
        ir->write_position = 0;
        ir->read_position = 0;
        ir->item_counter = 0;
    }
    
    int main()
    {
        InitItemRepository(&gItemRepository);
        std::thread producer1(ProducerTask);
        std::thread producer2(ProducerTask);
        std::thread producer3(ProducerTask);
        std::thread producer4(ProducerTask);
        std::thread consumer(ConsumerTask);
    
        producer1.join();
        producer2.join();
        producer3.join();
        producer4.join();
        consumer.join();
    }

![复制代码][copycode.gif]

### 多生产者-多消费者模型 ###

该模型可以说是前面两种模型的综合，程序需要维护两个计数器，分别是生产者已生产产品的数目和消费者已取走产品的数目。另外也需要保护产品库在多个生产者和多个消费者互斥地访问。

代码如下：

![复制代码][copycode.gif]

#include <unistd.h>
    
    #include <cstdlib>
    #include <condition_variable>
    #include <iostream>
    #include <mutex>
    #include <thread>
    
    static const int kItemRepositorySize  = 4; // Item buffer size.
    static const int kItemsToProduce  = 10;   // How many items we plan to produce.
    
    struct ItemRepository {
        int item_buffer[kItemRepositorySize];
        size_t read_position;
        size_t write_position;
        size_t produced_item_counter;
        size_t consumed_item_counter;
        std::mutex mtx;
        std::mutex produced_item_counter_mtx;
        std::mutex consumed_item_counter_mtx;
        std::condition_variable repo_not_full;
        std::condition_variable repo_not_empty;
    } gItemRepository;
    
    typedef struct ItemRepository ItemRepository;
    
    
    void ProduceItem(ItemRepository *ir, int item)
    {
        std::unique_lock<std::mutex> lock(ir->mtx);
        while(((ir->write_position + 1) % kItemRepositorySize)
            == ir->read_position) { // item buffer is full, just wait here.
            std::cout << "Producer is waiting for an empty slot...\n";
            (ir->repo_not_full).wait(lock);
        }
    
        (ir->item_buffer)[ir->write_position] = item;
        (ir->write_position)++;
    
        if (ir->write_position == kItemRepositorySize)
            ir->write_position = 0;
    
        (ir->repo_not_empty).notify_all();
        lock.unlock();
    }
    
    int ConsumeItem(ItemRepository *ir)
    {
        int data;
        std::unique_lock<std::mutex> lock(ir->mtx);
        // item buffer is empty, just wait here.
        while(ir->write_position == ir->read_position) {
            std::cout << "Consumer is waiting for items...\n";
            (ir->repo_not_empty).wait(lock);
        }
    
        data = (ir->item_buffer)[ir->read_position];
        (ir->read_position)++;
    
        if (ir->read_position >= kItemRepositorySize)
            ir->read_position = 0;
    
        (ir->repo_not_full).notify_all();
        lock.unlock();
    
        return data;
    }
    
    void ProducerTask()
    {
        bool ready_to_exit = false;
        while(1) {
            sleep(1);
            std::unique_lock<std::mutex> lock(gItemRepository.produced_item_counter_mtx);
            if (gItemRepository.produced_item_counter < kItemsToProduce) {
                ++(gItemRepository.produced_item_counter);
                ProduceItem(&gItemRepository, gItemRepository.produced_item_counter);
                std::cout << "Producer thread " << std::this_thread::get_id()
                    << " is producing the " << gItemRepository.produced_item_counter
                    << "^th item" << std::endl;
            } else ready_to_exit = true;
            lock.unlock();
            if (ready_to_exit == true) break;
        }
        std::cout << "Producer thread " << std::this_thread::get_id()
                    << " is exiting..." << std::endl;
    }
    
    void ConsumerTask()
    {
        bool ready_to_exit = false;
        while(1) {
            sleep(1);
            std::unique_lock<std::mutex> lock(gItemRepository.consumed_item_counter_mtx);
            if (gItemRepository.consumed_item_counter < kItemsToProduce) {
                int item = ConsumeItem(&gItemRepository);
                ++(gItemRepository.consumed_item_counter);
                std::cout << "Consumer thread " << std::this_thread::get_id()
                    << " is consuming the " << item << "^th item" << std::endl;
            } else ready_to_exit = true;
            lock.unlock();
            if (ready_to_exit == true) break;
        }
        std::cout << "Consumer thread " << std::this_thread::get_id()
                    << " is exiting..." << std::endl;
    }
    
    void InitItemRepository(ItemRepository *ir)
    {
        ir->write_position = 0;
        ir->read_position = 0;
        ir->produced_item_counter = 0;
        ir->consumed_item_counter = 0;
    }
    
    int main()
    {
        InitItemRepository(&gItemRepository);
        std::thread producer1(ProducerTask);
        std::thread producer2(ProducerTask);
        std::thread producer3(ProducerTask);
        std::thread producer4(ProducerTask);
    
        std::thread consumer1(ConsumerTask);
        std::thread consumer2(ConsumerTask);
        std::thread consumer3(ConsumerTask);
        std::thread consumer4(ConsumerTask);
    
        producer1.join();
        producer2.join();
        producer3.join();
        producer4.join();
    
        consumer1.join();
        consumer2.join();
        consumer3.join();
        consumer4.join();
    }

![复制代码][copycode.gif]

另外，所有例子的代码(包括前面一些指南的代码均放在[github][]上)，希望对大家学习 C++11 多线程并发有所帮助。

文章来源：http://www.cnblogs.com/haippy/p/3284540.html

[C_11 _C_11]: http://www.cnblogs.com/haippy/p/3235560.html
[C_11]: http://zh.wikipedia.org/zh-cn/C%2B%2B0x
[C_11 1]: https://en.wikipedia.org/wiki/C%2B%2B11
[Bjarne Stroustrup]: http://www.stroustrup.com/index.html
[C_11 _ FAQ]: http://www.stroustrup.com/C++11FAQ.html
[http_www.open-std.org_jtc1_sc22_wg21]: http://www.open-std.org/jtc1/sc22/wg21/
[http_gcc.gnu.org_projects_cxx0x.html]: http://gcc.gnu.org/projects/cxx0x.html
[https_www2.research.att.com_bs_what-is-2009.pdf]: https://www2.research.att.com/~bs/what-is-2009.pdf
[http_www.artima.com_shop_overview_of_the_new_cpp]: http://www.artima.com/shop/overview_of_the_new_cpp
[http_ishare.iask.sina.com.cn_f_20120005.html_from_like]: http://ishare.iask.sina.com.cn/f/20120005.html?from=like
[http_www.artima.com_cppsource_cpp0x.html]: http://www.artima.com/cppsource/cpp0x.html
[http_www.aristeia.com_C_11_C_11FeatureAvailability.htm]: http://www.aristeia.com/C++11/C++11FeatureAvailability.htm
[http_www.codeproject.com_Articles_344282_Cplusplus-11-Come-Closer]: http://www.codeproject.com/Articles/344282/Cplusplus-11-Come-Closer
[http_www.codeproject.com_Articles_598695_Cplusplus11-threads-locks-and-condition-variables]: http://www.codeproject.com/Articles/598695/Cplusplus11-threads-locks-and-condition-variables
[http_www.codeproject.com_Articles_397492_Move-Semantics-and-Perfect-Forwarding-in-Cplusplus]: http://www.codeproject.com/Articles/397492/Move-Semantics-and-Perfect-Forwarding-in-Cplusplus
[http_solarianprogrammer.com_categories_C_11]: http://solarianprogrammer.com/categories/C++11/
[http_www.baptiste-wicht.com_2012_03_cpp11-concurrency-part1-start-threads]: http://www.baptiste-wicht.com/2012/03/cpp11-concurrency-part1-start-threads/
[http_www.hpl.hp.com_personal_Hans_Boehm_misc_slides_sfacm-cleaned.pdf]: http://www.hpl.hp.com/personal/Hans_Boehm/misc_slides/sfacm-cleaned.pdf
[http_en.cppreference.com_w_cpp_thread]: http://en.cppreference.com/w/cpp/thread
[http_isocpp.org_blog_2012_12_c11-a-cheat-sheet-alex-sinyakov]: http://isocpp.org/blog/2012/12/c11-a-cheat-sheet-alex-sinyakov
[http_blog.smartbear.com_c-plus-plus_the-biggest-changes-in-c11-and-why-you-should-care]: http://blog.smartbear.com/c-plus-plus/the-biggest-changes-in-c11-and-why-you-should-care/
[http_www.codeproject.com_Articles_570638_Ten-Cplusplus11-Features-Every-Cplusplus-Developer]: http://www.codeproject.com/Articles/570638/Ten-Cplusplus11-Features-Every-Cplusplus-Developer
[http_www.codeproject.com_Articles_312029_Cplusplus11-A-Glance-part-1-of-n]: http://www.codeproject.com/Articles/312029/Cplusplus11-A-Glance-part-1-of-n
[http_www.codeproject.com_Articles_314415_Cplusplus11-A-Glance-part-2-of-n]: http://www.codeproject.com/Articles/314415/Cplusplus11-A-Glance-part-2-of-n
[http_mindhacks.cn_2012_08_27_modern-cpp-practices]: http://mindhacks.cn/2012/08/27/modern-cpp-practices/
[http_www.cprogramming.com_c_11_c_11-lambda-closures.html]: http://www.cprogramming.com/c++11/c++11-lambda-closures.html
[http_www.cprogramming.com_c_11_c_11-nullptr-strongly-typed-enum-class.html]: http://www.cprogramming.com/c++11/c++11-nullptr-strongly-typed-enum-class.html
[http_www.cprogramming.com_c_11_rvalue-references-and-move-semantics-in-c_11.html]: http://www.cprogramming.com/c++11/rvalue-references-and-move-semantics-in-c++11.html
[http_www.gotw.ca_publications_index.htm]: http://www.gotw.ca/publications/index.htm
[http_www.devx.com_SpecialReports_Door_38865]: http://www.devx.com/SpecialReports/Door/38865
[http_accu.org_index.php_journals_1584]: http://accu.org/index.php/journals/1584
[http_www.iesensor.com_blog_2011_05_31_c-0x-feature-summary-cheat-sheat]: http://www.iesensor.com/blog/2011/05/31/c-0x-feature-summary-cheat-sheat/
[http_www.justsoftwaresolutions.co.uk_threading_multithreading-in-c_0x-part-1-starting-threads.html]: http://www.justsoftwaresolutions.co.uk/threading/multithreading-in-c++0x-part-1-starting-threads.html
[http_www.cplusplus.com_reference_multithreading]: http://www.cplusplus.com/reference/multithreading/
[copycode.gif]: /images/20220708/113d0a6454d14090b502709167d0292b.png
[C_11 _std_thread]: http://www.cnblogs.com/haippy/p/3236136.html
[Link 1]: http://en.cppreference.com/w/cpp/thread/thread/thread
[get_id]: http://www.cplusplus.com/reference/thread/thread/get_id/
[joinable]: http://www.cplusplus.com/reference/thread/thread/joinable/
[join]: http://www.cplusplus.com/reference/thread/thread/join/
[detach]: http://www.cplusplus.com/reference/thread/thread/detach/
[swap]: http://www.cplusplus.com/reference/thread/thread/swap/
[native_handle]: http://www.cplusplus.com/reference/thread/thread/native_handle/
[hardware_concurrency _static]: http://www.cplusplus.com/reference/thread/thread/hardware_concurrency/
[C_11 _std_mutex]: http://www.cnblogs.com/haippy/p/3237213.html
[Link 2]: http://www.cplusplus.com/reference/mutex/mutex/try_lock/
[Link 3]: http://www.cplusplus.com/reference/mutex/timed_mutex/try_lock_for/
[Link 4]: http://www.cplusplus.com/reference/mutex/lock_guard/
[Link 5]: http://www.cplusplus.com/reference/mutex/unique_lock/
[C_11 _Lock]: http://www.cnblogs.com/haippy/p/3346477.html
[Link 6]: http://www.cplusplus.com/reference/mutex/lock_guard/lock_guard/
[Link 7]: http://www.cplusplus.com/reference/mutex/unique_lock/unique_lock/
[Link 8]: http://www.cplusplus.com/reference/mutex/unique_lock/operator=/
[Link 9]: http://www.cplusplus.com/reference/mutex/unique_lock/lock/
[Link 10]: http://www.cplusplus.com/reference/mutex/unique_lock/try_lock/
[Link 11]: http://www.cplusplus.com/reference/mutex/unique_lock/try_lock_for/
[Link 12]: http://www.cplusplus.com/reference/mutex/unique_lock/try_lock_until/
[Link 13]: http://www.cplusplus.com/reference/mutex/unique_lock/release/
[Link 14]: http://www.cplusplus.com/reference/mutex/unique_lock/operator_bool/
[Link 15]: http://www.cplusplus.com/reference/mutex/unique_lock/mutex/
[C_11 _future_ _ std_promise]: http://www.cnblogs.com/haippy/p/3239248.html
[C_11 _future_ _ std_packaged_task]: http://www.cnblogs.com/haippy/p/3279565.html
[http_www.cplusplus.com_reference_future_packaged_task]: http://www.cplusplus.com/reference/future/packaged_task/
[C_11 _future_ _ std_future _ std_shared_future]: http://www.cnblogs.com/haippy/p/3280643.html
[Link 16]: http://www.cplusplus.com/reference/future/future/
[Link 17]: http://www.cplusplus.com/reference/future/future/get/
[Link 18]: http://www.cplusplus.com/reference/future/future/wait/
[operator]: http://www.cplusplus.com/reference/future/shared_future/operator=/
[get]: http://www.cplusplus.com/reference/future/shared_future/get/
[valid]: http://www.cplusplus.com/reference/future/shared_future/valid/
[wait]: http://www.cplusplus.com/reference/future/shared_future/wait/
[wait_for]: http://www.cplusplus.com/reference/future/shared_future/wait_for/
[wait_until]: http://www.cplusplus.com/reference/future/shared_future/wait_until/
[Link 19]: http://www.cplusplus.com/reference/future/future_errc/
[Link 20]: http://www.cplusplus.com/reference/future/future_status/
[Link 21]: http://www.cplusplus.com/reference/future/launch/
[C_11 _std_condition_variable]: http://www.cnblogs.com/haippy/p/3252041.html
[Link 22]: http://en.wikipedia.org/wiki/Monitor_%28synchronization%29
[MSDN]: http://msdn.microsoft.com/en-us/library/windows/desktop/ms682052%28v=vs.85%29.aspx
[Link 23]: http://www.cplusplus.com/reference/condition_variable/condition_variable/
[Link 24]: http://www.cplusplus.com/reference/condition_variable/condition_variable/wait/
[Link 25]: http://www.cplusplus.com/reference/condition_variable/condition_variable/wait_for/
[Link 26]: http://www.cplusplus.com/reference/condition_variable/condition_variable/notify_one/
[Link 27]: http://www.cplusplus.com/reference/condition_variable/notify_all_at_thread_exit/
[C_11 _atomic _ atomic_flag]: http://www.cnblogs.com/haippy/p/3252056.html
[C_11 _ _atomic_ _ std_atomic]: http://www.cnblogs.com/haippy/p/3301408.html
[Link 28]: http://www.cplusplus.com/reference/atomic/atomic/compare_exchange_weak/
[C_11 _atomic _ std_atomic]: http://www.cnblogs.com/haippy/p/3304556.html
[C_11 _atomic _ C]: http://www.cnblogs.com/haippy/p/3306625.html
[C_11 _C_11 1]: http://www.cnblogs.com/haippy/p/3412858.html
[atomic_store]: http://en.cppreference.com/w/cpp/atomic/atomic_store
[atomic_load]: http://en.cppreference.com/w/cpp/atomic/atomic_load
[atomic_exchange]: http://en.cppreference.com/w/cpp/atomic/atomic_exchange
[atomic_compare_exchange]: http://en.cppreference.com/w/cpp/atomic/atomic_compare_exchange
[07162105-85c403b5f8ae4ea882af842d6d178273.png]: /images/20220708/277155b9578047359dc909b9e476d3fd.png
[Link 29]: https://github.com/forhappy/A-Detailed-Cplusplus-Concurrency-Tutorial/blob/master/zh/chapter8-Memory-Model/web-resources.md
[C_11 _ C_11]: http://www.cnblogs.com/haippy/p/3252092.html
[Link 30]: http://zh.wikipedia.org/wiki/%E7%94%9F%E4%BA%A7%E8%80%85%E6%B6%88%E8%B4%B9%E8%80%85%E9%97%AE%E9%A2%98
[github]: https://github.com/forhappy/c-recipes/tree/master/c%2B%2B11/concurrency