C++11 多线程（std::thread）实例

C++11的std::thread
在C中已经有一个叫做pthread的东西来进行多线程编程，但是并不好用 （如果你认为句柄、回调式编程很实用，那请当我没说），所以c++11标准库中出现了一个叫作std::thread的东西。

std::thread常用成员函数
构造&析构函数

举个栗子

例一：thread的基本使用

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
using namespace std;
void doit() { cout << "World!" << endl; }
int main() {
    // 这里的线程a使用了 C++11标准新增的lambda函数
    // 有关lambda的语法，请参考我之前的一篇博客
    // https://blog.csdn.net/sjc_0910/article/details/109230162
    thread a([]{
        cout << "Hello, " << flush;
    }), b(doit);
    a.join();
    b.join();
    return 0;
}

那么，为什么会有不同的结果呢？
这就是多线程的特色！

多线程运行时是以异步方式执行的，与我们平时写的同步方式不同。异步方式可以同时执行多条语句。

在上面的例子中，我们定义了2个thread，这2个thread在执行时并不会按照一定的顺序。打个比方，2个thread执行时，就好比赛跑，谁先跑到终点，谁就先执行完毕。

例二：thread执行有参数的函数

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
using namespace std;
void countnumber(int id, unsigned int n) {
    for (unsigned int i = 1; i <= n; i++);
    cout << "Thread " << id << " finished!" << endl;
}
int main() {
    thread th[10];
    for (int i = 0; i < 10; i++)
        th[i] = thread(countnumber, i, 100000000);
    for (int i = 0; i < 10; i++)
        th[i].join();
    return 0;
}

 

注意：我说的是有可能。你的运行结果可能和我的不一样，这是正常现象，在上一个例子中我们分析过原因。

这个例子中我们在创建线程时向函数传递了一些参数，但如果要传递引用参数呢？是不是像这个例子中直接传递就行了？

让我们来看看第三个例子：

例三：thread执行带有引用参数的函数

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
using namespace std;
template<class T> void changevalue(T &x, T val) {
    x = val;
}
int main() {
    thread th[100];
    int nums[100];
    for (int i = 0; i < 100; i++)
        th[i] = thread(changevalue<int>, nums[i], i+1);
    for (int i = 0; i < 100; i++) {
        th[i].join();
        cout << nums[i] << endl;
    }
    return 0;
}

如果你尝试编译这个程序，那你的编译器一定会报错

 这是怎么回事呢？原来thread在传递参数时，是以右值传递的：

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
using namespace std;
template<class T> void changevalue(T &x, T val) {
    x = val;
}
int main() {
    thread th[100];
    int nums[100];
    for (int i = 0; i < 100; i++)
        th[i] = thread(changevalue<int>, ref(nums[i]), i+1);
    for (int i = 0; i < 100; i++) {
        th[i].join();
        cout << nums[i] << endl;
    }
    return 0;
}

这次编译可以成功通过，你的程序输出的结果应该是这样的：

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
using namespace std;
int n = 0;
void count10000() {
    for (int i = 1; i <= 10000; i++)
        n++;
}
int main() {
    thread th[100];
    // 这里偷了一下懒，用了c++11的foreach结构
    for (thread &x : th)
        x = thread(count10000);
    for (thread &x : th)
        x.join();
    cout << n << endl;
    return 0;
}

例四：std::mutex的使用

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int n = 0;
mutex mtx;
void count10000() {
    for (int i = 1; i <= 10000; i++) {
        mtx.lock();
        n++;
        mtx.unlock();
    }
}
int main() {
    thread th[100];
    for (thread &x : th)
        x = thread(count10000);
    for (thread &x : th)
        x.join();
    cout << n << endl;
    return 0;
}

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
// #include <mutex> //这个例子不需要mutex了
#include <atomic>
using namespace std;
atomic_int n = 0;
void count10000() {
    for (int i = 1; i <= 10000; i++) {
        n++;
    }
}
int main() {
    thread th[100];
    for (thread &x : th)
        x = thread(count10000);
    for (thread &x : th)
        x.join();
    cout << n << endl;
    return 0;
}

 

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
#include <future>
using namespace std;
int main() {
    async(launch::async, [](const char *message){
        cout << message << flush;
    }, "Hello, ");
    cout << "World!" << endl;
    return 0;
}

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
// #include <thread> // 这里我们用async创建线程
#include <future> // std::async std::future
using namespace std;

template<class ... Args> decltype(auto) sum(Args&&... args) {
    // C++17折叠表达式
    // "0 +"避免空参数包错误
    return (0 + ... + args);
}

int main() {
    // 注：这里不能只写函数名sum，必须带模板参数
    future<int> val = async(launch::async, sum<int, int, int>, 1, 10, 100);
    // future::get() 阻塞等待线程结束并获得返回值
    cout << val.get() << endl;
    return 0;
}

例八：void特化std::future

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <future>
using namespace std;
void count_big_number() {
    // C++14标准中，可以在数字中间加上单
    // 引号 ' 来分隔数字，使其可读性更强
    for (int i = 0; i <= 10'0000'0000; i++);
}
int main() {
    future<void> fut = async(launch::async, count_big_number);
    cout << "Please wait" << flush;
    // 每次等待1秒
    while (fut.wait_for(chrono::seconds(1)) != future_status::ready)
        cout << '.' << flush;
    cout << endl << "Finished!" << endl;
    return 0;
}

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
using namespace std;
constexpr long double PI = 3.14159265358979323846264338327950288419716939937510582097494459230781640628;
// 给定圆的半径r，求圆的直径、周长及面积
void get_circle_info(double r, double &d, double &c, double &s) {
    d = r * 2;
    c = PI * d;
    s = PI * r * r;
}
int main() {
    double r;
    cin >> r;
    double d, c, s;
    get_circle_info(r, d, c, s);
    cout << d << ' ' << c << ' ' <<  s << endl;
    return 0;
}

例十一：std::promise的使用

以例七中的代码为基础加以修改：

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
#include <future> // std::promise std::future
using namespace std;

template<class ... Args> decltype(auto) sum(Args&&... args) {
    return (0 + ... + args);
}

template<class ... Args> void sum_thread(promise<long long> &val, Args&&... args) {
    val.set_value(sum(args...));
}

int main() {
    promise<long long> sum_value;
    thread get_sum(sum_thread<int, int, int>, ref(sum_value), 1, 10, 100);
    cout << sum_value.get_future().get() << endl;
    get_sum.join(); // 感谢评论区 未来想做游戏 的提醒
    return 0;
}

 

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
atomic_bool ready = 0;
// uintmax_t ==> unsigned long long
void sleep(uintmax_t ms) {
    this_thread::sleep_for(chrono::milliseconds(ms));
}
void count() {
    while (!ready) this_thread::yield();
    for (int i = 0; i <= 20'0000'0000; i++);
    cout << "Thread " << this_thread::get_id() << " finished!" << endl;
    return;
}
int main() {
    thread th[10];
    for (int i = 0; i < 10; i++)
        th[i] = thread(::count);
    sleep(5000);
    ready = true;
    cout << "Start!" << endl;
    for (int i = 0; i < 10; i++)
        th[i].join();
    return 0;
}

 转自：https://blog.csdn.net/sjc_0910/article/details/118861539