diy 데이터베이스 (4) -- 잠 금 및 대기 열

자물쇠
1. 상호 배척 자물쇠
      임계 자원 의 상호 배척 방문 을 보장 하 는 데 쓰 인 다.
2. 읽 기와 쓰기 자물쇠
      한 스 레 드 에서 읽 기와 쓰기 자물쇠 의 읽 기 자물쇠 가 신청 되면 다른 스 레 드 는 읽 기 자 물 쇠 를 다시 신청 할 수 있 지만 자 물 쇠 를 신청 할 수 없습니다.
      한 스 레 드 에서 읽 기와 쓰기 자물쇠 에 있 는 쓰기 자물쇠 가 신청 되면 다른 스 레 드 는 읽 기 자 물 쇠 를 신청 할 수 없고 쓰기 자 물 쇠 를 신청 할 수 없습니다.
3. 자전거 자물쇠
      조건 을 기다 릴 때 cpu 를 양보 하지 않 습 니 다.nginx 에 서 는 모든 작업 프로 세 스 가 사용자 에 게 빠 른 응답 을 요구 하기 때문에 자동 잠 금 을 사용 합 니 다.
4. 재 귀 자물쇠
      같은 스 레 드 는 재 귀 자물쇠 에 여러 번 자 물 쇠 를 추가 할 수 있 지만, 같은 여러 번 자 물 쇠 를 풀 어야 합 니 다.
또한 조건 변수 와 신 호 량 을 통 해 스 레 드 간 동기 화 를 한다.
2. diy 데이터베이스 의 잠 금 실현

#ifndef OSSLATCH_HPP__
#define OSSLATCH_HPP__

#include "core.hpp"


#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 )

enum OSS_LATCH_MODE
{
   SHARED ,//  
   EXCLUSIVE//  
} ;

class ossXLatch//   
{
private :
   oss_mutex_t _lock ;
public :
   ossXLatch ()
   {
      oss_mutex_init ( &_lock, 0 ) ;
   }
   ~ossXLatch ()
   {
		oss_mutex_destroy(&_lock);
   }
   void get ()
   {
		oss_mutex_lock(&_lock);
   }
   void release ()
   {
		oss_mutex_unlock(&_lock);
   }
   bool try_get ()
   {
		return oss_mutex_trylock(&_lock);
   }
} ;

class ossSLatch//   
{
private :
   oss_rwlock_t _lock ;
public :
   ossSLatch ()
   {
      oss_rwlock_init ( &_lock, 0 ) ;
   }

   ~ossSLatch ()
   {
      oss_rwlock_destroy ( &_lock ) ;
   }

   void get ()//  
   {
      oss_rwlock_wrlock ( &_lock ) ;
   }

   void release ()
   {
      oss_rwlock_wrunlock ( &_lock ) ;
   }

   bool try_get ()
   {
      return ( oss_rwlock_wrtrylock ( &_lock ) ) ;
   }

   void get_shared ()//  
   {
      oss_rwlock_rdlock ( &_lock ) ;
   }

   void release_shared ()
   {
      oss_rwlock_rdunlock ( &_lock ) ;
   }

   bool try_get_shared ()
   {
      return ( oss_rwlock_rdtrylock ( &_lock ) ) ;
   }
} ;
#endif

(1) 이곳 의 상호 배척 자물쇠 와 공유 자 물 쇠 는 각각 운영 체제 의 상호 배척 자물쇠 와 읽 기와 쓰기 자물쇠 에 대한 간단 한 포장 이다.
(2) 시스템 호출 에 대해 매크로 정의 로 별명 을 얻 고 oss 층 이 플랫폼 관련 시스템 호출 에 대한 패 키 징 사상 을 나 타 냈 다.
(3) 우리 의 데이터 베 이 스 는 스 레 드 탱크 의 구조 로 그 자체 가 스 레 드 전환 을 요구 하기 때문에 자 회전 자물쇠 로 효율 을 높 일 필요 가 없다.
3. 대열 의 개술

#ifndef OSSQUEUE_HPP__
#define OSSQUEUE_HPP__

#include <queue>
#include <boost/thread.hpp>
#include <boost/thread/thread_time.hpp>

#include "core.hpp"

template<typename Data>
class ossQueue
{
private :
   std::queue<Data> _queue ;//  
   boost::mutex _mutex ;//   
   boost::condition_variable _cond ;//    
public :
   unsigned int size ()//    
   {
      boost::mutex::scoped_lock lock ( _mutex ) ;//  
      return (unsigned int)_queue.size () ;
   }

   void push ( Data const &data )//      
   {
      boost::mutex::scoped_lock lock ( _mutex ) ;
      _queue.push ( data ) ;
      lock.unlock () ;//  
      _cond.notify_one () ;//             
   }

   bool empty () const
   {
      boost::mutex::scoped_lock lock ( _mutex ) ;
      return _queue.empty () ;
   }

   bool try_pop ( Data &value )//    
   {
      boost::mutex::scoped_lock lock ( _mutex ) ;
      if ( _queue.empty () )
         return false ;
      value = _queue.front () ;
      _queue.pop () ;
      return true ;
   }

   void wait_and_pop ( Data &value )//      
   {
      boost::mutex::scoped_lock lock ( _mutex ) ;
      while ( _queue.empty () )
      {
         _cond.wait ( lock ) ;//         ，          
      }
      value = _queue.front () ;
      _queue.pop () ;
   }

   bool timed_wait_and_pop ( Data &value, long long millsec )
   {
      boost::system_time const timeout = boost::get_system_time () +
            boost::posix_time::milliseconds(millsec) ;
      boost::mutex::scoped_lock lock ( _mutex ) ;
      // if timed_wait return false, that means we failed by timeout
      while ( _queue.empty () )
      {
         if ( !_cond.timed_wait ( lock, timeout ) )//            
         {
            return false ;
         }
      }
      value = _queue.front () ;
      _queue.pop () ;
      return true ;
   }
} ;
#endif

(1) 다 중 스 레 드 의 메시지 대기 열 은 공유 자원 이기 때문에 대기 열 을 조작 할 때 잠 금 을 추가 해 야 합 니 다.
(2) 스 레 드 간 의 동기 화 는 주로 조건 변수 로 이 루어 지 는데 주의해 야 할 것 은 조건 변수의 사용 은 반드시 상호 배척 자물쇠 와 수반 된다 는 것 이다.
(3) 여기 서 boost 의 상호 배척 자물쇠 와 조건 변 수 를 사 용 했 지만 실제 적 으로 블 로그 의 상호 배척 자물쇠 와 조건 변수 포장 류 를 사용 해도 된다.