1. 线程库的使用
创建进程
# include<iostream>
# include<thread> //线程库头文件
using namespace std;
void thread_1()
{
cout<<"子线程1"<<endl;
}
int thread_2(int x)
{
cout<<"子线程2"<<endl;
return x;
}
int main()
{
//thread函数创建一个新线程
//first是线程名，括号里第一个参数是函数名，第二个参数是给第一个函数的参数
thread first(thread_1);
thread second(thread_2 , 100);
//若没有下面这两行，程序会报错
//因为若没有下面这两行程序会一直执行下去。
//很有可能在主线程return 0后，子线程还没有继续进行
first.detach();
second.join();
return 0;
}
join和detach
first.join(); //主进程会等待子进程first执行完毕后才继续执行
second.detach(); //主进程不会等待子进程，子线程在后台运行
joinable
判断线程是否可以join，返回bool类型
若对一个不能使用join或detach的线程强行使用join或detach会报一个system_error
所以在一个比较严谨的项目中会先判断一下是否可以使用
int main()
{
thread first(thread_1);
thread second(thread_2 , 100);
first.detach();
//second.detach();
if(second.joinable())
{
second.join();
}
cout<<"主进程";
return 0;
}
2. 互斥锁mutex(互斥量)
如下面的代码
当两个线程都对一个全局变量进行操作时候。若a = 3，两个线程恰好在同一时刻执行a++，那么a会等于4而不是我们下意识想到的5
为了避免这个情况，我们使用互斥锁mutex
当线程遇到lock()
若没上锁，则上锁，其他线程无法访问
若已上锁，则等待解锁
# include<iostream>
# include<thread>
# include<mutex>
using namespace std;
int a = 1;
mutex mtx;
void f()
{
for(int i=1;i<=1000;i++)
{
mtx.lock(); //上锁
a++;
mtx.unlock(); //解锁
}
}
int main()
{
thread t1(f);
thread t2(f);
t1.join();t2.join();
cout<<a;
return 0;
}
3. 原子操作
原子操作就是: 不可中断的一个或者一系列操作, 也就是不会被线程调度机制打断的操作, 运行期间不会有任何的上下文切换(context switch).
讲第二个例子中的a改成atomic
atomic<int> a = 1
void f()
{
for(int i=1;i<=1000;i++)
{
a++;
}
}
int main()
{
thread t1(f);
thread t2(f);
t1.join();t2.join();
cout<<a;
return 0;
}
4. 互斥量死锁
下面的两个线程可能会发生死锁:
f1占有m1资源，f2占有m2资源，然后两个都在等待对方释放资源
mutex m1;
mutex m2;
void f1()
{
for(int i=1;i<=1000;i++)
{
m1.lock();
m2.lock();
m1.unlock();
m2.unlock();
}
}
void f2()
{
for(int i=1;i<=1000;i++)
{
m2.lock();
m1.lock();
m1.unlock();
m2.unlock();
}
}
只需要将f2改成下面这样就好了
void f2()
{
for(int i=1;i<=1000;i++)
{
m1.lock();
m2.lock();
m1.unlock();
m2.unlock();
}
}
5. unique lock
实现自动解锁
int a = 1;
mutex mtx;
void f()
{
for(int i=1;i<=1000;i++)
{
unique_lock<mutex>lg(mtx);
a++;
}
}
int main()
{
thread t1(f);
thread t2(f);
t1.join();t2.join();
cout<<a;
return 0;
}