目录
thread
线程的构造方式
相关成员函数
join与detach
线程传参
互斥量mutex
mutex
Locks
原子性操作库
条件变量
thread
线程的构造方式
它是不支持拷贝构造，赋值的，但是可以支持移动构造，移动赋值。还可以直接创建无参的对象。
它的有参的构造是支持可变参数模板的，
fn：可调用对象，比如函数指针、仿函数、lambda表达式、被包装器包装后的可调用对象等。args...：调用可调用对象fn时所需要的若干参数。
例如：
使用构造函数：
void Print1(int n)
{
for (int i = 0; i < n; i++)
{
cout << "hello" << endl;
}
}
int main()
{
int n = 1000;
thread t1(Print1, n);
thread t2(Print1, n );
t1.join();
t2.join();
return 0;
}使用lambda：
thread t3([&]() {
for (int i = 0; i < n; i++)
{
cout << "hello" << endl;
}
}
);
t3.join();也可以使用移动构造：
//thread t3 = t1;//不允许
thread t4 = thread(Print1, n);//移动构造
t4.join();相关成员函数
例如:常用的函数
join:对该线程进行等待，在等待的线程返回之前，调用join函数的线程将会被阻塞
detach:将该线程与创建线程进行分离，被分离后的线程不再需要创建线程调用join函数对其进行等待。
get_id:获取该线程的id
joinable:判断该线程是否已经执行完毕，如果是则返回true，否则返回false.
joinable函数还可以用于判定线程是否是有效的这些情况，线程都是无效的采用无参构造函数构造的线程对象。（该线程对象没有关联任何线程）
线程对象的状态已经转移给其他线程对象。（已经将线程交给其他线程对象管理）
线程已经调用join或detach结束。（线程已经结束）
但上面这些函数都是需要通过线程对象来获取的，如果要在线程对象关联的线程函数中获取线程id，可以调用this_thread命名空间下的get_id函数。
该空间下的函数：
yield:只让当前线程退出运行状态，让其它线程去调度。
join与detach
当一个线程退出时，需要对该线程所使用的资源进行回收，否则可能会导致内存泄露等问题。
可以是主线程调用join函数，对线程进行回收，或者也可以调用detach函数将新线程与主线程进行分离，分离后新线程会在后台运行，其所有权和控制权将会交给C++运行库，此时C++运行库会保证当线程退出时，其相关资源能会被正确回收。
这里也存在一个问题，若在某些情况下，导致线程不能被正确回收，例如：
void Print1(int n,int& k)
{
for (int i = 0; i < n; i++)
{
k++;
}
}
void Errno(bool& flag)
{
flag = true;
}
int main()
{
int n = 100000;
int k = 0;
thread t1(Print1,n,ref(k));
thread t2(Print1,n,ref(k));
bool flag = false;
Errno(flag);
if (flag)
return -1；
t1.join();
t2.join();
cout << "k=" << k << endl;
return 0;
}这里可以借用RAII思想解决，代码示例：
class RAII
{
public:
RAII(thread& t)
:t_(t)
{
}
~RAII()
{
if (t_.joinable())
{
t_.join();
cout << "线程回收" << endl;
}
}
private:
thread& t_;
};
int main()
{
int n = 100000;
int k = 0;
thread t1(Print1,n,ref(k));
thread t2(Print1,n,ref(k));
RAII T1(t1);
RAII T2(t2);
bool flag = false;
Errno(flag);
if (flag)
return -1;
t1.join();
t2.join();
cout << "k=" << k << endl;
return 0;
}结果：
线程传参
线程传参时是以值拷贝的方式拷贝到线程空间当中的，即使将参数设置为引用，也不会改变外边的变量。
例如：
void Print1(int n,int& m)
{
for (int i = 0; i < n; i++)
{
cout << "hello" << endl;
m++;
}
}
int main()
{
int n = 1000;
int m = 0;
thread t1(Print1, n,m);
thread t2(Print1, n,m);
cout << m << endl;
t1.join();
t2.join();
return 0;
}这段代码在vs2019还下不能运行
解决方法：
使用std::ref函数，当线程中函数的参数为引用时，可以借助ref函数保持对实参的引用，而不是线程栈空间中的拷贝。
例如：
thread t1(Print1, n,ref(m));
thread t2(Print1, n,ref(m));将函数的参数改为指针类型，例如：
或者使用lambda，例如：
互斥量mutex
mutex
以这段代码为例：
void Print1(int n,int& k)
{
for (int i = 0; i < n; i++)
{
k++;
}
}
int main()
{
mutex mu_;
int n = 100000;
int k = 0;
thread t1(Print1,n,ref(k));
thread t2(Print1,n,ref(k));
t1.join();
t2.join();
cout << "k=" << k << endl;
return 0;
}由于k++不是原子性的操作，当多个执行流去对这个变量操作时，可能会出现二义性。
结果：
对于临界资源，要进行加锁保护。C++11提供了4种锁：
都是不能进行拷贝的。不同的锁分别用于不同的场景中。最常使用的就是mutex。
该锁的成员函数有：
try_lock:尝试对该线程加锁，若成功会返回TRUE，失败返回false。
对上面的代码进行加锁：
Locks
在对代码进行加锁的过程中，可能因为加锁的代码太长，进行了误操作。或者抛异常等原因，从而导致死锁问题。这里便也可以使用RAII思想。在需要加锁的地方，创建一个Lock对象，其构造函数会进行加锁，在其生命结束时，自动调用析构函数进行解锁。
例如：
template<class Lock>
class LockGuard
{
public:
LockGuard(Lock& lk)
:_lock(lk)
{
_lock.lock();
cout << "thread:" << this_thread::get_id() << "加锁" << endl;
}
~LockGuard()
{
cout << "thread:" << this_thread::get_id() << "解锁" << endl << endl;
_lock.unlock();
}
private:
Lock& _lock;
};c++11也提供了两个类型用来加锁，其中unique_lock还提供了一些成员函数，使用上更加灵活。
例如：
原子性操作库<atomic>
当一个数据被多个执行流访问时，除了加锁进行互斥访问外，C++11中引入了原子操作类型。
支持模板，可以定任意原子类型数据
对上面代码进行更改：
补充：定义为原子数据的变量，是不能进行赋值，拷贝构造，移动构造的。
条件变量
使用是要搭陪锁（互斥量）去使用，以第一个类为例。它们提供的成员函数可分为两大类。
一个是等待，一个是去唤醒。
等待：以wait为例
提供了两个版本：
一个是直接传入unique<mutex_>,若线程调用wait后会立即被阻塞，直到被唤醒。
另一个还需传入一个返回值为bool的对象，当线程被唤醒后还需要调用传入的可调用对象，如果可调用对象的返回值为false，那么该线程还会被继续被阻塞。
唤醒：
一个是唤醒等待队列中的第一个线程，另一个是唤醒全部线程
代码测试：以两个线程交替打印100位例，一个线程打印奇数，另一个打印偶数；
int main()
{
int i = 0;
int n = 100;
mutex mtx;
thread t1([&](){
while (i < n)
{
while (i % 2 == 0)
{
this_thread::yield();
}
cout << "t1--" << this_thread::get_id() << ":" << i << endl;
i += 1;
}
});
// t2打印偶数
thread t2([&]() {
while (i < n)
{
while (i % 2 != 0)
{
this_thread::yield();
}
cout <<"t2--"<<this_thread::get_id() << ":" << i << endl;
i += 1;
}
});
this_thread::sleep_for(chrono::seconds(3));
cout << "t1:" << t1.get_id() << endl;
cout << "t2:" << t2.get_id() << endl;
t1.join();
t2.join();
return 0;
}使用条件变量：
int main()
{
int i = 0;
int n = 100;
mutex mtx;
condition_variable cv;
bool ready = true;
thread t1([&](){//打印奇数
while (i < n)
{
unique_lock<mutex> lock(mtx);
cv.wait(lock, [&ready]() {return !ready; });
cout << "t1--" << this_thread::get_id() << ":" << i << endl;
i += 1;
ready = true;
cv.notify_one();
//this_thread::yield();
//this_thread::sleep_for(chrono::microseconds(100));
}
});
thread t2([&]() {// t2打印偶数
while (i < n)
{
unique_lock<mutex> lock(mtx);
cv.wait(lock, [&ready](){return ready; });
cout <<"t2："<<this_thread::get_id() << ":" << i << endl;
i += 1;
ready = false;
cv.notify_one();
}
});
this_thread::sleep_for(chrono::seconds(3));
cout << "t1:" << t1.get_id() << endl;
cout << "t2:" << t2.get_id() << endl;
t1.join();
t2.join();
return 0;
}结果：
![[Pandas] 构建DataFrame数据框](https://img-blog.csdnimg.cn/c01b99c1798248cfa699cc64c16557cc.png)
![[Pandas] 查看DataFrame的常用属性](https://img-blog.csdnimg.cn/32e7d7a3aaf647e4bfae63090d316be1.png)
![[架构之路-185]-《软考-系统分析师》-3-操作系统基本原理 - 文件索引表](https://img-blog.csdnimg.cn/679b63ffaad542a5bbe1b59f58eafc57.png)