C++11多线程初体验

小咪咪 2022-08-08 12:55 151阅读 0赞

在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;
    }

运行结果：  
![运行结果][20150518161154682]

可以看到先执行主线程，然后是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_-atomic]

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

[20150518161154682]: /images/20220805/325d521d33814d93aef4c830db31929f.png
[C_-atomic]: http://www.cplusplus.com/reference/atomic/