[源码阅读]数据库代码阅读笔记_4

源代码链接地址


今天来看的源码文件是位于路径 src/include/ossLatch.hpp 下的文件

---

// ossLatch.hpp

 在该头文件中定义的是数据库中在进行互斥访问数据库中的对象

/*******************************************************************************
   Copyright (C) 2013 SequoiaDB Software Inc.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License, version 3,
   as published by the Free Software Foundation.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU Affero General Public License for more details.

   You should have received a copy of the GNU Affero General Public License
   along with this program. If not, see <http://www.gnu.org/license/>.
*******************************************************************************/
#ifndef OSSLATCH_HPP__
#define OSSLATCH_HPP__

#include "core.hpp"
// 下面的宏定义的是提高数据库软件的可移植性，使得代码无论是在 windows 下面还是 linux 操作系统中
// 都能够以同样的变量、方法名称来调用
// 主要关注 linux 中的系统编程方法

#ifdef _WINDOWS                // 如果操作系统是 windows 那么定义的宏方法便是 windows 中的函数
#define oss_mutex_t                        CRITICAL_SECTION
#define oss_mutex_init(__lock, __attribute)        InitializeCriticalSection( (__lock) )
#define oss_mutex_destroy                DeleteCriticalSection
#define oss_mutex_lock                    EnterCriticalSection
#define oss_mutex_trylock(__lock)        (TRUE == TryEnterCriticalSection( (__lock) ) )
#define oss_mutex_unlock                LeaveCriticalSection

#define oss_rwlock_t                    SRWLOCK
#define oss_rwlock_init(__lock, __attribute)        InitializeSRWLock( (__lock) )
#define oss_rwlock_destroy(__lock)        (1)
#define oss_rwlock_rdlock                AcquireSRWLockShared
#define oss_rwlock_rdunlock                ReleaseSRWLockShared
#define oss_rwlock_wrlock                AcquireSRWLockExclusive
#define oss_rwlock_wrunlock                ReleaseSRWLockExclusive
#define oss_rwlock_rdtrylock(__lock)    (false)
#define oss_rwlock_wrtrylock(__lock)    (false)

#else

#define oss_mutex_t                      pthread_mutex_t        // 互斥量变量
#define oss_mutex_init                   pthread_mutex_init     // 互斥量动态初始化方法
#define oss_mutex_destroy                pthread_mutex_destroy  // 互斥量销毁方法
#define oss_mutex_lock                   pthread_mutex_lock     // 互斥量上锁方法
#define oss_mutex_trylock(__lock)        (pthread_mutex_trylock( (__lock) ) == 0 )
#define oss_mutex_unlock                 pthread_mutex_unlock

#define oss_rwlock_t                     pthread_rwlock_t
#define oss_rwlock_init                  pthread_rwlock_init
#define oss_rwlock_destroy               pthread_rwlock_destroy
#define oss_rwlock_rdlock                pthread_rwlock_rdlock
#define oss_rwlock_rdunlock              pthread_rwlock_unlock
#define oss_rwlock_wrlock                pthread_rwlock_wrlock
#define oss_rwlock_wrunlock              pthread_rwlock_unlock
#define oss_rwlock_rdtrylock(__lock)     (pthread_rwlock_tryrdlock( (__lock) ) == 0 )
#define oss_rwlock_wrtrylock(__lock)     (pthread_rwlock_trywrlock ( ( __lock) ) == 0 )

#endif

enum OSS_LATCH_MODE  // 通过定义枚举变量来定义锁的两种类型
{
   SHARED ,         // SHARED 是共享锁
   EXCLUSIVE        // EXCLUSIVE 是互斥锁/独占锁
} ;

class ossXLatch     //  ossXLatch 类 ， 封装了互斥锁/独占锁
{
private :
   oss_mutex_t _lock ;  // ossXLatch 类中封装的互斥量对象 ,
                        // 互斥量每次允许一个运行单位访问其所保护的对象，功能等同于互斥锁
public :
   ossXLatch ()
   {
      oss_mutex_init ( &_lock, 0 ) ;
   }
   ~ossXLatch ()
   {
        oss_mutex_destroy(&_lock);
   }
// 上面是 ossXLatch 的构建于析构方法

   void get ()
   {
        oss_mutex_lock(&_lock);
   }
//get: 该方法用于获取 ossXLatch 中的私有变量 _lock

   void release ()
   {
        oss_mutex_unlock(&_lock);
   }
//release: 该方法用于释放 _lock 变量

   bool try_get ()
   {
        return oss_mutex_trylock(&_lock);
   }
//try_get: 该方法用于试图获取 _lock 变量，试图对其上锁，如果有其余的线程占用该互斥量保护的资源
//那么此次获取 _lock 便会失败，如果获取失败返回 false， 如果获取成功返回 true
} ;

class ossSLatch  // 封装了共享锁/读写锁 ，既可以用作读锁，也可以用作写锁来使用
{
private :
   oss_rwlock_t _lock ;  // 使用读写锁作为 ossSLatch 的基本类型
public :
   ossSLatch ()
   {
      oss_rwlock_init ( &_lock, 0 ) ;
   }

   ~ossSLatch ()
   {
      oss_rwlock_destroy ( &_lock ) ;
   }
// ossSLatch 的构造函数和析构函数

   void get ()
   {
      oss_rwlock_wrlock ( &_lock ) ;
   }
//get: 该方法用于获取 ossSLatch 类中的私有变量

   void release ()
   {
      oss_rwlock_wrunlock ( &_lock ) ;
   }
//release : 该方法封装了用于释放 _lock 锁对象的方法

   bool try_get ()
   {
      return ( oss_rwlock_wrtrylock ( &_lock ) ) ;
   }
// try_get 该方法中封装的 oss_rwlock_wrtrylock 是通过宏定义来实现的
// 通常的获取锁的方法是在多个线程/进程抢占锁的时候，没有抢占到锁的线程/进程会阻塞到该锁的等待队列上面，进行死等
// 这种处理方法比较麻烦，所以有了 try_get 试上锁的方法，即便是线程/进程获取不到锁资源，也不会阻塞死等，而是立即返回。
// 这种操作机制消耗系统资源比较小
// 如果抢占到了锁，那么锁对象便被赋值给 ossSLatch中的 _lock 变量，返回值为 true， 下一步通过调用 get() 方法便可获得该锁；
// 如果没有抢到，那么返回值为 false

   void get_shared ()
   {
      oss_rwlock_rdlock ( &_lock ) ;
   }
//get_shared: 上面的两个方法是获取写锁的，虽然在方法上面没有标识；而下面的这两个方法是与上面的两个方法相呼应的
// 用于获取读锁，读锁常被用于是共享锁也就是在对某个资源进行读取的时，这种锁锁保护的资源对象可以被多个 线程/进程同时访问（读取）

   void release_shared ()
   {
      oss_rwlock_rdunlock ( &_lock ) ;
   }
// release_shared: 该方法用于释放线程/进程占用的锁资源

   bool try_get_shared ()
   {
      return ( oss_rwlock_rdtrylock ( &_lock ) ) ;
   }
//try_get_shared ：该方法用户试探性的获取读锁，如果成功获取则返回 true，
// 如果没有成功接收，返回 false
} ;

#endif

在这里主要学习使用源码中定义的宏方法中所调用的 pthread 相关方法与变量
[通过链接可以查看函数原型使用方法]

pthread_mutex_t
pthread_mutex_init
pthread_mutex_destroy
pthread_mutex_lock
pthread_mutex_trylock
pthread_mutex_unlock
pthread_rwlock_t
pthread_rwlock_init
pthread_rwlock_destroy
pthread_rwlock_rdlock
pthread_rwlock_unlock
pthread_rwlock_wrlock

end