C++11 线程类（Thread）学习笔记

文档声明：
以下资料均属于本人在学习过程中产出的学习笔记，如果错误或者遗漏之处，请多多指正。并且该文档在后期会随着学习的深入不断补充完善。

---

资料仅供学习交流使用。
作者：Aliven888

1、简述

Thread：表示执行线程的类。

执行线程是指令序列，可以在多线程环境中与其他此类序列同时执行，同时共享相同的地址空间。

初始化的线程对象表示活动的执行线程；这样的线程对象是可连接的，并且具有唯一的线程ID。

默认构造（未初始化）的线程对象不可连接，并且其线程ID对于所有不可连接的线程都是通用的。

如果从中移出可连接线程，或者如果在它们上调用了join或detach，则该线程将不可连接。

2、接口描述

Member types

名称	描述
id	线程 id (public member type)
native_handle_type	本机句柄类型 (public member type)

Member functions

名称	描述
(constructor)	构造函数 (public member function)
(destructor)	析构函数 (public member function)
operator=	Move-assign thread (public member function)
get_id	获取线程 id (public member function)
joinable	检查是否可加入 (public member function)
join	加入线程 (public member function)
detach	分离线程 (public member function)
swap	交换两个线程 (public member function)
native_handle	获取本机句柄类型 (public member function)
hardware_concurrency [static]	检测硬件并发 (public static member function)

3、接口介绍

3.1、成员类型（Member types）

3.1.1、Thread::id

默认构造的thread :: id对象的值标识不可连接的线程，因此，其值等于任何此类线程的成员thread :: get_id返回的值。

对于可连接线程，thread :: get_id返回此类型的唯一值，该值与其他任何可连接或不可连接线程返回的值不相等。

请注意，某些库实现可能会重新利用无法再加入的终止线程的thread :: id值。

3.1.2、Thread::native_handle_type

如果库实现支持，则该成员类型仅出现在类线程中。

它是thread :: native_handle返回的类型，具有有关线程的特定于实现的信息。

3.2、成员函数（Member functions）

3.2.1、构造函数（Thread::Thread(…)）

默认构造函数：

	Thread::thread() noexcept;

功能：构造一个不代表任何执行线程的线程对象。

初始化构造函数：

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

功能：构造一个代表新的可连接执行线程的线程对象。新的执行线程调用fn传递args作为参数（使用其左值或右值引用的衰减副本）。该构造函数的完成与该fn副本的调用开始同步。

复制构造函数

Thread::thread (const thread&) = delete;

功能：删除构造函数形式（线程对象无法复制）。

移动构造函数

	Thread::thread (thread&& x) noexcept;

功能：构造一个线程对象，该对象获取x表示的执行线程（如果有）。此操作不会以任何方式影响已移动线程的执行，它只是传输其处理程序。
x对象不再代表任何执行线程。

构造函数参量介绍：
fn： 指向函数的指针，指向成员的指针或任何类型的可移动构造的函数对象（即，其类定义了operator（）的对象，包括闭包和函数对象）。返回值（如果有）将被忽略。

args …： 传递给fn调用的参数（如果有）。它们的类型应是可移动构造的。如果fn是成员指针，则第一个参数应是为其定义了该成员的对象（或其引用或指向它的指针）。

X： 线程对象，其状态已移至构造对象。

注意： fn和args …是模板参数；如果隐式推导，则它们是将参数绑定到的正确的左值或右值引用类型。但是请注意，在新线程中对fn的调用中，始终使用fn和args …的衰减副本。

	std::atomic<int> global_counter (0);
	
	void increase_global (int n) { for (int i=0; i<n; ++i) ++global_counter; }
	
	void increase_reference (std::atomic<int>& variable, int n) { for (int i=0; i<n; ++i) ++variable; }
	
	struct C : std::atomic<int> {
	  C() : std::atomic<int>(0) {}
	  void increase_member (int n) { for (int i=0; i<n; ++i) fetch_add(1); }
	};
	
	int main ()
	{
	  std::vector<std::thread> threads;
	
	  std::cout << "increase global counter with 10 threads...\n";
	  for (int i=1; i<=10; ++i)
	    threads.push_back(std::thread(increase_global,1000));
	
	  std::cout << "increase counter (foo) with 10 threads using reference...\n";
	  std::atomic<int> foo(0);
	  for (int i=1; i<=10; ++i)
	    threads.push_back(std::thread(increase_reference,std::ref(foo),1000));
	
	  std::cout << "increase counter (bar) with 10 threads using member...\n";
	  
	  for (int i=1; i<=10; ++i)
	    threads.push_back(std::thread(&C::increase_member,std::ref(bar),1000));
	
	  std::cout << "synchronizing all threads...\n";
	  for (auto& th : threads) th.join();
	
	  std::cout << "global_counter: " << global_counter << '\n';
	  std::cout << "foo: " << foo << '\n';
	  std::cout << "bar: " << bar << '\n';
	
	  return 0;
	}

输出：
increase global counter using 10 threads...
increase counter (foo) with 10 threads using reference...
increase counter (bar) with 10 threads using member...
synchronizing all threads...
global_counter: 10000
foo: 10000
bar: 10000

3.2.2、析构函数（Thread::~Thread()）

	Thread::~Thread()

线程析构函数，常用于销毁线程对象。如果线程在销毁时是可连接的，则调用terminate（）。

3.2.2、运算符重载（Thread::operator=）

常用接口有：

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

	void pause_thread(int n) 
	{
	  std::this_thread::sleep_for (std::chrono::seconds(n));
	  std::cout << "pause of " << n << " seconds ended\n";
	}
	
	int main() 
	{
	  std::thread threads[5];                         // default-constructed threads
	
	  std::cout << "Spawning 5 threads...\n";
	  for (int i=0; i<5; ++i)
	    threads[i] = std::thread(pause_thread,i+1);   // move-assign threads
	
	  std::cout << "Done spawning threads. Now waiting for them to join:\n";
	  for (int i=0; i<5; ++i)
	    threads[i].join();
	
	  std::cout << "All threads joined!\n";
	
	  return 0;
	}

输出：
Spawning 5 threads...
Done spawning threads. Now waiting for them to join:
pause of 1 seconds ended
pause of 2 seconds ended
pause of 3 seconds ended
pause of 4 seconds ended
pause of 5 seconds ended
All threads joined!

3.2.4、获取线程ID（Thread::get_id()）

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

功能： 获取线程ID

返回值： 如果线程对象是可连接的，则该函数返回一个唯一标识线程的值。如果线程对象不可连接，则该函数返回成员类型为thread :: id的默认构造的对象。

	std::thread::id main_thread_id = std::this_thread::get_id();
	
	void is_main_thread() {
	  if ( main_thread_id == std::this_thread::get_id() )
	    std::cout << "This is the main thread.\n";
	  else
	    std::cout << "This is not the main thread.\n";
	}
	
	int main() 
	{
	  is_main_thread();
	  std::thread th (is_main_thread);
	  th.join();
	}

输出：
This is the main thread.
This is not the main thread.

3.2.5、检查是否可加入（Thread::joinable()）

	bool joinable() const noexcept;

功能： 检查是否可加入

返回值： 返回线程对象是否可连接。如果线程对象表示执行线程，则该对象是可连接的。如果线程可连接，则为true。否则为false。

注意事项：
在以下任何情况下，线程对象均不可连接：
如果它是默认构造的。
如果已将其移出（构造另一个线程对象或对其进行分配）。
是否已调用其成员join或detach。

	void mythread() 
	{
	  // do stuff...
	}
	 
	int main() 
	{
	  std::thread foo;
	  std::thread bar(mythread);
	
	  std::cout << "Joinable after construction:\n" << std::boolalpha;
	  std::cout << "foo: " << foo.joinable() << '\n';
	  std::cout << "bar: " << bar.joinable() << '\n';
	
	  if (foo.joinable()) foo.join();
	  if (bar.joinable()) bar.join();
	
	  std::cout << "Joinable after joining:\n" << std::boolalpha;
	  std::cout << "foo: " << foo.joinable() << '\n';
	  std::cout << "bar: " << bar.joinable() << '\n';
	
	  return 0;
	}

输出：
Joinable after construction:
foo: false
bar: true
Joinable after joining:
foo: false
bar: false

3.2.6、连接线程（Thread::join()）

	void join();

功能：
这使该函数返回的时刻与线程中所有操作的完成同步。
阻塞调用该函数的线程的执行，直到构造函数上调用的函数返回为止（函数阻塞，直到线程执行完毕）。
线程执行完成后，该函数返回。
调用此函数后，线程对象变得不可连接，并且被安全地销毁。

返回值： void

	void pause_thread(int n) 
	{
	  std::this_thread::sleep_for (std::chrono::seconds(n));
	  std::cout << "pause of " << n << " seconds ended\n";
	}
	 
	int main() 
	{
	  std::cout << "Spawning 3 threads...\n";
	  std::thread t1 (pause_thread,1);
	  std::thread t2 (pause_thread,2);
	  std::thread t3 (pause_thread,3);
	  std::cout << "Done spawning threads. Now waiting for them to join:\n";
	  t1.join();
	  t2.join();
	  t3.join();
	  std::cout << "All threads joined!\n";
	
	  return 0;
	}

输出：
Spawning 3 threads...
Done spawning threads. Now waiting for them to join:
pause of 1 seconds ended
pause of 2 seconds ended
pause of 3 seconds ended
All threads joined!

3.2.7、分离线程（Thread::detach()）

	void detach();

功能：
从调用线程中分离对象所代表的线程，从而使它们彼此独立执行。

两个线程继续运行，而不会阻塞或以任何方式进行同步。 请注意，当任何一个执行结束时，其资源将被释放。

调用此函数后，线程对象变得不可连接，并且可以安全地被销毁。

返回值： void

	void pause_thread(int n) 
	{
	  std::this_thread::sleep_for (std::chrono::seconds(n));
	  std::cout << "pause of " << n << " seconds ended\n";
	}
	 
	int main() 
	{
	  std::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();
	  std::cout << "Done spawning threads.\n";
	
	  std::cout << "(the main thread will now pause for 5 seconds)\n";
	  // give the detached threads time to finish (but not guaranteed!):
	  pause_thread(5);
	  return 0;
	}

输出：
Spawning and detaching 3 threads...
Done spawning 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

3.2.8、（Thread::swap()）

	void swap (thread& x) noexcept;

功能： 用x线程对象交换当前线程对象的状态。x线程对象和当前线程对象均被修改。
返回值： void

3.2.9、（Thread::native_handle()）

	native_handle_type native_handle（）;

功能：
获取本地句柄；如果库实现支持，则该成员函数仅存在于类线程中。如果存在，它将返回一个值，该值用于访问与线程关联的特定于实现的信息。

3.2.10、（Thread::hardware_concurrency ()）

	static  unsigned  hardware_concurrency() noexcept;

功能： 检测硬件并发；返回硬件线程上下文的数量。

此值的解释是特定于系统和实现的，可能不准确，而只是一个近似值。

请注意，这不需要与系统中可用的处理器或内核的实际数量相匹配：系统可以为每个处理单元支持多个线程，或限制对程序的资源访问。

如果此值不可计算或定义不正确，则该函数返回0。