线程互斥补全和加锁原理

上篇博客，我们用互斥锁完成了互斥的功能。

#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;
}

个人认为这样写最好，看着也舒心。