Linux组件封装(一) 互斥锁MutexLock

由于pthread系列的函数都是成功时返回0，我们需要一段判断处理错误的代码:

#define TINY_CHECK(exp)
        if(!exp)
        {    
            fprintf(stderr, "File : %s, Line : %d Exp : ["#exp"] is true, abort.
", __FILE__, __LINE__); abort();
        }

MutexLock的封装如下:

#ifndef MUTEXLOCK_H
#define MUTEXLOCK_H

#include "NonCopyable.h"
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#define TINY_CHECK(exp)
        if(!exp)
        {    
            fprintf(stderr, "File : %s, Line : %d Exp : ["#exp"] is true, abort.
", __FILE__, __LINE__); abort();
        }



class MutexLock :  NonCopyable
{
    friend class Condition;
public:
    MutexLock();
    ~MutexLock();
    void lock();
    void unlock();

    bool isLocked() const { return _isLock; }
    pthread_mutex_t *getMutexPtr() { return &_mutex; }

private:
    void restoreMutexStatus()
    { _isLock = true; }

    pthread_mutex_t _mutex;
    bool _isLock;
};


class MutexLockGuard : NonCopyable            //将锁封装到MutexLockGuard中，
{                                            //这样只需定义一个对象，便可
public:                                        //便可自动上锁，对象销毁时自动解锁
    MutexLockGuard(MutexLock &mutex)
        :_mutex(mutex)
    { _mutex.lock(); }

    ~MutexLockGuard()
    { _mutex.unlock(); }

private:
    MutexLock &_mutex;
};
#define MutexLockGuard(m) "ERROR"

#endif

cpp文件如下:

#include "MutexLock.h"
#include <assert.h>

MutexLock::MutexLock()
    :_isLock(false)
{
    TINY_CHECK(!pthread_mutex_init(&_mutex, NULL));
}

MutexLock::~MutexLock()
{
    assert(!isLocked());
    TINY_CHECK(!pthread_mutex_destroy(&_mutex));
}

void MutexLock::lock()
{
    TINY_CHECK(!pthread_mutex_lock(&_mutex));
    _isLock = true;
}

void MutexLock::unlock()
{
    _isLock = false;
    TINY_CHECK(!pthread_mutex_unlock(&_mutex));
}

当然，有一种使用方式是错误的，例如:

size_t Buffer::size() const
{
    MutexLockGuard(mutex_);
    return queue_.size();
}

这段代码的加锁周期仅在那一行有效，所以该种方法是错误的，所以，我们定义一个宏:

#define MutexLockGuard(m) "Error"

这样当错误使用时，会导致编译错误，使我们早些发现问题。