c++基础11、线程间数据共享

上一篇讲述了 如何去管理线程，std::thread 线程的创建、等待、分离、共享、所有权的转移，基础的理念，这一篇准备了解一下线程间数据共享机制，有以下模块。

 一、线程数据共享

        在同一个进程当中，允许多线程的存在，不管是不是有无数据共享，多线程之间仍然保持着资源竞争，共享同一个进程的资源，并无时无刻的切换上下文进行cpu 的调度，如当访问同一个变量的时候，原因对变量的操作，是先从内存中读取数据到寄存器当中，修改完成之后，在重新写入内存，由于这期间线程先后访问不一，可以对同一变量同时进行读写操作，造成变量的不确定性，因此如果不控制对共享数据的访问先后，会产生错误的结果看，这样就会带来问题。

#include <thread>
#include <iostream>

int i=0;

void test(){
     i++;
     std::cout<<"i value:"<<i<<std::endl;
}

int main(int argc, char *argv[])
{
    int cpu_num = std::thread::hardware_concurrency();
    std::cout<<"cpu_num value:"<<cpu_num<<std::endl;
    std::thread threads[cpu_num];
    for(int n=0;n<cpu_num;n++){
        threads[n] = std::thread (test);
    }
    for (auto& t: threads) {
           t.join();
    }
}

以上代码就会造成对共享资源 i 最后结果的不一致性，这就是多线程访问会造成的影响 。

二、使用互斥量访问共享资源

因为多线程之间的竞争导致结果的不一致性，我们可以使用互斥量进行访问，如下代码简述

#include <thread>
#include <iostream>
#include <mutex>

std::mutex mu;

int i=0;

void test(){

     std::lock_guard<std::mutex> guard(mu);
     i++;
     std::cout<<"i value:"<<i<<std::endl;
}

int main(int argc, char *argv[])
{
    int cpu_num = std::thread::hardware_concurrency();
    std::cout<<"cpu_num value:"<<cpu_num<<std::endl;
    std::thread threads[cpu_num];
    for(int n=0;n<cpu_num;n++){
        threads[n] = std::thread (test);
    }
    for (auto& t: threads) {
           t.join();
    }
}

通常不直接使用std::mutex的成员函数lock 借鉴于RALL 思想，在函数执行完毕的时候进行解琐，所以会使用  std::lock_guard<std::mutex> guard(mu);作为一种处理方式。

三、保护共享数据的方式

  方式1、一些资源仅需要在第一次初始化的时候需要保护，其时候就可以不需要互斥变量的保护了。比如编码中最常见的单例模式，核心代码如下.,创建单例是一种保护方式。

//（3）获得本类实例的唯一全局访问点
static CSinglton* GetInstance()
{
    //若实例不存在，则创建实例对象
    if (NULL == pInstance)
    {
        pInstance = new CSinglton();
    }
//实例已经存在，直接该实例对象
    return pInstance;
}

方式2、使用双重锁定方式单例模式，主要是使用互斥量来进行初始化。

static CSinglton* GetInstance()
{
     //仅在实例未被创建时加锁，其他时候直接返回
    if (NULL == pInstance)
    {
        std::lock_guard<std::mutex> guard(g_mutex)
        if (NULL == pInstance)
        {
            //若实例不存在，则创建实例对象
            pInstance = new CSinglton();//步骤一
        }
    }
    //实例已经存在，直接该实例对象
    return pInstance;
}
//执行代码
GetInstance()->dosomething();//步骤二

方式3、std::call_once保护共享数据
为了解决双重锁定以及创建多个实例的问题，C++11标准库提供了std::once_flag和std::call_once来处理只初始化一次的情况。使用std::call_once比显式使用互斥量消耗的资源更少，并且还是无锁式编程，减少了死锁问题的发生。

std::once_flag flag;
 
void simple_do_once()
{
    std::call_once(flag, [](){ std::cout << "Simple example: called once\n"; });
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    std::thread st1(simple_do_once);
    std::thread st2(simple_do_once);
    std::thread st3(simple_do_once);
    std::thread st4(simple_do_once);
    st1.join();
    st2.join();
    st3.join();
    st4.join();
 
    std::cout << "main thread end\n";
}

由于本人经验有限，如有错误，欢迎修正。