《c++新经典》C++11并发与多线程笔记（2）

二 线程启动、结束，创建线程多法、join，detach

1、范例演示线程运行的开始

• 程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；当主线程从main（）函数返回，则整个进程执行完毕
• 主线程从main（）开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，线程也结束运行
• 整个进程是否执行完毕的标志是：主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了，此时，一般情况下：如果其他子线程还没有执行完，也会被强行终止【此条有例外，以后会解释】

创建一个线程：

• (1)包含头文件<thread> thread是个标准库的类
• (2)写初始函数
• (3)在main中创建thread
  必须要明白：有两个线程在跑，相当于整个程序中有两条线在同时走，即使一条被阻塞，另一条也能运行

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

void myPrint()
{
	cout << "我的线程开始运行" << endl;
	//-------------
	//-------------
	cout << "我的线程运行完毕" << endl;
	return;
}

int main()
{
	//(1)创建了线程，线程执行起点（入口）是myPrint；(2)执行线程
	thread myThread(myPrint);//括号里面接收的是一个可调用对象，myPrint作为构造函数的实参传递进去

	//(2)阻塞主线程并等待myPrint执行完，当myPrint执行完毕，join()就执行完毕，主线程继续往下执行
	//join意为汇合，子线程和主线程回合
	myThread.join();

	//(3)传统多线程程序中，主线程要等待子线程执行完毕，然后自己才能向下执行
	//detach:分离，主线程不再与子线程汇合，不再等待子线程
	//detach后，子线程和主线程失去关联，驻留在后台，由C++运行时库接管
	//myThread.detach();

	//(4)joinable()判断是否可以成功使用join()或者detach()
	//如果返回true，证明可以调用join()或者detach()
	//如果返回false，证明调用过join()或者detach()，join()和detach()都不能再调用了
	if (myThread.joinable())
	{
		cout << "可以调用可以调用join()或者detach()" << endl;
	}
	else
	{
		cout << "不能调用可以调用join()或者detach()" << endl;
	}
	
	cout << "Hello World!" << endl;
	return 0;
}

重要补充：
线程类参数是一个可调用对象。
一组可执行的语句称为可调用对象，c++中的可调用对象可以是函数、函数指针、lambda表达式、bind创建的对象或者重载了函数调用运算符的类对象。
可调用对象

2、其他创建线程的方法

①创建一个类，并编写圆括号重载函数(不然就是不可调用对象)，初始化一个该类的对象，把该对象作为线程入口地址

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <thread>
using namespace std;

class Ta
{
public:
	void operator()()//不能带参数
	{
		std::cout << "Ta::我的子线程开始了" << std::endl;
		std::cout << "Ta::我的子线程结束了" << std::endl;
	}
protected:
private:
};

int main(int argc, char* argv[])
{
	Ta ta;
	std::thread ta_thread(ta);
	if (ta_thread.joinable())
	{
		std::cout << "ta_thread.joinable" << std::endl;
		ta_thread.join();
	}
	system("pause");
	return 0;
}

detach产生的问题：

• 问题1：主线程结束，子线程使用的是主线程的局部变量，当主线程结束的时候，局部变量已经被销毁，子线程再去访问主线程的局部变量失效，会变成随机数
• 问题2：主线程结束时，主线程创建的对象被销毁，但是不影响子线程，因为主线程的对象已经被赋值到子线程里面去了；当主线程结束时，子线程的对象还在，类方法还能用
• 只要这个对象里面没有引用，没有指针，就不会产生问题

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


class Ta
{
public:
	Ta(int &a) :a_(a)
	{
		std::cout << "Ta构造函数被执行" << std::endl;
	}
	Ta(const Ta &ta) :a_(ta.a_)
	{
		std::cout << "Ta拷贝构造函数被执行" << std::endl;
	}
	~Ta()
	{
		std::cout << "Ta析构函数被执行" << std::endl;
	}

	void operator()()
	{
		std::cout << "1::a_ = " << a_ <<std::endl;
		std::cout << "2::a_ = " << a_ << std::endl;
		std::cout << "3::a_ = " << a_ << std::endl;
		Sleep(500);
		std::cout << "4::a_ = " << a_ << std::endl;
		std::cout << "5::a_ = " << a_ << std::endl;
		std::cout << "6::a_ = " << a_ << std::endl;
		std::cout << "7::a_ = " << a_ << std::endl;
		std::cout << "8::a_ = " << a_ << std::endl;
		std::cout << "9::a_ = " << a_ << std::endl;
		std::cout << "10::a_ = " << a_ << std::endl;

	}
protected:
private:
	int &a_;
};

int main(int argc, char* argv[])
{
	int a = 3;
	Ta ta(a);
	std::thread ta_thread(ta);
	//ta_thread.join();
	ta_thread.detach();
	return 0;
}

去掉引用：

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


class Ta
{
public:
	Ta(int a) :a_(a)
	{
		std::cout << "Ta构造函数被执行" << std::endl;
	}
	Ta(const Ta ta) :a_(ta.a_)
	{
		std::cout << "Ta拷贝构造函数被执行" << std::endl;
	}
	~Ta()
	{
		std::cout << "Ta析构函数被执行" << std::endl;
	}

	void operator()()
	{
		std::cout << "1::a_ = " << a_ <<std::endl;
		std::cout << "2::a_ = " << a_ << std::endl;
		std::cout << "3::a_ = " << a_ << std::endl;
		Sleep(500);
		std::cout << "4::a_ = " << a_ << std::endl;
		std::cout << "5::a_ = " << a_ << std::endl;
		std::cout << "6::a_ = " << a_ << std::endl;
		std::cout << "7::a_ = " << a_ << std::endl;
		std::cout << "8::a_ = " << a_ << std::endl;
		std::cout << "9::a_ = " << a_ << std::endl;
		std::cout << "10::a_ = " << a_ << std::endl;

	}
protected:
private:
	int a_;
};

int main(int argc, char* argv[])
{
	int a = 3;
	Ta ta(a);
	std::thread ta_thread(ta);
	//ta_thread.join();
	ta_thread.detach();
	return 0;
}

②lambda表达式创建线程

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


int main(int argc, char* argv[])
{
	auto lambda_thread = []
	{
		std::cout << "我的线程开始了" << std::endl;
		std::cout << "我的线程结束了" << std::endl;
	};

	std::thread my_thread(lambda_thread);
	my_thread.join();
	system("pause");
	return 0;
}