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
#include
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
#include
#include
using namespace std;static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁//模拟买票的线程函数
void sellTicket(int index)
{mtx.lock();//此种加锁相当于只有一个窗口在买票while (ticketcount >= 1)//锁+双重判断{if (ticketcount > 0){//临界区代码段-》原子操作=》线程间互斥操作了=》mutexcout << "窗口：" << index << "  卖出第：" << ticketcount << " 张票！" << endl;ticketcount--;}std::this_thread::sleep_for(std::chrono::milliseconds(100));}mtx.unlock();
}
int main()
{listtlist;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
#include
#include
using namespace std;static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁//模拟买票的线程函数
void sellTicket(int index)
{while (ticketcount >= 1)//锁+双重判断{mtx.lock();if (ticketcount > 0){//临界区代码段-》原子操作=》线程间互斥操作了=》mutexcout << "窗口：" << 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_guardlock(mtx);if (ticketcount > 0){//临界区代码段-》原子操作=》线程间互斥操作了=》mutexcout << "窗口：" << 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_locklock(mtx);if (ticketcount > 0){//临界区代码段-》原子操作=》线程间互斥操作了=》mutexcout << "窗口：" << index << "  卖出第：" << ticketcount << " 张票！" << endl;ticketcount--;}lock.unlock();std::this_thread::sleep_for(std::chrono::milliseconds(100));}
}

4.线程间同步通信机制

生产者—消费者模型：锁+条件变量

#include
#include
#include
#include
#include//C++STL所有的容器都不是线程安全
#include
using namespace std;std::mutex mtx;//定义互斥锁，做线程间的互斥操作
std::condition_variable cv; //定义条件变量，做线程间的同步通信操作//生产者生产一个物品，通知消费者消费一个;消费完了，消费者再通知生产者继续生产物品
class Queue
{
public:void put(int val)//生产物品{//lock_guardlock(mtx);unique_locklck(mtx);while (!que.empty()){//que不空，生产者应该通知消费者消费，消费完了再继续消费//生产者进程应该1.进入阻塞状态，2.并且释放mtx,消费者可以获得锁cv.wait(lck);//通过条件变量wait进入等待状态，一进入等待状态就会把锁释放}que.push(val);cv.notify_all();//通知其它所有的线程，我生产了一个物品，你们赶紧消费吧//其它线程得到该通知，就会从等待状态=》阻塞状态=》获取互斥锁才能继续执行cout << "生产者 生产：" << val << " 号物品" << endl;}int get()//消费物品{//lock_guardlock(mtx);unique_locklck(mtx);while (que.empty()){//que空，消费者应该通知生产者生产//进程应该1.进入阻塞状态，2.并且释放mtxcv.wait(lck);//通过条件变量wait进入等待状态，一进入等待状态就会把锁释放}int val = que.front();que.pop();cv.notify_all();//通知其它线程我消费完了，赶紧生产吧cout << "消费者 消费：" << val << " 号物品" << endl;return val;}
private:queueque;
};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;
}