目录

• 前言
• 1、创建第一个线程
• 2、线程对象的生命周期、等待和分离
• 3、线程创建的多种方式
• 4、互斥量
• 4.1 独占的互斥量std::mutex
• 4.2 递归独占互斥量recursive_mutex
• 4.4 std::lock_guard和std::unique_lock
• 5、call_once/once_flag的使用
• 6、条件变量

前言

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

1、创建第一个线程

//创建线程需要引入头文件thread
#include<thread>  
#include<iostream>

void ThreadMain()
{
	cout << "begin thread main" << endl;
}

int main()
{
	//创建新线程t并启动
	thread t(ThreadMain);
	//主线程(main线程)等待t执行完毕
	if (t.joinable()) //必不可少
	{
		//等待子线程退出
		t.join();	//必不可少
	}
	return 0;
}

我们都知道，对于一个单线程来说，也就main线程或者叫做主线程，所有的工作都是由main线程去完成的。而在多线程环境下，子线程可以分担main线程的工作压力，在多个CPU下，实现真正的并行操作。

在上述代码中，可以看到main线程创建并启动了一个新线程t，由新线程t去执行ThreadMain()函数，jion函数将会把main线程阻塞住，知道新线程t执行结束，如果新线程t有返回值，返回值将会被忽略

我们可以通过函数this_thread::get_id()来判断是t线程还是main线程执行任务

void ThreadMain()
{
	cout << "线程" << this_thread::get_id()<< ":begin thread main" << endl;
}

int main()
{
	//创建新线程t并启动
	thread t(ThreadMain);
	//主线程(main线程)等待t执行完毕
	if (t.joinable()) //必不可少
	{
		//等待子线程退出
		cout << "线程" << this_thread::get_id() << ":正在等待" << endl;
		t.join();	//必不可少
	}
	return 0;
}

执行结果：

2、线程对象的生命周期、等待和分离

void func()
{
	cout << "do func" << endl;
}

int main()
{
	thread t(func);
	return 0;
}

上诉代码运行可能会抛出异常，因为线程对象t可能先于线程函数func结束，应该保证线程对象的生命周期在线程函数func执行完时仍然存在

为了防止线程对象的生命周期早于线程函数fun结束，可以使用线程等待join

void func()
{
	while (true)
	{
		cout << "do work" << endl;
		this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒
	}
}

int main()
{
	thread t(func);
	if (t.joinable())
	{
		t.join();//main线程阻塞
	}
	return 0;
}

虽然使用join能有效防止程序的崩溃，但是在某些情况下，我们并不希望main线程通过join被阻塞在原地，此时可以采用detach进行线程分离。但是需要注意：detach之后main线程就无法再和子线程发生联系了，比如detach之后就不能再通过join来等待子线程，子线程任何执行完我们也无法控制了

void func()
{
	int count = 0;
	while (count < 3)
	{
		cout << "do work" << endl;
		count++;
		this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒
	}
}

int main()
{
	thread t(func);
	t.detach();
	this_thread::sleep_for(std::chrono::seconds(1));//当前线程睡眠1秒
	cout << "线程t分离成功" << endl;
	return 0;
}

执行结果：

3、线程创建的多种方式

线程的创建和执行，无非是给线程指定一个入口函数嘛，例如main线程的入口函数就main()函数，前面编写的子线程的入口函数是一个全局函数。除了这些之外线程的入口函数还可以是函数指针、仿函数、类的成员函数、lambda表达式等，它们都有一个共同的特点：都是可调用对象。线程的入口函数指定，可以为任意一个可调用对象。

普通函数作为线程的入口函数

void func()
{
	cout << "hello world" << endl;
}

int main()
{
	thread t(func);
	if (t.joinable())
	{
		t.join();
	}
	return 0;
}

类的成员函数作为线程的入口函数

class ThreadMain
{
public:
	ThreadMain() {}
	virtual ~ThreadMain(){}
	void SayHello(std::string name)
	{
		cout << "hello " << name << endl;
	}
};

int main()
{
	ThreadMain obj;
	thread t(&ThreadMain::SayHello, obj, "fl");
	thread t1(&ThreadMain::SayHello, &obj, "fl");
	t.join();
	t1.join();
	return 0;
}

t和t1在传递参数时存在不同：

• t是用对象obj调用线程函数的语句，即线程函数将在obj对象的上下文中运行。这里obj是通过值传递给线程构造函数的，因此在线程中使用的是对象obj的一个副本。这种方式适用于类定义在局部作用域中时，需要将其传递给线程的情况。
• t1是使用对象的指针&obj调用线程函数的语句，即线程函数将在对象obj的指针所指向的上下文中运行。这里使用的是对象obj的指针，因此在线程中使用的是原始的obj对象。这种方式适用于类定义在全局或静态作用域中时，需要将其传递给线程的情况。

如果需要在类的成员函数中，创建线程，以类中的另一个成员函数作为入口函数，再执行

class ThreadMain
{
public:
	ThreadMain() {}
	virtual ~ThreadMain(){}
	void SayHello(std::string name)
	{
		cout << "hello " << name << endl;
	}
	void asycSayHello(std::string name)
	{
		thread t(&ThreadMain::SayHello, this, name);
		if (t.joinable())
		{
			t.join();
		}
	}
};

int main()
{
	ThreadMain obj;
	obj.asycSayHello("fl");
	return 0;
}

在asycSayHello的成员函数中，如果没有传递this指针，会导致编译不通过

原因就是参数列表不匹配，因此需要我们显示的传递this指针，表示以本对象的成员函数作为参数的入口函数

lambda表达式作为线程的入口函数

int main()
{
	thread t([](int i){
		cout << "test lambda i = " << i << endl;
	}, 123);
	if (t.joinable())
	{
		t.join();
	}
	return 0;
}

执行结果：

在类的成员函数中，以lambda表达式作为线程的入口函数

class TestLmadba
{
public:
	void Start()
	{
		thread t([this](){
			cout << "name is " << this->name << endl;
		});
		if (t.joinable())
		{
			t.join();
		}
	}

private:
	std::string name = "fl";
};

int main()
{
	TestLmadba test;
	test.Start();
	return 0;
}

在类的成员函数中，以lambda表达式作为线程的入口函数，如果需要访问兑现的成员变量，也需要传递this指针

仿函数作为线程的入口函数

class Mybusiness
{
public:
	Mybusiness(){}
	virtual ~Mybusiness(){}

	void operator()(void)
	{
		cout << "Mybusiness thread id is " << this_thread::get_id() << endl;
	}

	void operator()(string name)
	{
		cout << "name is " << name << endl;
	}
};

int main()
{
	Mybusiness mb;
	thread t(mb);
	if (t.joinable())
	{
		t.join();
	}
	thread t1(mb, "fl");
	if (t1.joinable())
	{
		t1.join();
	}
	return 0;
}

执行结果：

线程t以无参的仿函数作为函数入口，而线程t1以有参的仿函数作为函数入口

函数指针作为线程的入口函数

void func()
{
	cout << "thread id is " << this_thread::get_id() << endl;
}

void add(int a, int b)
{
	cout << a << "+" << b << "=" << a + b << endl;
}

int main()
{	
	//采用C++11扩展的using来定义函数指针类型
	using FuncPtr = void(*)();
	using FuncPtr1 = void(*)(int, int);
	//使用FuncPtr来定义函数指针变量
	FuncPtr ptr = &func;
	thread t(ptr);
	if (t.joinable())
	{
		t.join();
	}

	FuncPtr1 ptr1 = add;
	thread t1(ptr1, 1, 10);
	if (t1.joinable())
	{
		t1.join();
	}
	return 0;
}

执行结果：

function和bind作为线程的入口函数

void func(string name)
{
	cout << this_thread::get_id() << ":name is " << name << endl;
}

int main()
{
	function<void(string)> f(func);
	thread t(f, "fl");
	if (t.joinable())
	{
		t.join();
	}
	thread t1(bind(func, "fl"));
	if (t1.joinable())
	{
		t1.join();
	}
	return 0;
}

执行结果：

线程不能拷贝和复制，但可以移动

//赋值操作
void func(string name)
{
	cout << this_thread::get_id() << ":name is " << name << endl;
}

int main()
{
	thread t1(func, "fl");
	thread t2 = t1;
	thread t3(t1);
	return 0;
}

编译报错：

在线程内部，已经将线程的赋值和拷贝操作delete掉了，所以无法调用到

//移动操作
void func(string name)
{
	cout << this_thread::get_id() << ":name is " << name << endl;
}

int main()
{
	thread t1(func, "fl");
	thread t2(std::move(t1));
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

执行结果：

线程被移动之后，线程对象t1将不代表任何线程了，可以通过调试观察到

4、互斥量

当多个线程同时访问同一个共享资源时，如果不加以保护或者不做任何同步操作，可能出现数据竞争或不一致的状态，导致程序运行出现问题。

为了保证所有的线程都能够正确地、可预测地、不产生冲突地访问共享资源，C++11提供了互斥量。

互斥量是一种同步原语，是一种线程同步手段，用来保护多线程同时访问的共享数据。互斥量就是我们平常说的锁

C++11中提供了4种语义的互斥量

• std::mutex：独占的互斥量，不能递归
• std::timed_mutex：带超时的独占互斥量，不能递归使用
• std::recursive_mutex：递归互斥量，不能带超时功能
• std::recursive_timed_mutex：带超时的递归互斥量

4.1 独占的互斥量std::mutex

这些互斥量的接口基本类似，一般用法是通过lock()方法来阻塞线程，知道获得互斥量的所有权为止。在线程获得互斥量并完成任务之后，就必须使用unlock()来解除对互斥量的占用，lock()和unlock()必须成对出现。try_lock()尝试锁定互斥量，如果成功则返回true，失败则返回false，它是非阻塞的。

int num = 0;
std::mutex mtx;
void func()
{
	for (int i = 0; i < 100; ++i)
	{
		mtx.lock();
		num++;
		mtx.unlock();
	}
}

int main()
{
	thread t1(func);
	thread t2(func);
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	cout << num << endl;
	return 0;
}

执行结果：

使用lock_guard可以简化lock/unlock的写法，同时也更安全，因为lock_guard在构造时会自动锁定互斥量，而在退出作用域后进行析构时自动解锁，从而保证了互斥量的正确操作，避免忘记unlock操作，因此，尽量用lock_guard。lock_guard用到了RALL技术，这种技术在类的构造函数中分配资源，在析构函数中释放资源，保证资源在出了作用域之后就释放。上面的例子使用lock_guard后会更简介，代码如下：

void func()
{
	for (int i = 0; i < 100; ++i)
	{
		lock_guard<mutex> lock(mtx);
		num++;
	}
}

一般来说，当某个线程执行操作完毕后，释放锁，然后需要等待几十毫秒，让其他线程也去获取锁资源，也去执行操作。如果不进行等待的话，可能当前线程释放锁后，又立马获取了锁资源，会导致其他线程出现饥饿。

4.2 递归独占互斥量recursive_mutex

递归锁允许同一线程多次获得该互斥锁，可以用来解决同一线程需要多次获取互斥量时死锁的问题。在以下代码中，一个线程多次获取同一个互斥量时会发生死锁：

class Complex
{
public:
	std::mutex mtx;
	void SayHello()
	{
		lock_guard<mutex> lock(mtx);
		cout << "Say Hello" << endl;
		SayHi();
	}

	void SayHi()
	{
		lock_guard<mutex> lock(mtx);
		cout << "say Hi" << endl;
	}
};

int main()
{
	Complex complex;
	complex.SayHello();
	return 0;
}

执行结果：

这个例子运行起来就发生了死锁，因为在调用SayHello时获取了互斥量，之后再调用SayHI又要获取相同的互斥量，但是这个互斥量已经被当前线程获取 ，无法释放，这时就会产生死锁，导致程序崩溃。

要解决这里的死锁问题，最简单的方法就是采用递归锁：std::recursive_mutex，它允许同一个线程多次获取互斥量

class Complex
{
public:
	std::recursive_mutex mtx;//同一线程可以多次获取同一互斥量，不会发生死锁
	void SayHello()
	{
		lock_guard<recursive_mutex> lock(mtx);
		cout << "Say Hello" << endl;
		SayHi();
	}

	void SayHi()
	{
		lock_guard<recursive_mutex> lock(mtx);
		cout << "say Hi" << endl;
	}
};

执行结果：

需要注意的是尽量不要使用递归锁比较好，主要原因如下：

1、需要用到递归锁定的多线程互斥量处理往往本身就是可以简化的，允许递归互斥量很容易放纵复杂逻辑的产生，而非导致一些多线程同步引起的晦涩问题

2、递归锁的效率比非递归锁的效率低

3、递归锁虽然允许同一个线程多次获得同一个互斥量，但可重复的最大次数并为具体说明，一旦超过一定次数，再对lock进行调用就会抛出std::system错误

4.3 带超时的互斥量std::timed_mutex和std::recursive_timed_mutex

std::timed_mutex是超时的独占锁，srd::recursive_timed_mutex是超时的递归锁，主要用在获取锁时增加超时锁等待功能，因为有时不知道获取锁需要多久，为了不至于一直在等待获互斥量，就设置一个等待超时时间，在超时时间后还可做其他事。

std::timed_mutex比std::mutex多了两个超时获取锁的接口：try_lock_for和try_lock_until，这两个接口是用来设置获取互斥量的超时时间，使用时可以用一个while循环去不断地获取互斥量。

std::timed_mutex mtx;

void work()
{
	chrono::milliseconds timeout(100);
	while (true)
	{
		if (mtx.try_lock_for(timeout))
		{
			cout << this_thread::get_id() << ": do work with the mutex" << endl;
			this_thread::sleep_for(chrono::milliseconds(250));
			mtx.unlock();
		}
		else
		{
			cout << this_thread::get_id() << ": do work without the mutex" << endl;
			this_thread::sleep_for(chrono::milliseconds(100));
		}
	}
}

int main()
{
	thread t1(work);
	thread t2(work);
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

执行结果：

在上面的例子中，通过一个while循环不断地去获取超时锁，如果超时还没有获取到锁时就休眠100毫秒，再继续获取锁。

相比std::timed_mutex，std::recursive_timed_mutex多了递归锁的功能，允许同一个线程多次获得互斥量。std::recursive_timed_mutex和std::recursive_mutex的用法类似，可以看作在std::recursive_mutex的基础上增加了超时功能

4.4 std::lock_guard和std::unique_lock

lock_guard和unique_lock的功能完全相同，主要差别在于unique_lock更加灵活，可以自由的释放mutex，而lock_guard需要等到生命周期结束后才能释放。

它们的构造函数中都有第二个参数

unique_lock：

lock_guard：

可以从源码中看到，unique_lock的构造函数中，第二个参数的种类有三种，分别是adopt_lock，defer_lock和try_to_lock。lock_guard的构造函数中，第二个参数的种类只有一种，adopt_lock

这些参数的含义分别是：

adopt_lock：互斥量已经被lock，构造函数中无需再lock(lock_ guard与unique_lock通用)

defer_lock：互斥量稍后我会自行lock，不需要在构造函数中lock，只初始化一个没有加锁的mutex

try_to_lock：主要作用是在不阻塞线程的情况下尝试获取锁，如果互斥量当前未被锁定，则返回std::unique_lock对象，该对象拥有互斥量并且已经被锁定。如果互斥量当前已经被另一个线程锁定，则返回一个空的std::unique_lock对象

mutex mtx;
void func()
{
	//mtx.lock();//需要加锁，否则在lock的生命周期结束后，会自动解锁，则会导致程序崩溃
	unique_lock<mutex> lock(mtx, std::adopt_lock);
	cout << this_thread::get_id() << " do work" << endl;
}

int main()
{
	thread t(func);
	if (t.joinable())
	{
		t.join();
	}
	return 0;
}

执行结果：

adopt_lock就表示构造unique_lock<mutex>时，认为mutex已经加过锁了，就不会再加锁了，它就把加锁的权限和时机交给了我们，由我们自己控制

mutex mtx;
void func()
{
	while (true)
	{
		unique_lock<mutex> lock(mtx, std::defer_lock);
		cout << "func thread id is " << this_thread::get_id() << endl;
		this_thread::sleep_for(chrono::milliseconds(500));
	}
}

int main()
{
	thread t1(func);
	thread t2(func);
	if (t1.joinable())
	{
		t1.join();
	}
	if (t2.joinable())
	{
		t2.join();
	}
	return 0;
}

执行结果：

本来我们的意愿是t1和t2每个时刻只能有一个线程打印"func thread id is…"，但是实际上却发生了竞争的关系，原因就在于defer_lock在构造unique_lock<mutex>时，认为mutex在后面会加锁，也就没有加锁，所以打印结果才发生混乱，因此需要我们手动改进一下

void func()
{
	while (true)
	{
		unique_lock<mutex> lock(mtx, std::defer_lock);
		lock.lock();
		cout << "func thread id is " << this_thread::get_id() << endl;
		this_thread::sleep_for(chrono::milliseconds(500));
		//lock.unlock();  //可以加，也可以不加
		//因为内部有一个标准为，如果我们自己手动解锁了，由于标志位的改变，在调用lock的析构函数时，就不会进行解锁操作
	}
}

执行结果：

5、call_once/once_flag的使用

为了保证在多线程环境中某个函数仅被调用一次，比如，需要在初始化某个对象，而这个对象只能初始化一次时，就可以用std::call_once来保证函数在多线程环境中只能被调用一次。使用std::call_once时，需要一个once_flag作为call_once的入参，用法比较简单

call_once函数模板

在使用call_once时，第一个参数是类型为once_flag的标志位，第二个参数是一个可调用对象，第三个为可变参数，表示的可调用对象中的参数

std::once_flag flag;

void do_once()
{
	std::call_once(flag, [](){
		cout << "call once" << endl;
	});
}

int main()
{
	const int ThreadSize = 5;
	vector<thread> threads;
	for (int i = 0; i < ThreadSize; ++i)
	{
		threads.emplace_back(do_once);
	}
	for (auto& t : threads)
	{
		if (t.joinable())
		{
			t.join();
		}
	}
	return 0;
}

执行结果：

6、条件变量

条件变量是C++11提供的另外一种用于等待的同步机制，它能够阻塞一个或者多个贤臣，直到收到另一个线程发出的通知或者超时，才会唤醒当前阻塞的线程。条件变量需要和互斥量配合起来使用。C++11提供了两种条件变量：

• condition_valuable，配合std::unique<mutex>进行wait操作
• condition_valuable_any，和任意带有lock，unlock语义的mutex搭配使用，比较灵活，但效率比condition_valuable差一些

可以看到condition_valuable_any比condition_valuable更灵活，因为它通用，对所有的锁都适用，而condition_valuable的性能更好。我们应该根据具体的应用场景来选择合适的条件变量

条件变量的使用条件如下：

• 拥有条件变量的线程获取互斥量
• 循环检测某个条件，如果条件不满足，则阻塞直到条件满足；如果条件满足，则向下执行
• 某个线程满足条件执行完毕之后调用notify_onc或者notify_all唤醒一个或者所有等待的线程

一个简单的生产者消费者模型

mutex mtx;
condition_variable_any notEmpty;//没满的条件变量
condition_variable_any notFull;//不为空的条件变量
list<string> list_; //缓冲区
const int custom_threads_size = 3;//消费者的数量
const int produce_threads_size = 4;//生产者的数量
const int max_size = 10;

void produce(int i)
{
	while (true)
	{
		lock_guard<mutex> lock(mtx);
		notEmpty.wait(mtx, []{
			return list_.size() != max_size;
		});
		stringstream ss;
		ss << "生产者" << i << "生产的东西";
		list_.push_back(ss.str());
		notFull.notify_one();
	}
}

void custome(int i)
{
	while (true)
	{
		lock_guard<mutex> lock(mtx);
		notFull.wait(mtx, []{
			return !list_.empty();
		});
		cout << "消费者" << i << "消费了 " << list_.front() << endl;
		list_.pop_front();
		notEmpty.notify_one();
	}
}

int main()
{
	vector<std::thread> producer;
	vector<std::thread> customer;
	for (int i = 0; i < produce_threads_size; ++i)
	{
		producer.emplace_back(produce, i);
	}
	for (int i = 0; i < custom_threads_size; ++i)
	{
		customer.emplace_back(custome, i);
	}

	for (int i = 0; i < produce_threads_size; ++i)
	{
		producer[i].join();
	}
	for (int i = 0; i < custom_threads_size; ++i)
	{
		customer[i].join();
	}
	return 0;
}

在上述案例中，list<string> list_是一个临界资源，无论是生产者生产数据，还是消费者消费数据，都要往list_中插入数据或者删除数据，为了防止出现数据竞争或不一致的状态，导致程序运行出现问题，因为每次操作list_时都需要进行加锁操作。

当list_没有满的情况下，生产者可以生产数据，如果满了，则会阻塞在条件变量notFull下，需要消费者通过notify_one()随机唤醒一个生产者。

当list_不为空的情况下。消费者可以消费数据，如果空了，则会阻塞在条件变量notEmpty下，需要生产者通过notify_one()随机唤醒一个消费者。