一. 常用知识点总结
- 关键字和语法
- auto：可以根据右值，推导右值的类型，然后左边变量的类型也就知道了
- nullptr：给指针专用（能够和整数进行区别）
- foreach：可以遍历数组，容器等
for(Type val:container)
{
cout<<val<<" ";
}
- 右值引用：move移动语义函数和forward类型完美转发
- 模板的一个新特性：typename… A 表示可变参（类型参数）
- 绑定器和函数对象
- function：函数对象
- bind：绑定器
- lambda表达式
function,bind和lambda详细讲解
- 智能指针
智能指针可以自动管理资源，以防止代码不可预期的执行导致资源泄露、资源未释放。
shared_ptr和weak_ptr
- 容器
unordered_set和unordered_map：哈希表
array：数组，无法进行扩容
forward_list：前向链表
- C++语言级别支持多线程编程
增强了可移植性
二. 多线程类thread
C++语言层面的thread，其底层还是调用操作系统对象的多线程函数，例如windows下调用createthread，linux下调用的是pthread_create。语言层面的支持就做到了跨平台运行。
1. 怎么创建启动一个新线程？
std::thread定义一个线程对象，传入线程所需要的线程函数和参数，线程自动开启
2. 子线程如何结束？
子线程函数运行完成，线程就结束了
3. 主线程如何处理子线程
t.join()：等待t线程结束，当前线程继续往下运行
t.detach()：把t线程设置为分离线程，主线程结束，整个进程结束，所有子线程就自动结束
示例代码：
#include<iostream>
#include<thread>
using namespace std;
void threadHandle(int time)
{
std::this_thread::sleep_for(std::chrono::seconds(time));
cout << "hello thread!" << endl;
}
int main()
{
std::thread t1(threadHandle, 2);
t1.detach();
cout << "main thread done" << endl;
return 0;
}
三. 线程互斥锁mutex
多线程互斥
竞态条件：多线程程序执行的结果是一致的，不会随着CPU对线程不同的调用顺序，而产生不同运行结果
#include<iostream>
#include<thread>
#include<list>
using namespace std;
int ticketCount = 100;
void sellTicket(int index)
{
while (ticketCount > 0)
{
cout << ticketCount << endl;
ticketCount--;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main()
{
list<std::thread> tlist;
for (int i = 1; i <= 3; ++i)
{
tlist.push_back(std::thread(sellTicket, i));
}
for (std::thread& t : tlist)
{
t.join();
}
cout << "所有窗口卖票结束" << endl;
return 0;
}
上面这段代码，启动三个线程模拟三个窗口同时卖票，总票数是100张，由于整数的–操作不是线程安全的操作，因为多线程环境中，需要通过加互斥锁做到线程安全。
代码如下：
#include<iostream>
#include<thread>
#include<list>
#include<mutex>
using namespace std;
int ticketCount = 100;
std::mutex mtx;
void sellTicket(int index)
{
while (ticketCount > 0)
{
mtx.lock();
if(ticketCount>0)
{
cout << "窗口"<<index<<"卖出第"<<ticketCount <<"张票" << endl;
ticketCount--;
}
mtx.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main()
{
list<std::thread> tlist;
for (int i = 1; i <= 3; ++i)
{
tlist.push_back(std::thread(sellTicket, i));
}
for (std::thread& t : tlist)
{
t.join();
}
cout << "所有窗口卖票结束" << endl;
return 0;
}
lock_guard自动释放锁
由于互斥锁需要手动lock()，unlock()，可能导致unlock()调用不到。所以采用lock_guard()封装mutex，保证所以线程都能释放锁，防止死锁的发生。（就像智能指针一样，利用栈上的对象出作用域必须析构对象来释放空间）
void sellTicket(int index)
{
while (ticketCount > 0)
{
lock_guard<std::mutex> lock(mtx);
if (ticketCount > 0)
{
cout << "窗口" << index << "卖出第" << ticketCount << "张票" << endl;
ticketCount--;
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
四. 线程间同步通信—生产者消费者模型
生产者-消费者模型：生产者线程生产出产品以后，会通知消费者线程去消费产品；如果消费者线程去消费产品，发现还没有产品生产出来，它需要通过线程生产出产品以后，消费者线程才能继续往下执行。使用条件变量和互斥锁实现的。
#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<queue>
using namespace std;
std::mutex mtx;
std::condition_variable cv;
class Queue
{
public:
void put(int val)
{
unique_lock<std::mutex> lck(mtx);
while (!que.empty())
{
cv.wait(lck);
}
que.push(val);
cv.notify_all();
cout << "生产者 生产" << val << "号物品" << endl;
}
int get()
{
unique_lock<std::mutex> lck(mtx);
while (que.empty())
{
cv.wait(lck);
}
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 = 0; i <= 10; i++)
{
que->put(i);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
void consumer(Queue* que)
{
for (int i = 0; i <= 10; i++)
{
que->get();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main()
{
Queue que;
std::thread t1(producer,&que);
std::thread t2(consumer,&que);
t1.join();
t2.join();
}
五. lock_guard和unique_lock
mutex mtx;
int main(){
mtx.lock();
mtx.unlock();
}
写法类似于裸指针，可能出现获取但没释放的情况。
lock_guard类似于智能指针，构造函数获取锁，析构函数释放锁。
部分源码如下，禁止拷贝构造和赋值
lock_guard(const lock_guard&) = delete;
lock_guard& operator=(const lock_guard&) = delete;
用法：
lock_guard<std::thread> guard(mtx);
lock_guard不可能用在函数参数传递或者返回过程中，因为这些会用到拷贝构造或赋值函数，但lock_guard不能进行拷贝构造和赋值，只能用在简单的加锁和解锁临界区代码段中。
同样是构造函数获取锁，析构函数释放锁。
删除了左值的拷贝构造和等号运算符重载，提供了右值的拷贝构造和等号运算符重载，unique_lock可用于函数的参数传递以及返回过程中。
底层也提供了互斥锁的lock()和unlock()方法
用法如下:
unique_lock<std::thread> lck(mtx);
unique_lock完全可以替代lock_guard，就像unique_ptr完全可以替代scoped_ptr一样。只是多了个条件变量的功能（线程同步通信）
通常和unique_lock搭配使用
unique_lock<mutex> lck(mtx);
cv.wait(lck);
cv.notify_all();
六. 基于CAS操作的atomic原子类型
互斥锁是比较重的，适合于临界区代码做的事情稍稍复杂的情形。而++，–操作使用CAS原子特性就足够了，是无锁操作。
CAS并不是不加锁，只不过加锁解锁不在软件层面。cpu和内存之间通信通过系统总线进行。CAS通过exchange/swap指令，相当于给总线加锁，当一个线程在做cpu和内存交换，不允许其他线程再使用总线，有助于提高多线程效率。
volatile：防止多线程对共享变量进行缓存，访问的都是原始内存变量值。
不加volatile的话，每个线程都会拷贝一份自己的线程栈上的变量，带到CPU的缓存，这样效率较高，但也可能出错。
#include <iostream>
#include <thread>
#include <list>
#include <atomic>
using namespace std;
volatile atomic_bool is_ready = false;
volatile atomic_int cnt = 0;
void task() {
if (!is_ready) {
this_thread::yield();
}
for (int i = 0; i < 100; i++) {
cnt++;
}
}
int main(){
list<thread> tlist;
for (int i = 0; i < 10; i++) {
tlist.push_back(thread(task));
}
this_thread::sleep_for(chrono::seconds(2));
is_ready = true;
for (thread& t : tlist) {
t.join();
}
cout << cnt << endl;
return 0;
}
|