在C++11之前，涉及到多线程问题，都是和平台相关的，比如Windows和Linux下有各自的接口，这使得代码的可移植性较差。C++11中最重要的特性就是对线程进行了支持，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念

一、线程库thread

1.1 线程对象的构造

调用无参构造函数

thread提供了无参构造函数，调用无参构造函数创建出来的线程对象没有关联任何线程函数，即没有启动任何线程

thread t;

由于thread提供了移动赋值函数，因此当后续需要让该线程对象与线程函数关联时，可以以带参的方式创建一个匿名对象，然后调用移动赋值将该匿名对象关联线程的状态转移给该线程对象

#include <iostream>
#include <thread>
using namespace std;
void func(int num)
{
  for (int i = 0; i < num; ++i) {
    cout << i << endl;
  }
}
int main()
{
  thread t;
  //...
  t = thread(func, 100);
  t.join();
  return 0;
}

调用带参构造函数

template <class Fn, class... Args>
explicit thread (Fn&& fn, Args&&... args);

fn：可调用对象，比如函数指针、仿函数、lambda表达式、被包装器包装后的可调用对象等
args...：调用可调用对象fn时所需要的若干参数。

#include <iostream>
#include <thread>
using namespace std;
void func(int num)
{
  for (int i = 0; i < num; i++) {
    cout << i << endl;
  }
}
int main()
{
  thread t(func, 10);
  t.join();
  return 0;
}

调用移动构造函数

thread提供了移动构造函数，能够用一个右值线程对象来构造一个线程对象

#include <iostream>
#include <thread>
using namespace std;
void func(int num)
{
  for (int i = 0; i < num; ++i) {
    cout << i << endl;
  }
}
int main()
{
  thread t = thread(func, 10);
  t.join();
  return 0;
}

注意：

线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态

若创建线程对象时没有提供线程函数，那么该线程对象实际没有对应任何线程。

若创建线程对象时提供了线程函数，那么就会启动一个线程来执行这个线程函数，该线程与主线程一起运行

thread类是防拷贝的，不允许拷贝构造和拷贝赋值，但是可以移动构造和移动赋值，可以将一个线程对象关联线程的状态转移给其他线程对象，并且转移期间不影响线程的执行

1.2 thread类的成员函数

thread类中常用的成员函数如下：

joinable()函数还可以用于判定线程是否是有效的，若是以下任意情况，则线程无效：

采用无参构造函数构造的线程对象（该线程对象没有关联任何线程）

线程对象的状态已经转移给其他线程对象（已经将线程交给其他线程对象管理）

线程已经调用join或detach结束（线程已经结束）

启动一个线程后，当这个线程退出时，需要对该线程所使用的资源进行回收，否则可能会导致内存泄露等问题。thread库提供了两种回收线程资源的方式：

join方式

主线程创建新线程后，可以调用join()函数等待新线程终止，当新线程终止时join()函数就会自动清理线程相关的资源。join()函数清理线程的相关资源后，thread对象与已销毁的线程就没有关系了，因此一个线程对象一般只会使用一次join()，否则程序会崩溃

#include <iostream>
#include <thread>
using namespace std;
void func(int n)
{
  for (int i = 0; i < n; i++) {
    cout << i << endl;
  }
}
int main()
{
  thread t(func, 10);
  t.join();
  t.join(); //程序崩溃
  return 0;
}

但如果一个线程对象join后，又调用移动赋值函数，将一个右值线程对象的关联线程的状态转移过来了，那么这个线程对象又可调用一次join

#include <iostream>
#include <thread>
using namespace std;
void func(int n)
{
  for (int i = 0; i < n; i++) {
    cout << i << endl;
  }
}
int main()
{
  thread t(func, 10);
  t.join();
  t = thread(func, 10);
  t.join();
  return 0;
}

但采用join的方式结束线程，在某些场景下也可能会出现问题。如在该线程被join前，若中途因为某些原因导致程序不再执行后续代码，这时这个线程将不会被join

#include <iostream>
#include <thread>
#include <windows.h>
using namespace std;
void func(int num)
{
  for (int i = 0; i < num; i++) {
    cout << i << endl;
  }
}
bool DoSomething(){ return false; }
int main()
{
  thread t(func, 10);
  Sleep(3);
  if (!DoSomething()) return -1;
  t.join(); //不会被执行
  return 0;
}

因此采用join方式结束线程时，join()函数的调用位置非常关键，为了避免上述问题，可以采用RAII的方式对线程对象进行封装，即利用对象的生命周期来控制线程资源的释放

#include <iostream>
#include <thread>
#include <windows.h>
using namespace std;
class Thread
{
public:
  Thread(thread& t):_thread(t) {}
  ~Thread() {
    if (_thread.joinable()) _thread.join();
  }
private:
  //防拷贝
  Thread(const Thread&) = delete;
  Thread& operator=(const Thread&) = delete;
private:
  thread& _thread;
};
void func(int num)
{
  for (int i = 0; i < num; i++) {
    cout << i << endl;
  }
}
bool DoSomething(){ return false; }
int main()
{
  thread t(func, 10);
  Thread T(t);
  Sleep(3);
  if (!DoSomething()) return 1;
  return 0;
}

每当创建一个线程对象后，就用Thread类对其进行封装产生一个Thread对象。

当Thread对象生命周期结束时就会调用析构函数，在析构中会通过joinable()判断这个线程是否需要被join，若需要那么就会调用join对其该线程进行等待

detach方式

主线程创建新线程后，也可以调用detach函数将新线程与主线程进行分离，分离后新线程会在后台运行，其所有权和控制权将会交给C++运行库，此时C++运行库会保证当线程退出时，其相关资源能够被正确回收

使用detach的方式回收线程的资源，一般在线程对象创建好之后就立即调用detach函数。

否则线程对象可能会因为某些原因，在后续调用detach函数分离线程之前被销毁掉，这时就会导致程序崩溃。

因为当线程对象被销毁时会调用thread的析构函数，而在thread的析构函数中会通过joinable判断这个线程是否需要被join，如果需要那么就会调用terminate终止当前程序（程序崩溃）

1.3 this_thread类

函数名	功能
get_id	获取当前线程ID
yeild	当前线程出让时间片，CPU调度其他时间片

sleep_until	使调用线程休眠到一个固定时间(绝对时间)
sleep_for	使调用线程休眠一个时间段(相对时间)

当想获取线程ID时，可以通过线程对象的get_id()接口，但想在与线程关联的线程函数中获取线程ID，这个办法就行不通了，可以调用this_thread类中的接口get_id()

#include <iostream>
#include <thread>
using namespace std;
void func()
{
  cout << this_thread::get_id() << endl;
}
int main()
{
  thread t(func);
  t.join();
  return 0;
}

1.4 线程函数的参数问题

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，就算线程函数的参数为引用类型，在线程函数中修改后也不会影响到外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参

若要通过线程函数的形参改变外部的实参，可以参考以下三种方法：

方法一：借助std::ref()

当线程函数的参数类型为引用类型时，若要想线程函数形参引用的是外部传入的实参，而不是线程栈空间中的拷贝，那么在传入实参时需要借助ref()函数保持对实参的引用

#include <iostream>
#include <thread>
using namespace std;
void add(int& num) {
  num++;
}
int main()
{
  int num = 0;
  thread t(add, ref(num));
  t.join();
  cout << num << endl;
  return 0;
}

方法二：指针地址

将线程函数的参数类型改为指针类型，将实参的地址传入线程函数，此时在线程函数中可以通过修改该地址处的变量，进而影响到外部实参

#include <iostream>
#include <thread>
using namespace std;
void add(int* num) {
  ++(*num);
}
int main()
{
  int num = 0;
  thread t(add, &num);
  t.join();
  cout << num << endl;
  return 0;
}

方法三：lambda表达式

将lambda表达式作为线程函数，利用lambda函数的捕捉列表，以引用的方式对外部实参进行捕捉，此时在lambda表达式中对形参的修改也能影响到外部实参

#include <iostream>
#include <thread>
using namespace std;
int main()
{
  int num = 0;
  thread t([&num](){ ++num; });
  t.join();
  cout << num << endl;
  return 0;
}

C++多线程（一）

一、线程库thread

1.1 线程对象的构造

1.2 thread类的成员函数

1.3 this_thread类

1.4 线程函数的参数问题

热门文章

最新文章

相关课程

相关电子书