我们实现一个简单的多线程抢票程序。
#include<iostream>
#include<thread>
#include<unistd.h>
#include<functional>
#include<vector>
using namespace std;
template<class T>
using func_t=function<void(T)>;//返回值为void,参数为T
template<class T>
class Thread
{
public:
Thread(func_t<T> func,const string&name,T data)
:_tid(0)
,_func(func)
,_threadname(name)
,isrunning(false)
,_data(data)
{
}
static void*ThreadRoutine(void*args)
{
//(void)args;//仅仅是为了防止编译器有告警
Thread*ts=static_cast<Thread*>(args);
ts->_func(ts->_data);
return nullptr;
}
bool Start()
{
int n=pthread_create(&_tid,nullptr,ThreadRoutine,this);
if(n==0)
{
isrunning=true;
return true;
}
return false;
}
bool Join()
{
if(!isrunning) return true;
int n=pthread_join(_tid,nullptr);
if(n==0)
{
isrunning=false;
return true;
}
return false;
}
string GetThreadName()
{
return _threadname;
}
bool IsRunning()
{
return isrunning;
}
~Thread()
{}
private:
pthread_t _tid;
string _threadname;
bool isrunning;
func_t<T> _func;
T _data;
};
#include"test.hpp"
using namespace std;
string GetThreadName()
{
static int number=1;
char name[64];
snprintf(name,sizeof name,"Thread - %d",number++);
return name;
}
void print(int num)
{
while(num--)
{
cout<<"hello world"<<num<<endl;
sleep(1);
}
}
int ticket=100;
void GetTicket(string name)
{
while(true)
{
if(ticket>0)
{
usleep(1000);
printf("%s get a ticket %d\n",name.c_str(),ticket--);
}
else
break;
}
}
int main()
{
int num=5;
//vector<Thread<int>> Threads;
string name1=GetThreadName();
string name2=GetThreadName();
string name3=GetThreadName();
string name4=GetThreadName();
Thread<string> t1(GetTicket,name1,name1);
Thread<string> t2(GetTicket,name2,name2);
Thread<string> t3(GetTicket,name3,name3);
Thread<string> t4(GetTicket,name4,name4);
t1.Start();
t2.Start();
t3.Start();
t4.Start();
t1.Join();
t2.Join();
t3.Join();
t4.Join();
// while(num--)
// {
// Threads.push_back(Thread<int>(print,GetThreadName(),10));
// }
// for(auto &t:Threads)
// {
// cout<<t.GetThreadName()<<" is running? "<<t.IsRunning()<<endl;
// }
// for(auto&t:Threads)
// {
// t.Start();
// }
// for(auto &t:Threads)
// {
// cout<<t.GetThreadName()<<" is running? "<<t.IsRunning()<<endl;
// }
// for(auto &t:Threads)
// {
// t.Join();
// }
// Thread t(print,GetThreadName());
// cout<<"Is thread running?"<<t.IsRunning()<<endl;
// t.Start();
// cout<<"Is thread running?"<<t.IsRunning()<<endl;
// t.Join();
return 0;
}
神奇的事情发生了，我们明明添加了ticket大于0时才能抢票的限制条件，
为什么最后ticket会小于0呢？
判断ticket是否大于0也是访问公共资源，并不是原子的。
可能多个线程同时通过判断，但是在执行ticket--的时候又因时间片变成串行。
最终导致ticket小于0。
数据在内存中，本质是被线程共享的。
数据被读取到寄存器中，本质变成了线程的上下文，属于线程的私有数据。
我们把任何一个时刻，只允许一个线程访问的共享资源叫做临界资源。
进程中访问临界资源的代码就叫做临界区。
任何时刻，互斥保证只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用。
原子性：不会被任何调度打断的操作，只有两态，完成或未完成。
我们认为，一条汇编语句就是原子的。
而像a++这样的C语言指令，实际上会被转化成三条汇编指令。
首先把a从内存拷贝到CPU的寄存器，字CPU中完成++操作，再返回内存，不是原子的。
为了不让上面的情况发生，需要加锁。
如图，加锁后，问题解决,不过速度变慢了。
申请锁本身是原子的，有宝马。这块的原理下一篇博客会介绍。
根据互斥的定义，任何一个时刻只允许一个线程申请锁成功，申请失败的进程在mutex阻塞，本质就是等待。
可能大家会认为，当线程进入锁，执行锁内代码，这是如果发生切换，还是会产生同样的错误。
其实这次不一样了，因为就算时间片到了，发生线程切换，被切换到的线程也没办法访问锁。
它在申请锁那里阻塞着呢。。。
这就保证了临界区的原子性。
就相当于上的线程的密码锁，专属的。
