创建多个线程、互斥量、死琐
创建多个线程
#include<iostream>
#include<thread>
#include<vector>
using namespace std;
void print(int i)
{
cout<<"子线程"<<i<<"开始"<<endl;
cout<<"子线程"<<i<<"结束"<<endl;
}
int main()
{
vector<thread>myThreads;
for(int i=0; i<10; i++)
myThreads.push_back(thread(print,i));
for(auto iter = myThreads.begin(); iter!=myThreads.end(); ++iter)
{
iter->join();
}
cout<<"主线程结束"<<endl;
return 0;
}
由下图可以看出多个线程的执行是不确定的，和操作系统对线程的调度有关。
互斥量 多线程保护共享数据
问题：一个线程往队列内插入数据，另一个线程往队列内取数据，在没有保护措施的情况下，此时的程序是不稳定的。
措施：采取使用互斥的方法保护共享数据
#include<iostream>
#include<thread>
#include<vector>
#include<list>
using namespace std;
class A
{
public:
void input()
{
for(int i=0;i<100000;i++)
{
cout<<"插入元素"<<i<<endl;
msg.push_back(i);
}
}
void output()
{
for(int i=0;i<100000;i++)
{
if(msg.empty())
{
cout<<"队列为空"<<endl;
}
else
{
int command = msg.front();
cout<<"取出元素"<<command<<endl;
msg.pop_front();
}
}
}
private:
list<int>msg;
};
int main()
{
A myobja;
thread insert_thread(&A::input,&myobja);
thread pop_thread(&A::output,&myobja);
insert_thread.join();
pop_thread.join();
cout<< "线程执行完成" <<endl;
return 0;
}
互斥量的用法
1.lock(),unlook()
先lock、共享数据、unlock
成对使用
void input()
{
for(int i=0;i<100000;i++)
{
my_mutex.lock(); //加锁
cout<<"插入元素"<<i<<endl;
msg.push_back(i);
my_mutex.unlock();//解锁
}
}
void output()
{
for(int i=0;i<100000;i++)
{
my_mutex.lock(); //加锁
if(msg.empty())
{
cout<<"队列为空"<<endl;
}
else
{
int command = msg.front();
cout<<"取出元素"<<command<<endl;
msg.pop_front();
}
my_mutex.unlock();//解锁
}
}
2.模板类std::lock_guard
可取代lock、unlock()
void output()
{
lock_guard<mutex>guard(my_mutex);
/*
构造函数里调用look()
析构函数里调用unlook()
缺点：不够灵活
*/
for(int i=0;i<100000;i++)
{
if(msg.empty())
cout<<"队列为空"<<endl;
else
{
int command = msg.front();
cout<<"取出元素"<<command<<endl;
msg.pop_front();
}
}
}
死琐
A等B，B等A或者有一个互等的循环
产生死锁
#include<iostream>
#include<thread>
#include<vector>
#include<list>
#include<mutex>
using namespace std;
class A
{
public:
void input()
{
my_mutex1.lock();
for(int i=0;i<1000000;i++)
i=i;
/*
其他程序
*/
my_mutex2.lock();
my_mutex1.unlock();
my_mutex2.unlock();
}
void output()
{
my_mutex2.lock();
for(int i=0;i<1000000;i++)
i=i;
/*
其他程序
*/
my_mutex1.lock();
my_mutex1.unlock();
my_mutex2.unlock();
}
private:
list<int>msg;
mutex my_mutex1; ///互斥量1
mutex my_mutex2; ///互斥量2
};
int main()
{
A myobja;
thread insert_thread(&A::input,&myobja);
thread pop_thread(&A::output,&myobja);
insert_thread.join();
pop_thread.join();
cout<< "线程执行完成" <<endl;
return 0;
}
上面程序进程一把一号锁锁住等待二号锁
上面程序进程二把二号锁锁住等待一号锁
产生互相等待
解决方案，保持调用顺序一致理论上不会死锁
std::lock()
一次锁住两个或以上的互斥量
如果失败则一个都不锁，要么全都锁住。从而避免死琐的问题
std::lock_guard的std::adopt_lock参数
lock_guard (mutex_type& m, adopt_lock_t tag);
lock_guard 对象管理 Mutex 对象 m，与 locking 初始化(1) 不同的是， Mutex 对象 m 已被当前线程锁住。
lock_guard<mutex>guard(my_mutex1,std::adopt_lock_t);
std::unique_lock
std::unique_lock 的构造函数的数目相对来说比 std::lock_guard 多，其中一方面也是因为 std::unique_lock 更加灵活，从而在构造 std::unique_lock 对象时可以接受额外的参数。
| 参数 | 功能 |
|---|---|
| 默认构造函数 | 新创建的 unique_lock 对象不管理任何 Mutex 对象。 |
| locking | 新创建的 unique_lock 对象管理 Mutex 对象 m，并尝试调用 m.lock() 对 Mutex 对象进行上锁，如果此时另外某个 unique_lock 对象已经管理了该 Mutex 对象 m，则当前线程将会被阻塞。 |
| try-locking | 新创建的 unique_lock 对象管理 Mutex 对象 m，并尝试调用 m.try_lock() 对 Mutex 对象进行上锁，但如果上锁不成功，并不会阻塞当前线程。 |
| deferred | 新创建的 unique_lock 对象管理 Mutex 对象 m，但是在初始化的时候并不锁住 Mutex 对象。 m 应该是一个没有当前线程锁住的 Mutex 对象。 |
| adopting | 新创建的 unique_lock 对象管理 Mutex 对象 m， m 应该是一个已经被当前线程锁住的 Mutex 对象。(并且当前新创建的 unique_lock 对象拥有对锁(Lock)的所有权)。 |
| locking一段时间(duration) | 新创建的 unique_lock 对象管理 Mutex 对象 m，并试图通过调用 m.try_lock_for(rel_time) 来锁住 Mutex 对象一段时间(rel_time)。 |
| locking直到某个时间点(time point) | 新创建的 unique_lock 对象管理 Mutex 对象m，并试图通过调用 m.try_lock_until(abs_time) 来在某个时间点(abs_time)之前锁住 Mutex 对象。 |
| 拷贝构造 [被禁用] | unique_lock 对象不能被拷贝构造。 |
| 移动(move)构造 | 新创建的 unique_lock 对象获得了由 x 所管理的 Mutex 对象的所有权(包括当前 Mutex 的状态)。调用 move 构造之后， x 对象如同通过默认构造函数所创建的，就不再管理任何 Mutex 对象了。 |
综上所述，由 (2) 和 (5) 创建的 unique_lock 对象通常拥有 Mutex 对象的锁。而通过 (1) 和 (4) 创建的则不会拥有锁。通过 (3)，(6) 和 (7) 创建的 unique_lock 对象，则在 lock 成功时获得锁。
搬砖啦
