C++ 11 多线程编程之线程类

Posted 2021-11-23 Overboom

C++11 之前，C++ 语言没有对并发编程提供语言级别的支持，这使得我们在编写可移植的并发程序时，存在诸多的不便。现在 C++11 中增加了线程以及线程相关的类，很方便地支持了并发编程，使得编写的多线程程序的可移植性得到了很大的提高。

C++11 中提供的线程类叫做 std::thread，基于这个类创建一个新的线程非常的简单，只需要提供线程函数或者函数对象即可，并且可以同时指定线程函数的参数。我们首先来了解一下这个类提供的一些常用 API：

1. 线程类构造函数

// ①
thread() noexcept;

// ②
thread( thread&& other ) noexcept;

// ③
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );

// ④
thread( const thread& ) = delete;

构造函数①：默认构造函，构造一个线程对象，在这个线程中不执行任何处理动作

构造函数②：移动构造函数，将 other 的线程所有权转移给新的 thread 对象。之后 other 不再表示执行线程。

构造函数③：创建线程对象，并在该线程中执行函数 f 中的业务逻辑，args 是要传递给函数 f 的参数

    任务函数 f 的可选类型有很多，具体如下：
        普通函数，类成员函数，匿名函数，仿函数（这些都是可调用对象类型）
        可以是可调用对象包装器类型，也可以是使用绑定器绑定之后得到的类型（仿函数）

构造函数④：使用 =delete 显示删除拷贝构造，不允许线程对象之间的拷贝

2. 线程类公共成员函数

2.1 get_id()

应用程序启动之后默认只有一个线程，这个线程一般称之为主线程或父线程，通过线程类创建出的线程一般称之为子线程，每个被创建出的线程实例都对应一个线程 ID，这个 ID 是唯一的，可以通过这个 ID 来区分和识别各个已经存在的线程实例，这个获取线程 ID 的函数叫做 get_id()，函数原型如下：

std::thread::id get_id() const noexcept;

示例程序如下：

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

void func(int num, string str)
{
    for (int i = 0; i < 10; ++i)
    {
        cout << "子线程: i = " << i << "num: " 
             << num << ", str: " << str << endl;
    }
}

void func1()
{
    for (int i = 0; i < 10; ++i)
    {
        cout << "子线程: i = " << i << endl;
    }
}

int main()
{
    cout << "主线程的线程ID: " << this_thread::get_id() << endl;
    thread t(func, 520, "i love you");
    thread t1(func1);
    cout << "线程t 的线程ID: " << t.get_id() << endl;
    cout << "线程t1的线程ID: " << t1.get_id() << endl;
}

在上面的示例程序中有一个 bug，在主线程中依次创建出两个子线程，打印两个子线程的线程 ID，最后主线程执行完毕就退出了（主线程就是执行 main () 函数的那个线程）。默认情况下，主线程销毁时会将与其关联的两个子线程也一并销毁，但是这时有可能子线程中的任务还没有执行完毕，最后也就得不到我们想要的结果了。
当启动了一个线程（创建了一个 thread 对象）之后，在这个线程结束的时候（std::terminate ()），我们如何去回收线程所使用的资源呢？thread 库给我们两种选择：

加入式：join()
分离式：detach()

我们必须要在线程对象销毁之前在二者之间作出选择，否则程序运行期间就会有 bug 产生。

2.2 join()

如果要阻塞主线程的执行，只需要在主线程中通过子线程对象调用这个方法即可，当调用这个方法的子线程对象中的任务函数执行完毕之后，主线程的阻塞也就随之解除了。该函数的函数原型如下：

void join();

上面的代码修改如下：

int main()
{
    cout << "主线程的线程ID: " << this_thread::get_id() << endl;
    thread t(func, 520, "i love you");
    thread t1(func1);
    cout << "线程t 的线程ID: " << t.get_id() << endl;
    cout << "线程t1的线程ID: " << t1.get_id() << endl;
    t.join();
    t1.join();
}

编译输出如下：

当主线程运行到第八行 t.join();，根据子线程对象 t 的任务函数 func() 的执行情况，主线程会做如下处理：

• 如果任务函数 func() 还没执行完毕，主线程阻塞，直到任务执行完毕，主线程解除阻塞，继续向下运行
• 如果任务函数 func() 已经执行完毕，主线程不会阻塞，继续向下运行

同样，第 9 行的代码亦如此。

2.3 detach()

detach() 函数的作用是进行线程分离，分离主线程和创建出的子线程。在线程分离之后，主线程退出也会一并销毁创建出的所有子线程，在主线程退出之前，它可以脱离主线程继续独立的运行，任务执行完毕之后，这个子线程会自动释放自己占用的系统资源。（其实就是孩子翅膀硬了，和家里断绝关系，自己外出闯荡了，如果家里被诛九族还是会受牵连）。该函数函数原型如下：

void detach（）;

线程分离函数没有参数也没有返回值，只需要在线程成功之后，通过线程对象调用该函数即可，继续将上面的测试程序修改一下：

int main()
{
    cout << "主线程的线程ID: " << this_thread::get_id() << endl;
    thread t(func, 520, "i love you");
    thread t1(func1);
    cout << "线程t 的线程ID: " << t.get_id() << endl;
    cout << "线程t1的线程ID: " << t1.get_id() << endl;
    t.detach();
    t1.detach();
    // 让主线程休眠, 等待子线程执行完毕
    this_thread::sleep_for(chrono::seconds(5));
}

编译输出：
Note:
注意事项：线程分离函数 detach () 不会阻塞线程，子线程和主线程分离之后，在主线程中就不能再对这个子线程做任何控制了，比如：通过 join () 阻塞主线程等待子线程中的任务执行完毕，或者调用 get_id () 获取子线程的线程 ID。有利就有弊，鱼和熊掌不可兼得，建议使用 join ()。

2.4 joinable()

用来判断是否能够调用join()或者detach(),可以返回true,不可以返回false.
实例代码如下：

// C++ program to demonstrate the use of 
// std::thread::joinable() 
  
#include <chrono> 
#include <iostream> 
#include <thread> 
  
using namespace std; 
  
// function to put thread to sleep 
void threadFunc() 
{ 
    std::this_thread::sleep_for( 
        std::chrono::seconds(1)); 
} 
  
int main() 
{ 
    std::thread t1; // declaring the thread 
  
    cout << "t1 joinable when default created? \\n"; 
    // checking if it is joinable 
    if (t1.joinable()) 
        cout << "YES\\n"; 
    else
        cout << "NO\\n"; 
  
    // calling the function threadFunc 
    // to put thread to sleep 
    t1 = std::thread(threadFunc); 
  
    cout << "t1 joinable when put to sleep? \\n"; 
  
    // checking if t1 is joinable 
    if (t1.joinable()) 
        cout << "YES\\n"; 
    else
        cout << "NO\\n"; 
  
    // joining t1 
    t1.join(); 
  
    // checking joinablity of t1 after calling join() 
    cout << "t1 joinable after join is called? \\n"; 
    if (t1.joinable()) 
        cout << "YES\\n"; 
    else
        cout << "NO\\n"; 
  
    return 0; 
}

编译输出：
在以下情况下，线程不可联接：

• 它是默认构造的
• 如果其成员join或detach中的任何一个已被调用
• 它已移至其他地方

2.5 operator=

线程中的资源是不能被复制的，因此通过 = 操作符进行赋值操作最终并不会得到两个完全相同的对象。

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

通过以上 = 操作符的重载声明可以得知：

• 如果 other 是一个右值，会进行资源所有权的转移
• 如果 other 不是右值，禁止拷贝，该函数被显示删除（=delete），不可用

3. 静态函数

thread 线程类还提供了一个静态方法，用于获取当前计算机的 CPU 核心数，根据这个结果在程序中创建出数量相等的线程，每个线程独自占有一个CPU核心，这些线程就不用分时复用CPU时间片，此时程序的并发效率是最高的。

static unsigned hardware_concurrency() noexcept;

示例代码如下：

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

int main()
{
    int num = thread::hardware_concurrency();
    cout << "CPU number: " << num << endl;
}