C++11 thread 1.线程的创建和参数的传递

std::thread

头文件：<thread>

C++11

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

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

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

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

类的成员变量：

id	Thread id (public member type )线程id(公有成员变量)
native_handle_type	Native handle type (public member type )本地句柄类型(公有成员变量)

    类的成员函数

(constructor)	Construct thread (public member function )构造函数(公有成员变量)
(destructor)	Thread destructor (public member function )线程析构函数(公有成员变量)
operator=	Move-assign thread (public member function )移动分配线程（公共成员函数）
get_id	Get thread id (public member function )获取线程id(公有成员函数)
joinable	Check if joinable (public member function )检查是否可连接（公共成员函数）
join	Join thread (public member function )连接线程（公共成员函数）
detach	Detach thread (public member function )分离线程
swap	Swap threads (public member function )交换线程（公共成员函数）
native_handle	Get native handle (public member function )获取本机句柄（公共成员函数）
hardware_concurrency [static]	Detect hardware concurrency (public static member function )检测硬件并发（公共静态成员函数）

Non-member overloads非成员重载

        swap (thread) Swap threads (function )

创建线程例子：

#include "stdafx.h"
#include <thread>
#include <iostream>
using namespace std;

// 创建线程
void first()
{
	cout << "This is first thread!" << endl;
}

int main()
{
	thread t1(first);
	cout << "This is main thread!" << endl;
	system("pause");
    return 0;
}

 

运行结果：

 

运行结果分析：first线程定义了之后，立刻就会运行，同时主线程也同时运行，输出的先后顺序又随机性。

使用join函数，主线程等待子线程执行完毕，才会继续运行。

#include <thread>
#include <iostream>
#include <windows.h>
using namespace std;

bool bStart = false;
// 创建线程
void first()
{
	cout << "This is first thread!" << endl;
	std::this_thread::sleep_for(std::chrono::milliseconds(5000));// 睡眠5秒
}

int main()
{
	thread t1(first);
	t1.join();// join之后，主线程就会等在这里，等待他执行完毕再执行
	cout << "This is main thread!" << endl;
	system("pause");
    return 0;
}

运行结果：

 

运行结果分析：join之后，主线程会等待子线程执行完毕。

join函数分析

void join（）;
连接线程
线程执行完成后，该函数返回。

这将使该函数返回的时刻与线程中所有操作的完成同步：阻塞调用该函数的线程的执行，直到构造函数上调用的函数返回（如果尚未返回）。

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

如何让子线程定义之后，不要立即执行呢？考虑添加一个变量控制

#include <thread>
#include <iostream>
#include <windows.h>
using namespace std;

bool bStart = false;
// 创建线程
void first()
{
	while (!bStart)
		std::this_thread::sleep_for(std::chrono::milliseconds(10));
	cout << "This is first thread!" << endl;
	std::this_thread::sleep_for(std::chrono::milliseconds(5000));// 睡眠5秒
}

int main()
{
	thread t1(first);
	//t1.join();// join之后，主线程就会等在这里，等待他执行完毕再执行
	bStart = true;
	cout << "This is main thread!" << endl;
	system("pause");
    return 0;
}

运行结果分析：

设置了一个bStart全局变量，子线程开始一直在循环等待向下执行，直到bStart变成true。

也可以使用内核变量进行同步。

线程传递参数

 

#include <thread>
#include <iostream>
#include <windows.h>
using namespace std;

// 创建线程
void second(int num)
{
	std::this_thread::sleep_for(std::chrono::milliseconds(1));
	cout << "This is second thread! this thread has a num:" << num << endl;
}

int main()
{
	thread t2(second,3);
	t2.join();
	cout << "This is main thread!" << endl;
	system("pause");
    return 0;
}

运行结果：

detach()函数分析

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

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

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

#include "stdafx.h"
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

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;
}

运行结果：

detach之后子线程和主线程独立运行