目录

1. thread类的简单介绍
2. 线程函数参数
3. 锁
4. 线程交替打印
5. 原子性操作库
6. 无锁CAS
7. 智能指针的线程安全
8. 单例模式的线程安全

1. thread类的简单介绍

在c++11之前，涉及到多线程问题，都是和平台相关的，如windows和linux下各有自己的接口，这使得代码的可移植性差。c++11中最重要的特性就是对线程支持，使得c++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库的线程，必须包含头文件。C++11线程类

函数名	功能
thread()	构造一个线程对象，没有关联任何线程函数，即没有启动任何线程
thread(fn, args1, args2, …)	构造一个线程对象，并关联线程函数fn，args1，args2，…为线程函数的参数
get_id	获取线程id
jionable()	线程是否还在执行，joinable代表的是一个正在执行中的线程
jion()	函数调用后会阻塞线程，线程结束后，主线程继续执行
detach()	在创建线程对象后马上调用，用于把被创建线程与现场对象分离开，分离的线程变为后台线程，创建的线程的“死活”就与主线程无关

注意：
1.线程是操作系统的一个概念，线程对象可以关联一个线程，用来控制现场以及获取线程的状态
2.当创建线程对象后，没有提供函数，该对象实际没有对应任何线程

#include <thread>

int main()
{
	thread t1;
	cout << t1.get_id() << endl;
	return 0;
}

get_id()返回值为id类型，id类型实际为std::thread命名空间下封装的一个类，在该类中包含了一个结构体：

3.当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。线程函数一般情况下可按照以下三种方式提供：

• 函数指针
• lambda表达式
• 函数对象
• 包装器

void ThreadFunc(int a)
{
	cout << "Thread1" << a << endl;
}

class TF
{
public:
	void operator()()
	{
		cout << "Thread3" << endl;
	}
};

int main()
{
	//函数指针
	thread t1(ThreadFunc, 10);
	
	//线程函数lambda表达式
	thread t2([] {cout << "Thread2" << endl; });

	//线程函数为函数对象
	TF tf;
	thread t3(tf);
	
	t1.join();
	t2.join();
	t3.join();

4.thiread类是防拷贝的,不允许拷贝构造以及赋值,但是可以移动构造和移动赋值,即将一个县城对象关联线程的状态转移给其他线程对象,转移期间不影响线程的执行
例：创建10个线程同时打印，不能用for，线程会结束

void Func(int x, const string& str)
{
	for (size_t i = 0; i < x; i++)
	{
		cout << str << endl;
	}
}
vector<thread> vthd(10);
int i = 0;
for (auto& thd : vthd)
{
	//移动赋值,匿名对象将亡值
	thd = thread(Func, 10, "线程" + to_string(i++));
}

for (auto& thd : vthd)
{
	thd.join();
}

将一个线程转移给另一个对象，使用move，也可以swap

thread t1(Func, 1, "线程");
thread t2(move(t1));

t2.join();

5.可以通过joinable()函数判断线程是否有效，如果是以下情况，则线程无效：

• 采用无参构造的线程对象
• 线程对象的状态已经转移给其他线程对象
• 线程已经调用join或者detch结束

2. 线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间的，因此：即使线程参数为引用类型，线程中修改后也不能修改外部实参，因为其实际引用的是线程中的拷贝，而不是外部实参

想改变参数，可以传指针或者用ref

//vs2022 引用无法做参数
void ThreadFunc1(int& x)
{
	x += 10;
}

void ThreadFunc2(int* x)
{
	*x = 20;
}

// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际
//引用的是线程栈中的拷贝
thread t1(ThreadFunc2, &a);
t1.join();
cout << a << endl;

// 如果想要通过形参改变外部实参时，必须借助std::ref()函数
thread t2(ThreadFunc1, ref(a));
t2.join();
cout << a << endl;

a在传入的过程中，为了解析模板参数，实际上引用的是a的一个拷贝，对临时变量做引用编译不过，所以要加ref，中间推演就会推出引用类型。下面是不加的情况

像上面一样bar如果不加ref，是一份拷贝

下面两个线程同时对一个局部变量修改的操作

int x = 0;
size_t n1 = 0;
size_t n2 = 0;
cin >> n1 >> n2;

thread t1([n1, &x] {
	for (int i = 0; i < n1; i++)
	{
		x++;
	}
	});
thread t2([n2, &x] {
	for (int i = 0; i < n2; i++)
	{
		x++;
	}
	});

t1.join();
t2.join();
cout << x << endl;

两个线程同时++变量x，当每个线程加10000次，最终的值应该是20000

两个线程对变量的访问产生了冲突，导致丢失了很多次的++结果。对于这种不一致的情况就需要用到锁

3. 锁

c++11中，总共包含了四个互斥量的种类：

std::mutex

c++11提供的最基本的互斥量，该类的对象之间不能拷贝，也不能进行移动。mutex最常用的三个函数：
|函数名|函数功能|
|lock()|上锁：锁住互斥量|
|unlock()|解锁：释放对互斥量的所有权|
|try_lock()|尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会阻塞|

注意：当线程函数调用lock()，可能会发生以下三种情况：

• 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用unlock之前，该线程一直拥有锁
• 如果当前互斥量被其他线程锁住，则当前的调用线程阻塞
• 如果当前互斥量被当前调用线程锁住，则会产生死锁（deadlock）

线程调用try_lock()时，可能产生以下三种情况：

• 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到调用unlock
• 如果当前互斥量被其他线程锁住，则当前的调用线程返回false，而不是阻塞
• 如果当前互斥量被当前调用线程锁住，则会产生死锁（deadlock）

std::recursive_mutex

其允许同一个线程对互斥量多次上锁（即递归上锁），来获得互斥量对象的多层所有权，释放互斥量需要调用与该锁层次深度相同的unlock()，除此之外，recursive_mutex的特性和mutex大致相同

std::timed_mutex

比std::mutex多了两个成员函数，try_lock_for()，try_lock_until()
延时需要用sleep_for
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
chrono是一个时间度量类

• try_lock_for()
  接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁被阻塞住（与std::mutex的try_lock()不同，try_lock如果被调用时没有获得锁则直接返回false，如果再次期限其他线程释放了锁，则该线程可以获得互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回false
• try_lock_until()
  接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时，则返回false

std::recusive_timed_mutex

lock_guard

如果在加锁和解锁之间抛了异常，就会导致死锁的问题

void fun()
{
	if (rand() % 6 == 0)
	{
		throw exception("异常");
	}
	else
	{
		cout << "func" << endl;
	}
}

srand(time(0));
int x = 0;
size_t n1 = 0;
size_t n2 = 0;
mutex mtx;
cin >> n1;

thread t1([n1, &x, &mtx] {
	try
	{
		for (int i = 0; i < n1; i++)
		{
			/*LockGuard<mutex> lg(mtx);*/
			mtx.lock();
			x++;
			fun();
			mtx.unlock();
		}
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	
	});
	t1.join();
cout << x << endl;

避免死锁问题，可以采用RAII思想，使用一个类管理锁，出作用域自动解锁

template <class Lock>
class LockGuard
{
public:
	LockGuard(Lock& lk)
		:_mtx(lk)
	{
		_mtx.lock();
	}

	~LockGuard()
	{
		_mtx.unlock();
	}

private:
	Lock& _mtx;
};

thread t1([n1, &x, &mtx] {
	try
	{
		for (int i = 0; i < n1; i++)
		{
			LockGuard<mutex> lg(mtx);
			/*mtx.lock();*/
			x++;
			fun();
			/*mtx.unlock();*/
		}
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	
	});

库里面实现了这个类
std::lock_gurad是c++11中定义的模板类，定义如下：

template<class _Mutex>
class lock_guard
{
public:
	// 在构造lock_gard时，_Mtx还没有被上锁
	explicit lock_guard(_Mutex& _Mtx)
		: _MyMutex(_Mtx)
	{
		_MyMutex.lock();
	}
	// 在构造lock_gard时，_Mtx已经被上锁，此处不需要再上锁
	lock_guard(_Mutex& _Mtx, adopt_lock_t)
		: _MyMutex(_Mtx)
	{}
	~lock_guard() _NOEXCEPT
	{
		_MyMutex.unlock();
	}
	lock_guard(const lock_guard&) = delete;
	lock_guard& operator=(const lock_guard&) = delete;
private:
	_Mutex& _MyMutex;
};

通过上述代码可以看到，lock_guard类模板主要是通过RAII的方式，对其管理的互斥量进行封装，在需要加锁的地方，只需要用上述介绍的任意互斥提实例化一个lock_guard，调用构造函数成功上锁，出作用域前，lock_guard对象要被销毁，调用析构函数自动解锁，可以有效避免死锁问题

lock_guard的缺陷：太单一，用户没有办法对该锁进行控制，因此c++11又提供了unique_lock

unique_lock

与lock_guard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。在构造（或移动move赋值）时，unique_lock对象需要传递一个Mutex对象作为它的参数，新创建的unique_lock对象负责传入的Mutex对象的上锁和解锁操作。使用以上类型互斥量实例化unique_lock的对象时，自动调用构造函数上锁，unique_lock对象销毁时自动调用析构函数解锁，可以很方便的防止死锁问题

与lock_guard不同的是，unique_lock更加的灵活，提供了更多的成员函数

• 上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock
• 修改操作：移动赋值、交换swap：与另一个unique_lock对象互换所管理的互斥量所有权，释放release：返回它所管理的互斥量对象的指针，并释放所有权
• 获取属性：owns_lock（返回当前对象是否上了锁）、operator bool()与owns_lock()的功能相同、mutex（返回当前unique_lock所管理的互斥量的指针）

lock_guard和unique_lock

4. 两个线程交替打印，一个打印奇数，一个打印偶数

主要考察condition_variable条件变量的使用，linux有讲解，没有大的区别，主要还是面向对象实现，条件变量的文档：https://cplusplus.com/reference/condition_variable/

首先要保证t1线程先运行，然后保证执行的顺序，t1对变量修改后打印，然后t2再操作，接着不断循环。就需要条件变量和锁的配合使用。关键是如何保证t1先运行，就需要一个标记，t1线程刚开始要可以执行，t2则得阻塞住，当t1执行完通知t2后t2才可以执行，这时t1就得阻塞住

int x = 0;
mutex mtx;
condition_variable cod;
bool flag = false;
thread t1([&] {
	for (size_t i = 0; i < 10; i++)
	{
		unique_lock<mutex> lock(mtx);
		if (flag == true)
			cod.wait(lock);
		x++;
		cout << this_thread::get_id() << ":" << x << endl;
		flag = true;
		cod.notify_one();
	}
	});

thread t2([&] {
	for (size_t i = 0; i < 10; i++)
	{
		unique_lock<mutex> lock(mtx);
		if (flag == false)
			cod.wait(lock);
		x++;
		cout << this_thread::get_id() << ":" << x << endl;
		flag = false;
		cod.notify_one();
	}
	});

t1.join();
t2.join();

解析
分为两个场景，t1先启动和t2先启动

场景1：t1先启动，t2待定
a: t1先启动，抢到锁，falg是false，t1会执行完，然后通知t2
a1: t2如果没启动或者没分到时间片，t1就会将flag改为true，抢到锁后在条件变量阻塞。t2总会启动起来，falg是true，t2会正常运行，当运行完改flag为false后通知t1，在t1执行完之前自己就会再次阻塞。之后不断交替
b1: 如果t2启动了，就会阻塞，t1运行完后会通知t2，然后像上面一样

场景2：t1待定，t2先启动
t2先启动，会阻塞住，一直等待t1运行完毕通知t2，之后正常交替

自旋锁和互斥锁
互斥锁是一个线程获得锁后另一个线程没抢到锁，就切换上下文进入休眠等待呼唤。另一个线程用完锁后就会唤醒开始竞争锁。对于临界区操作很简单的这种会反复唤醒，代价有些大，所以这种情况适合自旋锁

//互斥
int x = 0;
mutex mtx;
thread t1([&] {
	for (size_t i = 0; i < 10; i++)
	{
		mtx.lock();
		x++;
		mtx.unlock();
	}
	});

thread t2([&] {
	for (size_t i = 0; i < 10; i++)
	{
		mtx.lock();
		x++;
		mtx.unlock();
	}
	});

t1.join();
t2.join();
cout << x << endl;

自旋锁是不断询问，每隔一段时间不断尝试，这种循环加锁就叫（spinlock）
下面修改为类似自旋锁的方式：

//自旋
int x = 0;
mutex mtx;
thread t1([&] {
	for (size_t i = 0; i < 10; i++)
	{
		while (!mtx.try_lock())
		{
			//出让cpu
			this_thread::yield();
		}
		x++;
		cout << this_thread::get_id() << ":" << x << endl;
		mtx.unlock();
	}
	});

thread t2([&] {
	for (size_t i = 0; i < 10; i++)
	{
		while (!mtx.try_lock())
		{
			//出让cpu
			this_thread::yield();
		}
		x++;
		cout << this_thread::get_id() << ":" << x << endl;
		mtx.unlock();
	}
	});

t1.join();
t2.join();
cout << x << endl;

5. 原子性操作库

对于上面这种要保护的临界区很少的情况，c++11提供了原子库，可以让操作变成原子的，就解决了问题
多线程最主要的问题是共享数据带来的问题（即线程安全）。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会设计到数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦

虽然加锁可以解决，但加锁的缺陷：只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁

因此c++11中引入了原子操作。所谓原子操作：即不可被中断的一个或一系列操作，c++11引入的原子操作类型，使得线程间数据的同步变得非常高效。需要头文件

atmoc是类，flag是临时用来保证一个变量的原子的单独操作

//原子
atomic<int> x = 0;
mutex mtx;
thread t1([&] {
	for (size_t i = 0; i < 10000; i++)
	{
		x++;
	}
	});

thread t2([&] {
	for (size_t i = 0; i < 10000; i++)
	{
		x++;
	}
	});

t1.join();
t2.join();
cout << x << endl;

用printf打印变量得调用函数load()
printf("%d\n", x.load());

在c++11中，不需要对原子类型变量加解锁操作，线程能够对原子类型变量互斥的访问
更为普遍的，使用atomic类模板，定义需要的任意原子类型

atmoic<T> t; // 声明一个类型为T的原子类型变量t

库里重载了很多操作

注意，原子类型通常属于“资源型”数据，多个线程只能访问单个原子类型的拷贝，因此在c++11中，原子类型只能从模板参数中构造，不允许原子类型进行拷贝构造、移动构造以及operator=等，为了防止意外，标准库已经将拷贝、移动、赋值删掉了

#include <atomic>
 int main()
 {
 atomic<int> a1(0);
 //atomic<int> a2(a1);    // 编译失败
atomic<int> a2(0);
 //a2 = a1;               // 编译失败
return 0;
 }

6. 无锁CAS

atmoic操作的实现在底层是cas
CAS无锁编程就是Compare & Set，或是 Compare & Swap，现在几乎所有的CPU指令都支持CAS的原子操作，X86下对应的是 CMPXCHG 汇编指令

对于这个操作过程的描述就是先看一看内存*reg里的值是不是oldval，如果是的话，则对其赋值newval

int compare_and_swap (int* reg, int oldval, int newval)
{
  int old_reg_val = *reg;
  if (old_reg_val == oldval) {
     *reg = newval;
  }
  return old_reg_val;
}

windows的无锁

 InterlockedCompareExchange ( __inout LONG volatile *Target,
                                 __in LONG Exchange,
                                 __in LONG Comperand);

c++11的无锁

template< class T >
bool atomic_compare_exchange_weak( std::atomic* obj,
                                   T* expected, T desired );
template< class T >
bool atomic_compare_exchange_weak( volatile std::atomic* obj,
                                   T* expected, T desired );

下面是++操作的原理

两个线程都先取一下旧值，最后赋值的时候取现值做一下对比，如果不相等则说明已经被另一个线程修改过了，再赋值就会出错。继续重新计算。直到赋值成功就完成了++操作

无锁队列的实现

队列的多线程插入过程中，容易出现一个线程创建了节点链接后被另一个线程覆盖了的情况。因为没有及时更新队尾，还是和之前线程链接的位置一样

EnQueue(Q, data) //进队列
{
    //准备新加入的结点数据
    n = new node();
    n->value = data;
    n->next = NULL;
    do {
        p = Q->tail; //取链表尾指针的快照
    } while( CAS(p->next, NULL, n) != TRUE); 
    //while条件注释：如果没有把结点链在尾指针上，再试
    CAS(Q->tail, p, n); //置尾结点 tail = n;
}

创建节点是线程安全的，因为在各自的栈里，关键在于链接的时候

p不断取队尾节点，如果是空就退出循环，链接节点到队尾，同时更新队尾。在这个过程中另一个线程取到的队尾不是空，就会重新取。直到可以连接的时候改变队尾

修改++操作
c++11跨平台封装了cax函数

//无锁
atomic<int> x = 0;
thread t1([&] {
	for (size_t i = 0; i < 10000; i++)
	{
		int oldx, newx;
		do
		{
			oldx = x;
			newx = x + 1;
		} while (!atomic_compare_exchange_weak(&x, &oldx, newx));	
	}
	});

thread t2([&] {
	for (size_t i = 0; i < 10000; i++)
	{
		int oldx, newx;
		do
		{
			oldx = x;
			newx = x + 1;
		} while (!atomic_compare_exchange_weak(&x, &oldx, newx));
	}
	});

t1.join();
t2.join();
cout << x << endl;

7. share_ptr多线程安全

SharedPtr<double> sp(new double(1.1));
thread t1([&] {
	for (size_t i = 0; i < 10000; i++)
	{
		SharedPtr<double> copy(sp);
	}
	});

thread t2([&] {
	for (size_t i = 0; i < 10000; i++)
	{
		SharedPtr<double> copy(sp);
	}
	});

t1.join();
t2.join();
cout << sp.Count() << endl;

两个线程多次拷贝智能指针时，就会出问题。因为有可能对堆上同一个计数加加，这时，就需要用原子库。++会调用原子库的重载

template <class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = nullptr)
		:_ptr(ptr),
		_pcount(new std::atomic<int>(1))
	{}

	template <class D>
	SharedPtr(T* ptr, D del)
		: _ptr(ptr),
		_pcount(new std::atomic<int>(1)),
		_del(del)
	{

	}

	~SharedPtr()
	{
		Release();
	}

	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr),
		_pcount(sp._pcount)
	{
		(*_pcount)++;
	}

	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		if (_ptr != sp._ptr)
		{
			Release();

			_ptr = sp._ptr;
			_pcount = sp._pcount;
			(*_pcount)++;
		}

		return *this;
	}

	void Release()
	{
		if (--(*_pcount) == 0)
		{
			//std::cout << "delete ptr" << std::endl;
			_del(_ptr);
		}
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	int Count() const
	{
		return *_pcount;
	}

	T* get() const
	{
		return _ptr;
	}

private:
	T* _ptr;
	//int* _pcount;
	std::atomic<int>* _pcount;
	std::function<void(T*)> _del = [](T* ptr) {delete ptr; };
};

智能指针保证了自己是线程安全的，里面维护的资源需要自己保证线程安全

8. 单例模式线程安全

饿汉模式因为main函数之前就初始化了，不存在安全问题。懒汉模式如果多个线程同时创建，有可能创建多个对象，所以要加锁，但这个锁只需要保证第一次，外面再套一层双检查

//懒汉
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		//只保护第一次，双检查
		if (_instace == nullptr)
		{
			unique_lock<mutex> lock(_mtx);
			if (_instace == nullptr)
			{
				_instace = new Singleton();
			}
		}
			
		return _instace;
	}

	//资源回收
	class CGarbo
	{
	public:
		CGarbo()
		{
			if (_instace)
			{
				delete _instace;
			}
		}
	};

private:

	Singleton() {};
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	static Singleton* _instace;
	static mutex _mtx;
	static CGarbo _garbo;
};

Singleton* Singleton::_instace = nullptr;
Singleton::CGarbo _garbo;  //程序结束自动调用析构释放单例对象

懒汉c++11的简单写法

只适用于c++11

//懒汉c++11写法
class Singleton
{
public:
	//提供接口
	static Singleton& GetInstance()
	{
		//第一次调用初始化
		//c++11之前这个不安全，11之后可以保证局部静态对象初始化是线程安全的，只初始化一次
		static Singleton inst;
		return inst;
	}
private:
	//构造函数私有
	Singleton(){}
	//防拷贝
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
};