C++11多线程初体验

在C++11标准之前，使用C++编写多线程程序要么需要第三方的API如pthread，要么需要依赖运行平台提供的API，使用起来很不方便。而C++11提供了平台无关的语言级别的支持，这极大得方便了我们开发人员。

C++11的多线程支持主要通过使用如下的头文件中的类或者函数：<atomic><thread><mutex><condition_variable><future>。

新建线程

通过std::thread类新建线程。一般有两种方式：
1） 传递一个函数（可以是函数指针或者Lambda表达式等）
2） 传递一个对象，该对象重载了操作符()，也可以说该对象中必须有一个名为operator()的函数。

下面看实例（Visual Studio 2015运行通过）：

#include <thread>
#include <iostream>

using namespace std;

// 一个普通的函数
void fun(int num)
{
    cout << "The function child thread begin...\n";
    cout << "I come from function fun(): " << num << ‘\n‘;
    cout << "The function child thread end...\n";
    cout << endl;
}

// 一个函数类，实现了operator()方法
class Fun
{
public:
    void operator()(int num)
    {
        cout << "The class child thread begin...\n";
        cout << "I come from class Fun: " << num << ‘\n‘;
        cout << "The class child thread end...\n";
        cout << endl;
    }
};

int main()
{
    cout << "Main thread begin..." << ‘\n‘;
    cout.sync_with_stdio(true); // 设置输入流cout是线程安全的
    thread t_1(fun, 1); // 新建线程，第一个参数是函数指针，第二个参数是函数的参数（第二个参数是可变长参数）
    t_1.join(); // join方法数会阻塞主线程直到目标线程调用完毕，即join会直接执行该子线程的函数体部分
    thread t_2(fun, 2);
    t_2.detach(); // detach方法不会阻塞任何线程，目标线程就成为了守护线程，驻留后台运行
    Fun oFun;
    thread t_3(ref(oFun), 3); //这里新建线程，使用对象进行初始化，这里的通过ref传递的是oFun本身而不是其拷贝
    t_3.join();
    cout << "Main thread end..." << endl;
    return 0;
}

运行结果：

可以看到先执行主线程，然后是t_1子线程，然后是t_2子线程，但是t_2子线程没有执行完毕，又开始执行t_3子线程，等t_3执行完毕，接着执行t_2，然后是结束主线程。
为什么会是这样的结果呢？因为t_1和t_3调用的是thread的join方法，而t_2调用的是detach方法。
join()等待该子线程执行完之后，主线程才可以继续执行下去，此时主线程会释放掉执行完后的子线程资源。而detach()将子线程从主线程里分离，成为一个后台线程，子线程执行完成后会自己释放掉资源。分离后的线程，主线程将对它没有控制权了。

线程同步问题

一提到线程，一定会有资源竞争，以及死锁活锁的问题。
C++中提供atomic保持变量的原子性，个人感觉有些类似于Java和C#中的volatile关键字。
下面看这样一个例子：

#include <thread>
#include <iostream>
#include <vector>

using namespace std;

void func(int& counter)
{
    for (int i = 0; i < 100000; ++i)
    {
        ++counter;
    }
}

int main()
{
    int counter = 0;
    vector<thread> threads;
    for (int i = 0; i < 10; ++i)
    {
        threads.push_back(thread(func, ref(counter)));
    }
    for (auto& current_thread : threads)
    {
        current_thread.join();
    }
    cout << "Result = " << counter << ‘\n‘;
    return 0;
}

你多执行几次，会发现每次输出的counter的值并不总是1000000（100000*10=1000000，10个线程，每个线程每次增加100000），为什么呢？这就涉及到多线程中资源的竞争问题。
那么如何解决这个问题呢？C++中提供了atomic类，看修改后的程序：

#include <thread>
#include <iostream>
#include <vector>
#include <atomic>

using namespace std;

void func(atomic<int>& counter)
{
    for (int i = 0; i < 100000; ++i)
    {
        ++counter;
    }
}

int main()
{
    atomic<int> counter(0);
    vector<thread> threads;
    for (int i = 0; i < 10; ++i)
    {
        threads.push_back(thread(func, ref(counter)));
    }
    for (auto& current_thread : threads)
    {
        current_thread.join();
    }
    cout << "Result = " << counter << ‘\n‘;
    return 0;
}

这样执行上面程序不管多少次输出总是：Result = 1000000
此外，atomic类还提供了封装好的一些函数操作，详见：C++参考-atomic

初始C++多线程，就写到这里。