标签：__ muduo errno void 之六 mutex Mutex holder MutexLock

源码

#pragma once
#include <pthread.h>

#include "NonCopyable.h"
#include "CurrentThread.h"

namespace muduo
{

//@ 检查返回值的宏
#ifdef CHECK_PTHREAD_RETURN_VALUE

#ifdef NDEBUG
    __BEGIN_DECLS
    extern void __assert_perror_fail(int errno, const char *file, unsigned int line, const char *function) noexcept __attribute__((__noreturn__));
    __END_DECLS

#define MCHECK(ret)                                                    \
    ({                                                                 \
        __typeof__(ret) errno = (ret);                                 \
        if (__builtin_expect(errno != 0, 0))                           \
            __assert_perror_fail(errno, __FILE__, __LINE__, __func__); \
    })
#endif

#else //@ CHECK_PTHREAD_RETURN_VALUE
#define MCHECK(ret) ({ __typeof__(ret) errno = (ret); assert(errno == 0); void(errno); })

#endif //@ CHECK_PTHREAD_RETURN_VALUE

    class MutexLock : public NonCopyable
    {
    public:
        MutexLock() : holder_(0)
        {
            MCHECK(pthread_mutex_init(&mutex_, nullptr));
        }

        ~MutexLock()
        {
            assert(holder_ == 0); //@ 保证锁不被持有
            MCHECK(pthread_mutex_destroy(&mutex_));
        }

        bool is_locked_by_this_thread() const
        {
            return holder_ == CurrentThread::tid();
        }

        void assert_locked() const
        {
            assert(is_locked_by_this_thread());
        }

        void lock()
        {
            MCHECK(pthread_mutex_lock(&mutex_));
            assign_holder();
        }

        void unlock()
        {
            unassign_holder();
            MCHECK(pthread_mutex_unlock(&mutex_));
        }

        pthread_mutex *get_mutex() const
        {
            return &mutex_;
        }

    private:
        void assign_holder()
        {
            holder_ = CurrentThread::tid();
        }

        void unassign_holder()
        {
            holder_ = 0;
        }

    private:
        class UnassignGuard : NonCopyable
        {
        public:
            explicit UnassignGuard(MutexLock &owner) : owner_(owner)
            {
                owner_.unassign_holder();
            }

            ~UnassignGuard()
            {
                owner_.assign_holder();
            }

        private:
            MutexLock &owner_;  //@ 存放引用
        };

    private:
        pthread_mutex mutex_;
        pid_t holder_;
    };

    //@ RAII 格式 MutexLock 使用
    class MutexLockGuard : public NonCopyable
    {
    public:
        explicit MutexLockGuard(MutexLock &mutex) : mutex_(mutex)
        {
            mutex_.lock();
        }

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

    private:
        MutexLock &mutex_;
    };

//@ 避免构造一个临时的对象，例如 MutexLockGuard（mutex）,临时对象不能一直持有锁
#define MutexLockGuard(x) error "Missing guard object name"
}

标签：__,muduo,errno,void,之六,mutex,Mutex,holder,MutexLock
来源： https://www.cnblogs.com/xiaojianliu/p/14696717.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。