(目录)
一、条件变量
条件变量是一种线程同步机制。当条件不满足时,相关线程被一直阻塞,直到某种条件出现,这些线程才会被唤醒。 C++11的条件变量提供了两个类:
- condition_variable:只支持与普通mutex搭配,效率更高。
- condition_variable_any:是一种通用的条件变量,可以与任意mutex搭配(包括用户自定义的锁类型)。
生产消费问题的经典案例:
#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
#include <thread> //线程类头文件。
#include <mutex> //互斤锁类的头文件
#include <deque> //deque容器的头文件。
#include <queue> //queue容器的头文件。
#include <condition_variable> //条件变量的头文件。
using namespace std;
class AA {
mutex m_mutex;
condition_variable m_cond;
queue<string, deque<string>> m_q;
public:
void incache(int num) { // 生产数据,num指定数据的个数
lock_guard < mutex > lock(m_mutex); // 申请加锁。离开作用域的时候lock_guard会自动释放锁。
for (int i = 0; i < num; ++i) {
static int bh = 1; // 超女编号
string message = to_string(bh++) + " data";
m_q.push(message);
cout << "producting thread: " << this_thread::get_id() << ", "
<< message << endl;
}
// 唤醒一个被当前条件变量阻塞的消费线程
//m_cond.notify_one();
// 唤醒全部被当前条件变量阻塞的消费线程:让所有消费者线程都进来抢
m_cond.notify_all();
}
void outchache() { // 消费数据
while (true) {
string message;
{
//cout << "consuming thread: " << this_thread::get_id() << ", " << "申请加锁" << endl;
unique_lock < mutex > lock(m_mutex); // lock互斥锁在出作用域的时候也会释放
//cout << "consuming thread: " << this_thread::get_id() << ", " << "加锁成功" << endl;
// 挡住线程
//this_thread::sleep_for(chrono::hours(1));
// 存在条件变量虚假唤醒:消费者线程被唤醒后,缓存队列中没有数据。
// 被虚假唤醒的消费者线程要通过while反复判断,然后再进入wait()。使用if语句达不到效果(错过时点)。
while (m_q.empty())
// 1. 把互斥锁m_mutex解锁 2. 阻塞,等待被唤醒。 3. 给互斥锁m_mutex加锁。
m_cond.wait(lock);
/**
* c++11为我们提供了与上述while循环等效的解决方案:
* m_cond.wait(lock, [this]{return !m_q.empty();});
*/
message = m_q.front();
m_q.pop();
cout << "consuming thread: " << this_thread::get_id() << ", "
<< message << endl;
//lock.unlock(); 手工解锁
}
// 模拟消费出队数据
this_thread::sleep_for(chrono::milliseconds(1));
}
}
};
int main(int argc, const char **argv) {
const int max = 8;
srand(time(nullptr));
AA aa;
// 定义消费线程
thread t1(&AA::outchache, &aa);
thread t2(&AA::outchache, &aa);
thread t3(&AA::outchache, &aa);
this_thread::sleep_for(chrono::seconds(rand() % max));
// 主线程生产数据
aa.incache(6);
// 主线程生产数据
this_thread::sleep_for(chrono::seconds(rand() % max));
aa.incache(8);
// 回收线程资源
t1.join();
t2.join();
t3.join();
return 0;
}
普通的互斤锁为什么要转换成unique_lock之后才能用于条件变量呢?
unique_lock < mutex > lock(m_mutex);
template <class Mutex> class unique_lock 是模板类,模板参数为互斥锁类型。 unique_lock和lock_guard都是管理锁的辅助类,都是RAII风格(在构造时获得锁,在析构时释放锁)。它们的区别在于:为了配合condition_variable,unique_lock还有lock()和unlock()成员函数——而lock_guard没有。
二、wait()所做的工作
- 把互斥锁解锁
- 阻塞,等待被唤醒。
- 给互斥锁加锁。 如果wait()返回了,一定申请到了互斥锁。
三、原子类型atomic
c++11提供了atomic<T>模板类(结构体),用于支持原子类型,模板参数可以是bool、char、int、long、long long、指针类型(不支持浮点类型和自定义数据类型)——只支持整数。原子操作由CPU指令提供支持,它的性能比锁和消息传递更高,并且,不需要程序员处理加锁和释放锁的问题,支持修改、读取、交换、比较并交换等操作。
头文件:#include <atomic>
#include <iostream>
#include <thread> //线程类头文件。
#include <atomic>
using namespace std;
// 只支持整数
atomic<int> ga { 0 };
//atomic<int> ga(0);
//atomic_int ga(0);
void func() {
for (int i = 0; i < 1000000; ++i)
ga++;
}
int main(int argc, const char **argv) {
thread t1(func);
thread t2(func);
t1.join();
t2.join();
cout << "ga = " << ga << endl;
return 0;
}
另一个演示
#include <iostream>
#include <thread> //线程类头文件。
#include <atomic>
using namespace std;
int main(int argc, const char **argv) {
atomic<int> a(3); // 转换函数
cout << "a = " << a.load() << endl; // 读取原子变量a的值
a.store(8); // 把8存储到原子变量中
cout << "a = " << a.load() << endl; // 读取原子变量a的值
int old;
//用于存放原值
old = a.fetch_add(5); //把原子变量a的值与5相加,返回原值
cout << "old = " << old << ", a =" << a.load() << endl; // old=8, a=13
old = a.fetch_sub(2); //把原子变量a的值减2,返回原值。
cout << "old = " << old << ", a =" << a.load() << endl; // old=13, a=11
atomic<int> ii(3); //原子变量
int expect = 3; //期待值
int val = 5; //打算存入原子变量的值
//比较原子变量的值和预期值expect
//如果当两个值相等,把val存储到原子变量中
//小如果当两个值不相等,用原子变量的值更新预期值
//执行存储操作时返回true,否则返回false。
bool bret = ii.compare_exchange_strong(expect, val);
cout << "bret=" << bret << endl;
cout << "ii=" << ii << endl;
cout << "expect=" << expect << endl;
return 0;
}
比较原子变量的值和预期值expect,如果当两个值相等,把val存储到原子变量中,函数返回true;如果当两个值不相等,用原子变量的值更新预期值,函数返回false。CAS指令。
T compare_exchange_strong(T &expect,const T val)noexcept;
- atomic<T> 模板类重载了整数操作的各种运算符。
- atomic<T> 模板类的模板参数支持指针,但不表示它所指向的对象是原子类型。
- 原子整型可以用作计数器,布尔型可以用作开关。
- CAS指令是实现无锁队列的基础。
四、线程函数的多种形式
#include <iostream>
#include <thread> //线程类头文件。
using namespace std;
void f() {
cout << "void f() .." << endl;
}
struct F {
F(int a) :
x(a) {
}
void operator()() {
cout << "F::operator() " << x << endl;
}
void f() {
cout << "member f " << x << endl;
}
int x;
};
int main(int argc, const char **argv) {
thread t1(f);
thread t2(F(20));
thread t3([] {
cout << "noname func" << endl;
});
F a(10);
thread t4(F::f, &a); // 相当于有参的函数
t1.join();
t2.join();
t3.join();
t4.join();
return 0;
}
五、引用的传递
引用的传递有点不同,如果不加处理,编译器无法判断我们是想传引用,还是想传值。 可以这样处理:
#include <iostream>
#include <thread> //线程类头文件。
using namespace std;
void f(int &x) {
this_thread::sleep_for(chrono::seconds(1));
cout << x << endl;
}
int main(int argc, const char **argv) {
int x = 5;
thread td(f, std::ref(x));
x = 20;
td.join();
return 0;
}
六、再议线程互斥
用锁原则总结:
- 共享对象的操作要考虑加锁
- 锁的颗粒度越小越好
- 尽量不要用 mutex 裸装上阵,危险处处!
- 如无特殊需要,用 lock_guard 即可
- 如控制上满足不了要求(一般是粒度),改用unique_lock
七、局限于线程中的“全局变量” thread_local
#include <iostream>
#include <thread>
using namespace std;
thread_local int x = 0;
void g() {
x++;
cout << x << endl;
}
void f() {
for (int i = 0; i < 10; i++)
g();
}
int main(int argc, const char **argv) {
thread t1(f);
thread t2(f);
t1.join();
t2.join();
cout << x << endl;
return 0;
}
每个thread_local变量在线程创建的时候创建,然后对本线程而言,相当于全局变量;当线程销毁的时候,会同时销毁当初创建的这个thread_local变量。thread_local变量不是静态存储的。
七、c++11 future & promise
#include <iostream>
#include <thread>
#include <future>
#include <chrono>
using namespace std;
int func(int x, int y) {
this_thread::sleep_for(chrono::seconds(5));
return x * 100 + y;
}
int main(int argc, const char **argv) {
// launch::async 表示创建新线程;
// launch::deferred 表示延迟处理,同步调用,不创建新线程;
// launch::async | launch::deferred 表示系统自己看着办
future<int> res = async(launch::async, func, 3, 6); // 如果线程中抛出了异常,可以在主线程中抓住,
cout << "do something else ..." << endl;
int r = res.get(); // func计算未完成就阻塞在这里,直到func返回结果。
cout << r << endl;
return 0;
}
标签:变量,int,lock,c++,线程,初探,mutex,include
From: https://blog.51cto.com/cerana/7114813