c++多线程基础1(thread)

std::thread 在 <thread> 头文件中声明，因此使用 std::thread 时需要包含 <thread> 头文件。

thread 构造函数：

default (1)	thread() noexcept;
initialization (2)	template <class Fn, class... Args> explicit thread (Fn&& fn, Args&&... args);
copy [deleted] (3)	thread (const thread&) = delete;
move (4)	thread (thread&& x) noexcept;

 

(1). 默认构造函数，创建一个空的 thread 执行对象。

(2). 初始化构造函数，创建一个 thread对象，该 thread 对象可被 joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。

(3). 拷贝构造函数(被禁用)，意味着 thread 不可被拷贝构造。

(4). move 构造函数，move 构造函数，调用成功之后 x 不代表任何 thread 执行对象。

注意：可被 joinable 的 thread 对象必须在他们销毁之前被主线程 join 或者将其设置为 detached.

代码：

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

void fun1(int n) {
    for(int i = 0; i < 5; ++i) {
        cout << "Thread " << n << " executing\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

void fun2(int &n) {
    for(int i = 0; i < 5; ++i) {
        cout << "Thread 2 executing\n";
        ++n;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

int main() {
    int n = 0;
    std::thread t1;//t1 不是一个线程
    std::thread t2(fun1, n + 1);//值传参
    std::thread t3(fun2, std::ref(n));//引用传参
    std::thread t4(std::move(t3));//将t3的资源转移到t4,此时t3不再是一个线程

    t2.join();
    t4.join();

    cout << "Final valuw of n is " << n << '\n';

// 输出：
// Thread Thread 2 executing
// 1 executing
// Thread 2 executing
// Thread 1 executing
// Thread 2 executing
// Thread 1 executing
// Thread 2 executing
// Thread 1 executing
// Thread 2 executing
// Thread 1 executing
// Final valuw of n is 5

    return 0;
}

 

拷贝赋值和移动赋值操作：

move (1)	thread& operator= (thread&& rhs) noexcept;
copy [deleted] (2)	thread& operator= (const thread&) = delete;

 

(1). move 赋值操作，如果当前对象不可 joinable，需要传递一个右值引用(rhs)给 move 赋值操作；如果当前对象可被 joinable，则 terminate() 报错。

(2). 拷贝赋值操作被禁用，thread 对象不可被拷贝

代码：

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

void thread_task(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    cout << "hello thread "
        << std::this_thread::get_id()
        << " paused " << n << " seconds" << endl;
}

int main(void) {
    std::thread thread[5];
    cout << "Spawning 5 threads...\n";
    for(int i = 0; i < 5; ++i) {
        thread[i] = std::thread(thread_task, i + 1);//创建一个临时对象，并将临时对象资源移动到thread[i]
    }
    // thread[0] = thread[1];//错误，拷贝赋值函数是 delete 的
    cout << "Done wpawning threads! now wait fo them to join\n";
    for(auto &t : thread) {
        t.join();
    }
    cout << "all threads joind.\n";

// 输出：
// Spawning 5 threads...
// Done wpawning threads! now wait fo them to join
// hello thread 2 paused 1 seconds
// hello thread 3 paused 2 seconds
// hello thread 4 paused 3 seconds
// hello thread 5 paused 4 seconds
// hello thread 6 paused 5 seconds
// all threads joind.

    return 0;
}

 

成员函数 joinable：

用于检测线程是否 joinable

joinable ： 代表该线程是可执行线程。

not-joinable ：通常一下几种情况会导致线程成为 not-joinable

     1） 由 thread 的缺省构造函数构造而成 (thread()没有参数)。

     2） 该 thread 被 move 过（包括 move 构造和 move 赋值）

     3） 该线程调用过 join 或者 detach

代码：

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

void foo() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main(void) {
    std::thread t;
    cout << t.joinable() << endl;//0

    t = std::thread(foo);//调用移动构造函数
    cout << t.joinable() << endl;//1

    t.join();
    cout << t.joinable() << endl;//0

    return 0;
}

 

成员函数 get_id：

标识与 *this 关联的线程的 std::thread::id 类型值。若无关联的线程，则返回默认构造的 std::thread::id 

代码：

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

void foo() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main(void) {
    std::thread t0;
    std::thread::id t0_id = t0.get_id();

    std::thread t1(foo);
    std::thread::id t1_id = t1.get_id();

    std::thread t2(foo);
    std::thread::id t2_id = t2.get_id();

    cout << "t0's id: " << t0_id << "\n";
    cout << "t1's id: " << t1_id << "\n";
    cout << "t2's id: " << t2_id << "\n";

    t1.join();
    t2.join();

// 输出：
// t0's id: thread::id of a non-executing thread
// t1's id: 2
// t2's id: 3
    return 0;
}

 

成员函数 native_handle：

用于获得与操作系统相关的原生线程句柄

代码：

#include <thread>
#include <mutex>
#include <iostream>
#include <chrono>
#include <cstring>
#include <pthread.h>
using namespace std;

std::mutex iomutex;

void f(int num) {
    std::this_thread::sleep_for(std::chrono::seconds(1));

    sched_param sch;
    int policy;
    pthread_getschedparam(pthread_self(), &policy, &sch);
    std::lock_guard<std::mutex> lk(iostream);
    cout << "thread " << num << " is executing at priority "
        << sch.sched_priority << '\n';
}

int main(void) {
    std::thread t1(f, 1), t2(f, 2);
 
    sched_param sch;
    int policy; 
    pthread_getschedparam(t1.native_handle(), &policy, &sch);
    sch.sched_priority = 20;
    if (pthread_setschedparam(t1.native_handle(), SCHED_FIFO, &sch)) {
        std::cout << "Failed to setschedparam: " << std::strerror(errno) << '\n';
    }

    t1.join();
    t2.join();

    return 0;
}

 

静态成员函数 hardware_concurrency：

支持的并发线程数。若值非良定义或不可计算，则返回 ​0​ 

代码：

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

int main(void) {
    unsigned int n = std::thread::hardware_concurrency();
    cout << n << endl;//4

    return 0;
}

 

成员函数 jion 和 detach：

http://blog.csdn.net/xibeichengf/article/details/71173543

当thread::join()函数被调用后，调用它的线程会被block，直到线程的执行被完成。基本上，这是一种可以用来知道一个线程已结束的机制。当thread::join()返回时，OS的执行的线程已经完成，C++线程对象可以被销毁

当thread::detach()函数被调用后，执行的线程从线程对象中被分离，已不再被一个线程对象所表达--这是两个独立的事情。C++线程对象可以被销毁，同时OS执行的线程可以继续

jion 样例代码：

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

void show() {
    cout << "hello cplusplus\n";
}

int main(void) {
    array<thread, 3> threads = {thread(show), thread(show), thread(show)};
    for(int i = 0; i < 3; ++i) {
        cout << threads[i].joinable() << endl;//判断当前线程是否可以 join
        threads[i].join();//主线程等待当前子线程完成才退出
    }

// 输出：
// hello cplusplus
// 1hello cplusplus
// hello cplusplus

// 1
// 1

    return 0;
}

detach 样例代码：

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

void pause_thread(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    cout << "pause of " << n << " seconds ended\n";
}

int main(void) {
    cout << "Spawning and detaching 3 threads...\n";
    std::thread(pause_thread, 1).detach();//将执行的线程从线程对象中被分离
    std::thread(pause_thread, 2).detach();
    std::thread(pause_thread, 3).detach();
    cout << "(the main thread will now pause for 5 seconds)\n";
    pause_thread(5);

// 输出：
// Spawning and detaching 3 threads...
// (the main thread will now pause for 5 seconds)
// pause of 1 seconds ended
// pause of 2 seconds ended
// pause of 3 seconds ended
// pause of 5 seconds ended

    return 0;
}

注意：通常应该使用 join，除非你需要更灵活并且想要独立地提供一种同步机制来等待线程完成，在这种情况下你应该使用detach

如果父线程先于子线程结束，那么子线程将在父线程结束的同时被迫结束

thread::join() 会清理子线程相关的内存空间，此后 thread object 将不再和这个子线程相关了，即 thread object 不再 joinable 了，所以 join 对于一个子线程来说只可以被调用一次

如果一个 C++ 线程对象当销毁时仍然可以被 join，会抛出异常

 

成员函数 swap：

void swap( thread& other ) noexcept;

 

互换二个 thread 对象的底层句柄

代码：

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

void foo() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main(void) {
    std::thread t1(foo);
    std::thread t2(bar);

    cout << t1.get_id() << endl;
    cout << t2.get_id() << endl;

    std::swap(t1, t2);

    cout << "===" << endl;
    cout << t1.get_id() << endl;
    cout << t2.get_id() << endl;

    t1.swap(t2);

    cout << "---" << endl;
    cout << t1.get_id() << endl;
    cout << t2.get_id() << endl;

    t1.join();
    t2.join();

// 输出：
// 2
// 3
// ===
// 3
// 2
// ---
// 2
// 3

    return 0;
}

 

std::swap

void swap( thread &lhs, thread &rhs ) noexcept;

为 std::thread 特化 std::swap 算法。交换 lhs 与 rhs 的状态。等效地调用 lhs.swap(rhs) 

代码：

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

void foo() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main(void) {
    std::thread t1(foo);
    std::thread t2(bar);

    cout << t1.get_id() << endl;
    cout << t2.get_id() << endl;

    std::swap(t1, t2);

    cout << "===" << endl;
    cout << t1.get_id() << endl;
    cout << t2.get_id() << endl;

    t1.swap(t2);

    cout << "---" << endl;
    cout << t1.get_id() << endl;
    cout << t2.get_id() << endl;

    t1.join();
    t2.join();

// 输出：
// 2
// 3
// ===
// 3
// 2
// ---
// 2
// 3

    return 0;
}