c++多线程 thread mutex 使用小结

c++对于多线程的支持，依赖于 std::thread std::mutex

std::thread std::mutex 基本使用方法

std::thread的头文件是 #inlcude <thread>
std::mutex头文件是 #include <mutex>

std::thread 用于开启一个线程。

void threadfunc()
{
    printf("sub thread\n");
}

int main(int argc, const char * argv[])
{
    std::thread th(threadfunc);
    //th.join();
    th.detach();
    return 0;
}

上面的代码中 std::thread th(threadfunc) 开启了一个子线程。子线程的主函数是 threadfunc().

线程开启后，必须 join() 或者 detach() 否则会出现 th 这个变量退出作用域，被析构时，会报异常。

join() 的含义是，主线程必须等到这个子线程执行结束，才能继续。子线程结束之前，主线程会卡死在 th.join() 这一行。

detach() 的含义是，此线程与 th 这个变量毫无关联。这时，如果 th 变量析构后，不影响子线程的执行。并且 detach() 之后,主线程、子线程交替执行，两个线程之间没有先后关系。

对于游戏开发的情况来说，个人认为大部分用到的是 detach 的线程。因为游戏的主线程通常作为渲染线程，让渲染线程等待一个 join 的子线程完全执行完毕之后，再继续执行，这样卡住渲染线程的做法，完全没有意义。

如果希望给线程的主函数传递参数，则直接在构造 std::thread 对象时直接传参数即可。

void threadfunc(int& a,bool b)
{
    a = 55;
    printf("sub thread %d %d\n",a,b);
}

int main(int argc, const char * argv[])
{
    int test = 1;
    bool bb = false;
    std::thread th(threadfunc,std::ref(test),bb);
    th.detach();
    return 0;
}

比如上面的例子里，希望给 threadfunc 传递参数，直接在 std::thread th 的函数里，写上参数即可。需要注意的是，当参数是引用时，需要使用 std::ref ，否则无法编译通过。

std::mutex 是互斥锁，防止不同线程间的代码在不同线程间做不安全的切换

例如，一个子线一直往数组 std::vector arr 里插入元素，主线程一直从数组里删除元素。两个线程同时涉及修改 arr 变量。为了防止线程不同步，两个线程在各自操作 arr变量前，需要声明一个 std::mutex 变量，用 lock() unlock() 把关键的代码包围起来。

#include <stdio.h>
#include <thread>
#include <mutex>
#include <vector>

std::mutex mtx;
std::vector<int> arr;

void threadfunc()
{
    while(true)
    {
        mtx.lock();
        arr.push_back(3);
        mtx.unlock();
    }
}

int main(int argc, const char * argv[])
{
    std::thread th(threadfunc);
    th.detach();
    
    
    while(true)
    {
        mtx.lock();
        if(arr.size() > 0) {
            arr.erase(arr.begin());
        }
        mtx.unlock();
    }
    return 0;
}

mutex 的 lock() 函数是会阻塞线程的。如果在 lock() 时，该 mutex 已经被其他线程调用了 lock,则此时会将线程卡死在 lock() 函数调用的位置，直到其他线程 unlock() 释放了 mutex ，这个线程才能继续执行。

但是这样，对于游戏主线程作为渲染线程来说，卡死线程是不能接受的。因此，std::mutex 对象的另外一个函数 try_lock() ，在主线程里面使用时，更符合实际应用的场景。

std::mutex try_lock()

try_lock() 尝试获取 mutex 的 lock,如果成功返回 true;失败时返回 false ，但是不会卡住当前线程。因此，在游戏的主线程里，使用 mutex 的 try_lock() 更合适。

上面的代码，主线程可以改成这样:

int main(int argc, const char * argv[])
{
    std::thread th(threadfunc);
    th.detach();
    while(true)
    {
        if(mtx.try_lock())
        {
            if(arr.size() > 0) {
                arr.erase(arr.begin());
            }
            mtx.unlock();
        }
    }
    return 0;
}

---

手机游戏客户端开发中，绝大部分游戏逻辑不会涉及到多线程。常见的有以下两个方面，会涉及到多线程的应用：

1. 开启一个线程，用于接收网络消息。
2. 开启一个线程，处理比较耗时的操作，避免卡死主线程。

下面利用c++的 std::thread ,std::mutex，写一个demo,模仿游戏开发中常会遇到的两种情况

子线程作生产者、主线程做消费者

这种情况用于模仿游戏接收和处理网络消息的情形。

子线程用于监听网络消息，作为消息对象的生产者，一旦收到消息，就生成一个消息对象，存储到消息对象缓存中；
游戏主线程，作为消息对象的消费者，一旦发现有尚未处理的消息对象，逐一处理这小消息，并把处理过的消息对象从消息缓存中移除。

下面用代码模拟这种情形。

###定义一个消息对象的类 ShareItem

class ShareItem
{
public:
    ShareItem(int num)
    :m_nNum(num)
    {
        
    }
    int getNum() const { return m_nNum;}
private:
    int m_nNum = 0;
};

这个类有一个 int型的 id,用于做区分。

###定义一个消息对象的缓存池 SharePool

class SharePool
{
public:
    bool isMax() const { return m_arrItems.size() >= 10; }
public:
    std::mutex  m_mutex;
    std::vector<ShareItem*> m_arrItems;
};

缓存池里有一个 ShareItem* 的 vector 集合。每当子线程生产一个ShareItem,收藏对象到这里。

定义 SharePool 对象，声明子线程入口函数

static SharePool pool;
void producerMain(SharePool& p);

子线程入口函数的实现如下：

void producerMain(SharePool& p)
{
    static int nextIndex = 0;
    while(true)
    {
        p.m_mutex.lock();
        if(!p.isMax())
        {
            p.m_arrItems.push_back(new ShareItem(nextIndex++));
        }
        p.m_mutex.unlock();
        sleep(2);
    }
}

这里测试每2秒 sleep(2) 生产一个 ShareItem* 存储到 SharePool 里。在操作 SharePool 的过程中，互斥量 mutex 做了 lock() unlock() 的处理.

主线程每帧执行的函数里，取出来 SharePool 里面所有的 ShareItem ，用于显示 SharePool 里所有的内容:

void TestScene::update(float deltaTime)
{
    if(pool.m_mutex.try_lock())
    {
        std::string strItems = "";
        for(size_t i = 0;i < pool.m_arrItems.size();i++)
        {
            char buf[100];
            ShareItem* pItem = pool.m_arrItems[i];
            sprintf(buf,"item:%d\n",pItem->getNum());
            strItems += buf;
        }
        m_pLabel->setString(strItems);
        pool.m_mutex.unlock();
    }
}

为了测试在主线程中做“消费”，定义了一个按钮，每点击一次，就从 SharePool 里，取走一个 ShareItem* 对象。

pBtnCost->addClickEventListener([&](Ref* pRef){
    if(pool.m_mutex.try_lock())
    {
        if(!pool.m_arrItems.empty())
        {
        	std::vector<ShareItem*>::iterator it = pool.m_arrItems.begin();
        	ShareItem* pItem = *it;
        	// cost one item
        	delete pItem;
            pool.m_arrItems.erase(it);
        }
        pool.m_mutex.unlock();
    }
});

这样就可以在屏幕上看到 SharePool 里当前 ShareItem 的存储情况。并且点击消费按钮，还能随时消费掉子线程里产生的 ShareItem.比较直观的能够看到"生产者消费者"模型。

如果把 ShareItem 定义为网络消息， SharePool 用于存储尚未处理的网络消息，做一些封装，是能套用到这个模型里的。

子线程做加载、主线程显示百分比

先定义一个百分比的数字，从0开始，到100认为是结束。
再定义一个这个百分比数字的 mutex 互斥锁。
声明一个 loadSomeRes() 的子线程入口函数。

volatile int nLoadPct = 0;
std::mutex loadPctMutex;	
void loadSomeRes();

这里的 nLoadPct 声明时增加了 volatile 关键字。查阅了一些网上的资料，这个关键字保证编译器不会在取得这个变量时，从寄存器中获取，而是每次必须从内存中获取，防止被编译器优化。这个 volatile 关键字，能够保证多个 线程共享一个变量时，能够正确的获取变量值。

至于为什么上面的案例， SharePool 变量为什么不需要加 volatile ，
我没有弄明白原因。猜测只有简单的变量类型，必须加 volatile 关键字？
复杂的变量，由于不会简单的从寄存器中获取，所有不需要加这个关键字？
目前我还不太明白，但是至少从运行结果上来看没有错误。
待查.

加载线程代码如下：

void loadSomeRes()
{
    while(true)
    {
        
        loadPctMutex.lock();
        if(nLoadPct < 100)
        {
	        // sleep 2秒 放在 mutex lock/unlock 中间 ，模拟非常耗费时间的操作
            usleep(1000 * 2000);    
            nLoadPct++;
            printf("load process ? %d\n",nLoadPct);
            loadPctMutex.unlock();
        }
        else
        {
            loadPctMutex.unlock();
            break;
        }
        // sleep 一下看主线程是否能够 try_lock() 成功
        usleep(1000 * 20);   
    }
}

这里 把 usleep(1000 * 2000) 睡眠 2秒放在 mutex 的 lock,unlock 之间，用于模拟非常耗时的加载。

主线程，每帧调用的函数里，里读取加载的百分比

    // update load  percent
    if(loadPctMutex.try_lock())
    //loadPctMutex.lock();
    {
        char buf[100];
        sprintf(buf,"loaded %d%",nLoadPct);
        m_pPctLabel->setString(buf);
        loadPctMutex.unlock();
    }

这样，就能在游戏画面里，显示出来加载的百分比了。

多线程里遇到的几个问题：

• volatile 关键字. 上面已经提到了，是不是只有简单的类型才需要加这个关键字？
• 主线程里try_lock()一直失败的问题. 在加载的子线程里，每帧 usleep(1000*20) 休息20毫秒，
  才能保证主线程的 update() 里 try_lock() 有时候成功，否则 很容易出现主线程的 update() 里面次次不成功，只有等待子线程完全结束，不再 lock() 后，才能成功。即使子线程 sleep 也并不能保证主线程 try_lock() 次次成功.
• 主线程里只读时，是否需要加锁? 一种说法是， 子线程修改一个简单的数字，主线程读取一个简单的数字，两个线程都不需要加锁。另一种说法是，两个线程，无论是否涉及读写，都应该在加锁。个人更倾向第二种说法。

---

volatile 关键字的原理
C++多线程有必要加volatile么？

---

volatile 关键字在多线程中的应用,可以参考下面链接，“多线程下的 volatile"这一部分
C/C++volatile关键字详解

---

感觉网上转来转去的文章很多，说法也不是很一致。

个人理解如下：
volatile 本意只是用来防止编译器优化，每次取值时候都从内存中取值，而不从寄存器中取值。
volatile本身跟多线程没有任何关系。多线程本身的同步，还是需要 mutex 来保证的。
之所以在多线程中需要注意，是因为多个线程共享变量时，如果该变量真的被“优化”了(从寄存器中取值而非从内存中取值的时候),就可能会出现跟自己的理解所不一致的情况发生。
因此，要在一些关键部分的变量，增加 volatile 关键字。

---

多线程读写的时候，什么时候需要加锁

如果按照上面这个文章的说法，只有多个线程通时写，或者多个线程通时读的时候，才需要加锁。这样的话，似乎一个线程写，另外一个线程读，是不需要加锁的。

---

https://bbs.csdn.net/topics/390248385
这个帖子讨论得也比较多。贴在这里做个参考。虽然里面一些人支持读取时候不需要加锁，不少人认为这和业务逻辑相关。就“游戏客户端里，显示加载百分比”这个需求来说，似乎加锁不加锁都是可以接受的。