muduo源码解析5-mutex相关类

mutexlock和mutexlockguard

class mutexlock:noncopyable
{
}；

class mutexlockguard:noncopyable
{
}；

作用：

本文仅实现了最基本的mutexlock和mutexlockguard，放弃了muduo源码中的一大堆宏定义，为求精简可读性高。

成员变量mutexlock：

private:
    pthread_mutex_t m_mutex;
    pid_t m_holder;

m_mutex为要操作的mutex。主要有init,destroy,lock,unlock操作。

m_holder代表当前该m_mutex被哪一个线程所持有，m_holder>0表示持有该锁的线程ID，否则表示该锁可用。

成员函数mutexlock：

public:
    mutexlock():m_holder(0)
    {
        pthread_mutex_init(&m_mutex,NULL);
    }
    ~mutexlock()
    {
        assert(m_holder==0);
        pthread_mutex_destroy(&m_mutex);
    }
    //该锁是否被当前线程所持有
　 bool isLockedByThisThread() const
    {
        return m_holder==currentthread::tid();
    }

    void assertLocked() const
    {
        assert(isLockedByThisThread());
    }
    //加锁后设置m_holder为当前线程ID
    void lock()
    {
        pthread_mutex_lock(&m_mutex);
        assignHolder();
    }
    //解锁前先让当前m_holder设置为0
    void unlock()
    {
        unassignHolder();
        pthread_mutex_unlock(&m_mutex);

    }
    pthread_mutex_t* getPthreadMutex()
    {
        return &m_mutex;
    }


private:
    friend class Condition;
    //一个易于分配m_holder的内部类，仅含有一个mutexlock成员用于分配与释放
    class UnassignGuard:noncopyable
    {
    public:
        explicit UnassignGuard(mutexlock& owner):m_owner(owner)
        {
            m_owner.unassignHolder();
        }
        ~UnassignGuard()
        {
            m_owner.assignHolder();
        }
    private:
        mutexlock& m_owner;
    };
    //设置m_holder为当前线程ID
    void assignHolder()
    {
        m_holder=currentthread::tid();
    }
    //清零m_holder
    void unassignHolder()
    {
        m_holder=0;
    }

mutexlock重要就是四个操作,mutex的init,destroy,lock,unlock
有两个数据成员pthread_mutex_t和m_holder
mutex就是上述四个操作,m_holder表示此mutex被哪一个线程ID所拥有,为0表示没被拥有
lock时m_holder为持有此锁的线程ID,unlock时m_holder为0

还可以判断当前mutex是否被当前线程给锁住,isLockedByThisThread()

成员变量mutexlockguard：

private:
    mutexlock& m_mutex;

内部仅有一个mutexlock变量用于简化操作

成员函数mutexlockguard：

public:
    explicit mutexlockguard(mutexlock& mutex):m_mutex(mutex)
    {
        m_mutex.lock();
    }
    ~mutexlockguard()
    {
        m_mutex.unlock();
    }

仅提供构造与析构函数，为了简化对于mutexlock的操作,利用mutexlock引用传参构造，在构造时获得锁,在析构时释放锁。

测试：

//注意mymuduo::currentthread::cacheTid还没写实现，而且currentthread::Tid()也没有实现，在这里仅是测试mutex相关的功能。

#include"base/mutex.h"
#include<thread>
#include <stdio.h>

#include<iostream>

mymuduo::mutexlock mutex;

namespace mymuduo{
namespace currentthread {

void cacheTid()
{
}
}
}

long count=0;
void workerthread1()
{
    for(int i=0;i<100;i++)
    {
        mymuduo::mutexlockguard mlg(mutex);
        count++;
    }
}

int main()
{
  std::thread t[100];
  for(int i=0;i<100;i++)
      t[i]=std::thread(workerthread1);

  for(int i=0;i<100;i++)
      t[i].join();

  std::cout<<count<<std::endl;

}