上篇博客,我们用互斥锁完成了互斥的功能。
#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;
//pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;//全局的锁
void GetTicket(pthread_mutex_t*mutex)
{
while(true)
{
pthread_mutex_lock(mutex);
if(ticket>0)
{
usleep(1000);
printf("get a ticket %d\n",ticket--);
pthread_mutex_unlock(mutex);
}
else
{
pthread_mutex_unlock(mutex);
break;
}
}
}
int main()
{
int num=5;
//vector<Thread<int>> Threads;
pthread_mutex_t mutex;
pthread_mutex_init(&mutex,nullptr);
string name1=GetThreadName();
string name2=GetThreadName();
string name3=GetThreadName();
string name4=GetThreadName();
Thread<pthread_mutex_t*> t1(GetTicket,name1,&mutex);
Thread<pthread_mutex_t*> t2(GetTicket,name2,&mutex);
Thread<pthread_mutex_t*> t3(GetTicket,name3,&mutex);
Thread<pthread_mutex_t*> t4(GetTicket,name4,&mutex);
t1.Start();
t2.Start();
t3.Start();
t4.Start();
t1.Join();
t2.Join();
t3.Join();
t4.Join();
pthread_mutex_destroy(&mutex);
return 0;
}
互斥锁可以是全局的,也可以像上面一样是局部的。
局部锁用pthread_mutex_init()初始化,用pthread_mutex_destroy()销毁。
可将局部锁当参数传入。
#pragma once
#include<pthread.h>
class Mutex
{
public:
Mutex(pthread_mutex_t*lock)
:_lock(lock)
{
}
void Lock()
{
pthread_mutex_lock(_lock);
}
void Unlock()
{
pthread_mutex_unlock(_lock);
}
private:
pthread_mutex_t*_lock;
};
class LockGuard
{
public:
LockGuard(pthread_mutex_t*lock)
:_mutex(lock)
{
_mutex.Lock();
}
~LockGuard()
{
_mutex.Unlock();
}
private:
Mutex _mutex;
};
可以定义上面这样的类,自动析构就等于解锁,非常方便。
我们还可以定义一个包含线程名和锁的类。
#include"test.hpp"
#include"LockGuard.hpp"
using namespace std;
class ThreadData
{
public:
ThreadData(const string &name,pthread_mutex_t*mutex)
:_threadname(name)
,_mutex(mutex)
{}
string _threadname;
pthread_mutex_t*_mutex;
};
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=10000;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;//全局的锁
void GetTicket(ThreadData*td)
{
while(true)
{
pthread_mutex_lock(td->_mutex);
if(ticket>0)
{
usleep(1000);
printf("%s get a ticket %d\n",td->_threadname.c_str(),ticket--);
pthread_mutex_unlock(td->_mutex);
}
else
{
pthread_mutex_unlock(td->_mutex);
break;
}
}
}
int main()
{
int num=5;
//vector<Thread<int>> Threads;
pthread_mutex_t mutex;
pthread_mutex_init(&mutex,nullptr);
string name1=GetThreadName();
string name2=GetThreadName();
string name3=GetThreadName();
string name4=GetThreadName();
ThreadData*td1=new ThreadData(name1,&mutex);
ThreadData*td2=new ThreadData(name2,&mutex);
ThreadData*td3=new ThreadData(name3,&mutex);
ThreadData*td4=new ThreadData(name4,&mutex);
Thread<ThreadData*> t1(GetTicket,name1,td1);
Thread<ThreadData*> t2(GetTicket,name2,td2);
Thread<ThreadData*> t3(GetTicket,name3,td3);
Thread<ThreadData*> t4(GetTicket,name4,td4);
t1.Start();
t2.Start();
t3.Start();
t4.Start();
t1.Join();
t2.Join();
t3.Join();
t4.Join();
pthread_mutex_destroy(&mutex);
delete td1;
delete td2;
delete td3;
delete td4;
return 0;
}
个人认为这样写最好,看着也舒心。
多线程运行时,一份资源,有进程长期无法拥有,造成饥饿问题。
要解决饥饿问题,就要使多线程执行有一定顺序性,也就是线程同步。
话说回来,线程加锁的本质是什么?
大部分体系结构都提供了swap或者exchange指令。
为了方便理解,我们把锁简单理解成包含整形1的一个结构体,在内存单元中。
拿a=0来打比方。
操作时,以一条汇编指令的形式交换寄存器和内存单元中的数据,将寄存器的1和a来交换。
如果这时线程时间片到了,第二个线程过来,也要交换。
可是此时寄存器内已经是0,它交换之后会做判断,如果是大于0,就执行,等于0,就挂起等待
交换到线程硬件上下文的数据,就属于线程自己了。
这个过程就是加锁的过程。
解锁的时候,把1归还就行。
加锁的一般原则:谁加锁,谁解锁。