1.线程概念
好处：可以跨平台：windows / linux / mac
线程间的互斥：mutex / lock_quard / unique_lock
线程间的通信：condition_variable
atomic : 原子类型 基于CAS操作的原子类型 线程安全的
sleep_for :睡眠
C++语言层面调用thread，在windows操作系统上底层调用的是createThread，在linux下调用的是pthread_create。可以通过编译器的编译，加一个宏，可以识别当前的操作系统，可以通过适配在语言层面编写的thread底层自动调用相应的函数。本质上还是在调用操作系统线程创建的API。就是语言层面加了一层封装，对于开发者更友好
2.线程的基本操作
线程内容：
- 1.怎么创建启动一个线程
std: :thread定义一个线程对象，传入线程所需要的线程函数和参数，线程自动开启 - 2.子线程如何结束
子线程函数运行完成，线程就结束了 - 3.主线程如何处理子线程
-
- t.join() : 等待t线程结束，当前线程继续往下运行
-
- t.detach() : 把t线程设置为分离线程，主线程结束，整个进程结束,所有子线程都自动结束了!
#include<iostream>
#include<thread>
using namespace std;
void threadHandle1()
{
//让子线程睡眠2秒
std::this_thread::sleep_for(std::chrono::seconds(2));
cout << "hello thread1!" << endl;
}
int main()
{
//创建了一个线程对象，传入一个线程函数，新线程就开始运行了
thread t1(threadHandle1);
//主线程等待子线程结束，主线程继续往下运行
//t1.join();
t1.detach();
cout << "main run over!" << endl;
return 0;
}
3.线程间互斥
mutex
只能用在简单的临界区代码段的互斥操作中
多线程程序
竞态条件:多线程程序执行的结果是一致的，不会随着CPU对线程不同的调用顺序，而产生不同的运行结果，
#include<thread>
#include<list>
#include<mutex>
using namespace std;
static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁
//模拟买票的线程函数
void sellTicket(int index)
{
mtx.lock();//此种加锁相当于只有一个窗口在买票
while (ticketcount >= 1)//锁+双重判断
{
if (ticketcount > 0)
{
//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
cout << "窗口：" << index << " 卖出第：" << ticketcount << " 张票！" << endl;
ticketcount--;
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
mtx.unlock();
}
int main()
{
list<std::thread>tlist;
for (int i = 1; i <= 3; i++)
{
tlist.push_back(std::thread(sellTicket, i));
}
for (thread& t : tlist)
{
t.join();
}
cout << "所有窗口买票结束！" << endl;
return 0;
}
#include<thread>
#include<list>
#include<mutex>
using namespace std;
static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁
//模拟买票的线程函数
void sellTicket(int index)
{
while (ticketcount >= 1)//锁+双重判断
{
mtx.lock();
if (ticketcount > 0)
{
//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
cout << "窗口：" << index << " 卖出第：" << ticketcount << " 张票！" << endl;
ticketcount--;
}
mtx.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
lock_quard
mutex最好不要手动加锁和解锁。因为临界区代码一旦执行错误，或者return了，那么获取的锁就无法释放了，一个线程不释放锁，其他线程不能获取锁，所以整个进程就是死锁，所以需要采取智能指针的思想（栈上对象出作用域都会被析构）：lock_quard / unique_lock
保证了所有线程都能释放锁，有效防止了死锁问题的发生
缺点：delete了赋值和拷贝构造，所以不可能用在函数参数传递或者返回过程中
static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁
//模拟买票的线程函数
void sellTicket(int index)
{
while (ticketcount >= 1)//锁+双重判断
{
{
lock_guard<mutex>lock(mtx);
if (ticketcount > 0)
{
//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
cout << "窗口：" << index << " 卖出第：" << ticketcount << " 张票！" << endl;
ticketcount--;
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
unique_lock
提供了右值的赋值重载和右值拷贝构造，所以具有资源转移的功能，可以使用在函数调用过程中
在函数调用，参数传递过程中不能使用lock_quard，因为lock_quard不支持赋值和拷贝构造，此时就需要使用unique_lock
void sellTicket(int index)
{
while (ticketcount >= 1)//锁+双重判断
{
unique_lock<std::mutex>lock(mtx);
if (ticketcount > 0)
{
//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
cout << "窗口：" << index << " 卖出第：" << ticketcount << " 张票！" << endl;
ticketcount--;
}
lock.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
4.线程间同步通信机制
生产者—消费者模型：锁+条件变量
#include<iostream>
#include<thread>
#include<list>
#include<mutex>
#include<queue>//C++STL所有的容器都不是线程安全
#include<condition_variable>
using namespace std;
std::mutex mtx;//定义互斥锁，做线程间的互斥操作
std::condition_variable cv; //定义条件变量，做线程间的同步通信操作
//生产者生产一个物品，通知消费者消费一个;消费完了，消费者再通知生产者继续生产物品
class Queue
{
public:
void put(int val)//生产物品
{
//lock_guard<mutex>lock(mtx);
unique_lock<std::mutex>lck(mtx);
while (!que.empty())
{
//que不空，生产者应该通知消费者消费，消费完了再继续消费
//生产者进程应该1.进入阻塞状态，2.并且释放mtx,消费者可以获得锁
cv.wait(lck);//通过条件变量wait进入等待状态，一进入等待状态就会把锁释放
}
que.push(val);
cv.notify_all();//通知其它所有的线程，我生产了一个物品，你们赶紧消费吧
//其它线程得到该通知，就会从等待状态=》阻塞状态=》获取互斥锁才能继续执行
cout << "生产者 生产：" << val << " 号物品" << endl;
}
int get()//消费物品
{
//lock_guard<mutex>lock(mtx);
unique_lock<std::mutex>lck(mtx);
while (que.empty())
{
//que空，消费者应该通知生产者生产
//进程应该1.进入阻塞状态，2.并且释放mtx
cv.wait(lck);//通过条件变量wait进入等待状态，一进入等待状态就会把锁释放
}
int val = que.front();
que.pop();
cv.notify_all();//通知其它线程我消费完了，赶紧生产吧
cout << "消费者 消费：" << val << " 号物品" << endl;
return val;
}
private:
queue<int>que;
};
void producer(Queue* que)
{
for (int i = 1; i <= 10; i++)
{
que->put(i);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
void consumer(Queue* que)
{
for (int i = 1; i <= 10; i++)
{
que->get();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main()
{
Queue que;
thread t1(producer,&que);
thread t2(consumer, &que);
t1.join();
t2.join();
return 0;
}
![软件测试[用例篇]](https://img-blog.csdnimg.cn/ce621eb43873426380294dd1f2d61d8e.png)
