标准线程库,c++11引入,包含原子操作库、互斥锁、条件变量。。。
一、线程库
创建线程的四种方法:
1. 通过全局函数创建线程
线程类的构造函数是变参构造函数,第一个参数是线程函数,后面的参数为线程函数的参数(参数通过值传递方式,若要引用传递须加std::ref())。
thread t1 (counter, 1, 6); //void counter(int, int);
2. 通过函数对象创建线程
//class Counter 实现 operator()
1) thread t1{Counter(1, 20)}; //c++统一推荐方法
2) Counter c(1, 20);
thread t2(c);
3) thread t3(Counter(1,20));
比较第一种和第三种构造方式,如果函数对象的构造函数不需要任何参数。 thread t3(Counter());是不行的,因为编译器会认为你在声明一个函数,函数名为t3,此时只能用第一种构造方式。
3. 通过lambda表达式创建线程
4. 通过成员函数创建线程
// class Counter c();
thread t{&Counter::process, &c};
一般常见的是一个类自己创建一个后台处理线程:thread t{&Counter::process, this};
线程本地存储 thread_local
thread_local int n;
n作为线程参数传递给线程,那么每个线程有一个n的副本,在线程整个生命周期中存在,且只初始化一次,如同static局部变量。
二、原子操作库
多线程编程经常需要操作共享的内存,在读/写过程中会导致竞争条件。
例如:
int counter = 0;
............
++counter; //因为++counter不时原子操作,多个线程中出现此操作时不是线程安全的。
应该用:
atomic
............
++counter; //此时多个线程执行++counter是一个原子操作,是线程安全的。
例:
void func( std::atomic<int>& counter)
{
for( int i=0; i<1000; ++i )
++counter;
}
int main()
{
std::atomic<int> counter(0);
std::vector<std::thread> threads;
for( int i=0; i<10; ++i )
//线程参数总是值传递,若要传递引用,须加std::ref()。(头文件<functional>中)
threads.push_back( std::thread{ func, std::ref(counter)} );
for( auto& t : threads )
t.join(); //调用join,如果线程未结束,则main函数阻塞于此。
std::count<<"Result="<<counter<<std::endl;
return 0;
}
/*join的调用会导致调用线程阻塞于此,若不希望调用线程阻塞,但又想知道被调线程是否结束,应当用其它方式,例如消息...*/
三、互斥
编写多线程必须分外留意操作顺序,如果无法避免线程共享数据,则必须提供同步机制,保证一次只有一个线程能更改数据。使用互斥解决竞争条件,可能导致死锁。
1. 互斥体类
1) 非定时互斥体类 std::mutex std::recursive_mutex
lock() : 尝试获取锁,并且阻塞直到获取锁。
try_lock() : 尝试获取锁,并立即返回,成功获取返回true,否则false。
unlock() : 释放锁。
mutex与recursive_mutex的区别在于,前者已经获得所后不得再尝试获取,这会死锁,后者能递归获取,注意释放次数应与获取次数相等。
2) 定时互斥锁类 std::timed_mutex std::recursive_timed_mutex
lock() , try_lock() , unlock()
try_lock_for(rel_time) : 指定相对时间内获得返回true, 超时返回false。
try_lock_until(abs_time) : 指定系统绝对时间内获得返回true, 超时返回false。
timed_mutex与recursive_timed_mutex区别同上。
2. 锁类
锁类是一个包装器,析构函数会自动释放关联的互斥体。
1) 简单锁 std::lock_guard
其构造函数会要求获得互斥体,并阻塞直到获得锁。
2) 复杂锁 std::unique_lock
explict unique_lock( mutex_type& m); //阻塞直到获得锁。
unique_lock(mutex_type& m, defer_lock_t) noexcept; //保存一个互斥体引用,不会立即尝试获得锁。锁可以在以后获得。
unique_lock(mutex_type& m, try_to_lock_t); //尝试获得引用的互斥锁,未能获得也不阻塞。
unique_lock(mutex_type& m, adopt_lock_t); //该锁假定线程获得引用的互斥锁,并负责管理这个锁。
template<class Clock, class Duration>
unique_lock(mutex& m, const chrono::time_point<Clock, Duration>& abs_time); //尝试获取该锁,直到超过给定的绝对时间。
template<class Rep, class Period>
unique_lock(mutex& m, const chrono::duration<Rep, Period>& rel_time); //尝试获取该锁,直到超过给定的相对时间。
unique_lock类还支持lock(), try_lock(), try_lock_for(), try_lock_until()等方法。
通过owns_lock()查看是否获得了这个锁;也可以用if对unique_lock对象直接判断是否获得锁,因为它定义了bool()运算符。
3. 获得多个互斥体对象上的锁
1) 泛型lock可变参数模板函数
template
void lock(L1&, L2&, L3&...);
按顺序锁定,如果一个互斥体抛出异常,会对已获得的锁unlock。
2) 泛型try_lock
template
int try_lock(L1&, L2&, L3&...);
通过顺序调用互斥体对象的try_lock,成功返回-1,失败返回从0开始的位置索引,并对已获得的锁unlock。
参数顺序每次应保持一致, 否则易死锁。
4. std::call_once std::once_flag
保证call_once调度的函数只被执行一次。
5. 实例:
// 1. 简单锁
mutex mMutex;
lock_guard<mutex> mLock(mMutex);
// 2. 定时锁
timed_mutex mTimeMutex;
unique_lock<timed_mutex> mLock(mTimedMutex, chrono::milliseconds(200));
// 3. 泛型
mutex mut1;
mutex mut2;
unique_lock<mutex> lock1(mut1, defer_lock_t());
unique_lock<mutex> lock2(mut2, defer_lock_t());
lock(lock1, lock2);
// 4. 双重检查锁定算法 (代替call_once的用法)
class MyClass
{
public:
void init() { p = new int(0); cout<<"Init"<<endl;}
private:
int *p;
}
MyClass var;
bool initialized = false;
mutex mut;
void func()
{
if( ! initialized) //一次检查
{
unique_lock<mutex> lock1(mut);
if( ! initialized) //两次检查
{
var.init();
initialized = true;
}
}
cout<<"OK"<<endl;
}
//两次检查initialized。获得锁之前和获得锁之后,确保init只调用一次。
四、条件变量
1. std::condition_variable 只能等待unique_lock的条件变量
notify_one(); //唤醒等待这个条件变量的线程之一
notify_all(); //唤醒所有等待这个条件变量的线程
// 1)前提是已经获得lk的锁
// 2)调用wait会unlock lk,然后等待
// 3)当被唤醒后 lock lk
wait( unique_lock<mutex>& lk);
wait_for(unique_lock<mutex>& lk, const chrono::duration<Rep,Period>& rel_time);
wait_until(unique_lock<mutex>&lk, const chrono::time_point<Clock,Duration>& abs_time);
2. std::condition_variable_any 支持任何类型的Lock类
3.
//例:向队列中加入数据,当队列不为空时,后台线程被唤醒处理数据
std::queue<std::string> mQueue;
std::mutex mMutex;
std::condition_variable mCondVar;
//向队列加入数据的线程
unique_lock<mutex> lock(mMutex);
mQueue.push( data);
mCondVar.notify_all();
//后台处理数据的线程
unique_lock<mutex> lock(mMutex);
while(true)
{
//1.先释放lock 2.然后等待被唤醒 3.被唤醒后等待获取lock
mCondVar.wait(lock);
// process...
}
五、 future
promise/future模型方便获取线程返回的结果、线程间通信、处理异常
原文链接: https://www.cnblogs.com/songcf/archive/2013/06/15/3136034.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/92210
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!