《深入应用C++11》笔记-线程std::thread

上一篇：《深入应用C++11》笔记-std::function和bind

原来开发多线程在windows和linux各有各的接口，C++ 11有了标准的线程库：std::thread。

构造函数和赋值操作

std::thread定义了四个构造函数：

• 默认构造函数，创建一个空的 std::thread 执行对象。
• 初始化构造函数，创建一个 std::thread 对象，该std::thread 对象可被 joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。
• 拷贝构造函数(被禁用)，意味着 std::thread 对象不可拷贝构造，因为线程无法拷贝。
• 移动构造函数，详见(https://blog.csdn.net/wizardtoh/article/details/80718605中的移动构造函数)，调用成功之后 x 不代表任何 std::thread 执行对象。

void f1(int n)
{
    for (int i = 0; i < 5; ++i) {
        std::cout << "Thread " << n << " executing" << i << "\n";

        // 作用相当于sleep，后续的文章会具体介绍
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

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

int main()
{
    int n = 0;
    std::thread t1;                    // 没有执行线程
    std::thread t2(f1, n + 1);         // 执行线程，运行f1
    std::thread t3(f2, std::ref(n));   // 执行线程，运行f2
    std::thread t4(std::move(t3));     // f2在t4中运行，t3不再是线程

    // 下面会介绍join的内容
    t2.join();
    t4.join();

    std::cout << "Final value of n is " << n << '\n';
    return 0;
}

同时定义了两个赋值操作：

• Move 赋值操作，如果当前对象不可 joinable，需要传递一个右值引用(rhs)给 move 赋值操作；如果当前对象可被
  joinable，则会调用 terminate() 报错。
• 拷贝赋值操作，被禁用，意味着std::thread 对象不可拷贝赋值，因为线程无法拷贝。

int main(int argc, const char *argv[])
{
    std::thread threads[5];

    std::cout << "Spawning 5 threads...\n";
    for (int i = 0; i < 5; i++) {
        threads[i] = std::thread(thread_task, i + 1);    // 移动赋值，std::thread(thread_task, i + 1)作为右值
    }
    std::cout << "Done spawning threads! Now wait for them to join\n";
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "All threads joined.\n";

    return 0;
}

成员函数

std::thread还提供了一些成员函数来辅助线程。

get_id：获取线程 ID，返回一个类型为 std::thread::id 的对象。

void foo(int n)
{
    std::this_thread::sleep_for(std::chrono::seconds(n));
    // 在线程中通过std::this_thread::get_id()获取线程ID
    std::cout << "id:" << std::this_thread::get_id() << "\n";
}

int main()
{
    std::thread t1(foo, 1);
    std::thread::id t1_id = t1.get_id();   // 通过对象获取线程ID

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

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

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

    return 0;
}

joinable：检查线程是否可被 join。检查当前的线程对象是否表示了一个活动的执行线程，由默认构造函数创建的线程是不能被 join 的。另外，如果某个线程已经执行完任务，但是没有被 join 的话，该线程依然会被认为是一个活动的执行线程，因此也是可以被 join 的。

int main()
{
    std::thread t1;

    t1.join();   // thread对象没有执行线程，join会造成程序错误
    return 0;
}

void foo(int n)
{
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "id:" << std::this_thread::get_id() << "\n";
}

int main()
{
    std::thread t1(foo, 1);   // thread执行了线程，但是没有join，在程序结束时也会造成异常

    return 0;
}

使用joinable可以解决以上问题：

void foo(int n)
{
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "id:" << std::this_thread::get_id() << "\n";
}

int main()
{
    std::thread t1(foo, 1);

    if (t1.joinable())  // 执行线程的情况下才join
    {
        t1.join();
    }

    return 0;
}

join：Join 线程，调用该函数会阻塞当前线程，直到由 *this 所标示的线程执行完毕 join 才返回。

detach: Detach 线程。 将当前线程对象所代表的执行实例与该线程对象分离，不会阻塞当前线程，使得线程的执行可以单独进行。一旦线程执行完毕，它所分配的资源将会被释放。调用 detach 函数之后：

• thread对象本身不再代表任何的线程执行实例，但是线程仍然在运行。
• joinable() == false，thread对象不再需要join。
• get_id() == std::thread::id()，也就是0x0

void foo(int n)
{
    std::cout << "run" << "\n";
}

int main()
{
    std::thread t1(foo, 1);

    if (t1.joinable())
    {
        std::cout << "joinable" << std::endl;
    }

    std::cout << std::this_thread::get_id() << std::endl;
    std::cout << t1.get_id() << std::endl;

    t1.detach();

    // detach之后，joinable返回false，get_id返回0x0
    if (!t1.joinable())
    {
        std::cout << "can not joinable" << std::endl;
    }

    std::cout << t1.get_id() << std::endl;

    return 0;
}

在std::thread的析构函数中，如果线程没有被Joined（用t.join()，也没有被detached（用t.detach()，会引起程序异常。因此，你应该在执行流程到析构函数前总是要么join，要么detach一个线程。当一个程序终止时（比如main返回），剩下的在后台的detached线程执行不会再等待；相反它们的执行会被挂起并且它们的本地线程对象会被销毁。

swap: Swap 线程，交换两个线程对象所代表的底层句柄。通过下面的代码可以看到，thread对象的句柄会被交换。

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

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

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

    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

    std::swap(t1, t2);

    std::cout << "after std::swap(t1, t2):" << std::endl;
    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

    t1.swap(t2);

    std::cout << "after t1.swap(t2):" << std::endl;
    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

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

    return 0;
}

native_handle: 返回本地句柄（由于 std::thread 的实现和操作系统相关，因此该函数返回与 std::thread 具体实现相关的线程句柄），通过这个句柄就能用对应操作系统的线程相关接口了。

std::this_thread 命名空间中相关辅助函数

在上面的介绍中已经有用到了std::this_thread命名空间的部分函数，std::this_thread是作用于当前运行的线程。
get_id: 获取当前的线程 ID。
yield: 当前线程放弃执行，操作系统调度另一线程继续执行，有点类似于sleep，不过yield会将自己抢到的时间片让给其他线程，而sleep只是等待。该方法的具体行为取决于实现，尤其是正在使用的操作系统调度器的机制以及系统的状态。比如，一个先进先出的实时调度器（Linux中的SCHED_FIFO）将会使当前线程暂停，并将其置于同优先级线程队列的末尾（如果同优先级线程队列里没有其他线程，yield就没有效果了。）

sleep_until: 线程休眠至某个指定的时刻(time point)，该线程才被重新唤醒。
sleep_for: 线程休眠某个指定的时间片(time span)，该线程才被重新唤醒，不过由于线程调度等原因，实际休眠时间可能比 sleep_duration 所表示的时间片更长。

#include <iostream>
#include <thread>
#include <chrono>
#include <ctime>

int main()
{
    std::time_t tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());

    struct std::tm * ptm = std::localtime(&tt);
    std::cout << "Current time: " << tt << '\n';

    std::this_thread::sleep_for(std::chrono::milliseconds(100));

    tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
    ptm = std::localtime(&tt);
    std::cout << "Current time: " << tt << '\n';  // 等待了100ms

    std::cout << "Waiting for the next minute to begin...\n";
    ptm->tm_min += 1;
    ptm->tm_sec=0;
    std::this_thread::sleep_until (std::chrono::system_clock::from_time_t (mktime(ptm)));

    std::cout << ptm << " reached!\n";

    tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
    std::cout << "Current time: " << tt << '\n';  // 等到了下一分钟

    return 0;
}

下一篇：《深入应用C++11》笔记-互斥量std::mutex、锁std::lock_guard