线程互斥补全和加锁原理

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

#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归还就行。

加锁的一般原则：谁加锁，谁解锁。