(3)数据竞争与互斥对象

这节课终于要解决之前的一个bug了，也就是数据竞争的问题，先看一下如下代码:

#include <thread>
#include <iostream>
#include <string>
using namespace std;

void function_1()
{
    for(int i=0;i>-100;--i)
        cout << "from t1: " << i << endl;
}

int main(int argc, char** argv)
{
    std::thread t1(function_1);
    for(int i=0;i<100;++i)
        cout << "from main:" << i << endl;
    t1.join();
    return 0;
}

该代码在运行的时候，毫无规律可言，并且每一次运行结果都不一样，因为主线程和子线程都在抢占cout的使用．为了解决这个问题，我们引入互斥对象，所以先加上<mutex>这个头文件．然后通过定义一个全局变量mu,来控制两个线程对cout的使用．在视频中，当代码添加mutex的时候，就可以使得输出有序，让两个线程交替输出，但是我在复现的的时候，输出还是无序，但是可以肯定的是，线程之间没有数据竞争的问题了，所以，我自己通过添加了延时函数，现在也达到了两个线程有序输出的状态．

#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <unistd.h>

using namespace std;

std::mutex mu; 
void shared_print(string msg,int id)
{
    mu.lock();
    cout << msg << id << endl;
    mu.unlock();
}
void function_1()
{
    for(int i=0;i>-100;--i)
    {
        sleep(1);
        shared_print( "from t1: " , i );
        }
}

int main(int argc, char** argv)
{
    std::thread t1(function_1);
    for(int i=0;i<100;++i)
    {
        sleep(1);//保证两个线程交替输出，可以将延时时间改小
        shared_print( "from main:" , i );
    }
    t1.join();　
    return 0;
}

哦，是不是很完美的解决了数据竞争的问题了？但是，如果在shared_print函数中，如果在lock()和unlock()之间出现异常的话，那么mu就会被永远锁住了，这又该怎么解决呢？别担心，兵来将档，水来土掩，这里引入新的类型，即std::lock_guard<std::mutex>,它可以保证，即时过程中出现异常，mu对象也可以正常释放解锁．

然而，难道你们没有发现cout本身就是全局对象吗，也就是cout并没有在互斥对象mu的保护下，即其他线程也依旧可以在不加锁的情况下使用cout．所以为了改善这个问题，需要将mu和cout进行绑定．

这里我们通过自定义一个类的方式来解决这个资源抢占问题，代码如下所示．

#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <unistd.h>
#include <fstream>

using namespace std;

class Logfile
{
public:
    Logfile(){
        f.open("log.txt");
    }
    void shared_print(std::string msg,int id)
    {
        std::lock_guard<std::mutex> locker(mu);
        f << msg << id << endl;
    }
    //另外需要强调的是，我们既然选择这种方式来绑定mu和f，那我们就不能将f暴露在类外，类似如下这些函数都是不允许的
    //std::ofstream& GetStream(){return f;}
    //void process(void fun(ofstream&))
    //{
        //fun(f);
    //}
private:
    std::mutex mu;
    std::ofstream f;// 这样就将mu和f绑定在了一起，当Logfile对象在使用f的时候，其他线程就不能使用它
};
void function_1(Logfile& log)
{
    for(int i=0;i>-10;--i)
    {
    sleep(1);
    log.shared_print( "from t1: " , i );
    }
}

int main(int argc, char** argv)
{
    Logfile log;
    std::thread t1(function_1,std::ref(log));
    for(int i=0;i<10;++i)
    {   
    sleep(1);
    log.shared_print("from main: ",i);
    }
    t1.join();
    return 0;
}