目录

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()){//出让cputhis_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()){//出让cputhis_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;
};